--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1996-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 Emusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** L3.h ***************************************************
+
+ Layer III structures
+
+ *** Layer III is 32 bit only ***
+ *** Layer III code assumes 32 bit int ***
+
+******************************************************************/
+
+#define GLOBAL_GAIN_SCALE (4*15)
+/* #define GLOBAL_GAIN_SCALE 0 */
+
+
+#ifdef _M_IX86
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef _M_ALPHA
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef sparc
+#define LITTLE_ENDIAN 0
+#endif
+
+#ifndef LITTLE_ENDIAN
+#error Layer III LITTLE_ENDIAN must be defined 0 or 1
+#endif
+
+/*-----------------------------------------------------------*/
+/*---- huffman lookup tables ---*/
+/* endian dependent !!! */
+#if LITTLE_ENDIAN
+typedef union
+{
+ int ptr;
+ struct
+ {
+ unsigned char signbits;
+ unsigned char x;
+ unsigned char y;
+ unsigned char purgebits; // 0 = esc
+
+ }
+ b;
+}
+HUFF_ELEMENT;
+
+#else /* big endian machines */
+typedef union
+{
+ int ptr; /* int must be 32 bits or more */
+ struct
+ {
+ unsigned char purgebits; // 0 = esc
+
+ unsigned char y;
+ unsigned char x;
+ unsigned char signbits;
+ }
+ b;
+}
+HUFF_ELEMENT;
+
+#endif
+/*--------------------------------------------------------------*/
+typedef struct
+{
+ unsigned int bitbuf;
+ int bits;
+ unsigned char *bs_ptr;
+ unsigned char *bs_ptr0;
+ unsigned char *bs_ptr_end; // optional for overrun test
+
+}
+BITDAT;
+
+/*-- side info ---*/
+typedef struct
+{
+ int part2_3_length;
+ int big_values;
+ int global_gain;
+ int scalefac_compress;
+ int window_switching_flag;
+ int block_type;
+ int mixed_block_flag;
+ int table_select[3];
+ int subblock_gain[3];
+ int region0_count;
+ int region1_count;
+ int preflag;
+ int scalefac_scale;
+ int count1table_select;
+}
+GR;
+typedef struct
+{
+ int mode;
+ int mode_ext;
+/*---------------*/
+ int main_data_begin; /* beginning, not end, my spec wrong */
+ int private_bits;
+/*---------------*/
+ int scfsi[2]; /* 4 bit flags [ch] */
+ GR gr[2][2]; /* [gran][ch] */
+}
+SIDE_INFO;
+
+/*-----------------------------------------------------------*/
+/*-- scale factors ---*/
+// check dimensions - need 21 long, 3*12 short
+// plus extra for implicit sf=0 above highest cb
+typedef struct
+{
+ int l[23]; /* [cb] */
+ int s[3][13]; /* [window][cb] */
+}
+SCALEFACT;
+
+/*-----------------------------------------------------------*/
+typedef struct
+{
+ int cbtype; /* long=0 short=1 */
+ int cbmax; /* max crit band */
+// int lb_type; /* long block type 0 1 3 */
+ int cbs0; /* short band start index 0 3 12 (12=no shorts */
+ int ncbl; /* number long cb's 0 8 21 */
+ int cbmax_s[3]; /* cbmax by individual short blocks */
+}
+CB_INFO;
+
+/*-----------------------------------------------------------*/
+/* scale factor infor for MPEG2 intensity stereo */
+typedef struct
+{
+ int nr[3];
+ int slen[3];
+ int intensity_scale;
+}
+IS_SF_INFO;
+
+/*-----------------------------------------------------------*/
+typedef union
+{
+ int s;
+ float x;
+}
+SAMPLE;
+
+/*-----------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License}, {or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not}, {write to the Free Software
+ Foundation}, {Inc.}, {675 Mass Ave}, {Cambridge}, {MA 02139}, {USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/* TABLE 1 4 entries maxbits 3 linbits 0 */
+static HUFF_ELEMENT huff_table_1[] =
+{
+ {0xFF000003}, {0x03010102}, {0x03010001}, {0x02000101}, {0x02000101}, /* 4 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},
+};
+
+/* max table bits 3 */
+
+/* TABLE 2 9 entries maxbits 6 linbits 0 */
+static HUFF_ELEMENT huff_table_2[] =
+{
+ {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102}, /* 4 */
+ {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03010102}, /* 9 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 14 */
+ {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001}, /* 19 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 24 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 29 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000}, /* 34 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 39 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 44 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 49 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 54 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 59 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 64 */
+};
+
+/* max table bits 6 */
+
+/* TABLE 3 9 entries maxbits 6 linbits 0 */
+static HUFF_ELEMENT huff_table_3[] =
+{
+ {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102}, /* 4 */
+ {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03000101}, /* 9 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 14 */
+ {0x03000101}, {0x03000101}, {0x02010102}, {0x02010102}, {0x02010102}, /* 19 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 24 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 29 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010001}, {0x02010001}, /* 34 */
+ {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, /* 39 */
+ {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, /* 44 */
+ {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02000000}, /* 49 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 54 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 59 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 64 */
+};
+
+/* max table bits 6 */
+/* NO XING TABLE 4 */
+
+/* TABLE 5 16 entries maxbits 8 linbits 0 */
+static HUFF_ELEMENT huff_table_5[] =
+{
+ {0xFF000008}, {0x08030302}, {0x08030202}, {0x07020302}, {0x07020302}, /* 4 */
+ {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030102}, /* 9 */
+ {0x07030102}, {0x07030001}, {0x07030001}, {0x07000301}, {0x07000301}, /* 14 */
+ {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102}, {0x06020102}, /* 19 */
+ {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202}, {0x06010202}, /* 24 */
+ {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201}, /* 29 */
+ {0x06000201}, {0x06000201}, {0x06000201}, {0x03010102}, {0x03010102}, /* 34 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 39 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 44 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 49 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 54 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 59 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 64 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 69 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 74 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 79 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 84 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 89 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 94 */
+ {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, /* 99 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 104 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 109 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 114 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 119 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 124 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, /* 129 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 134 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 139 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 144 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 149 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 154 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 159 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 164 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 169 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 174 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 179 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 184 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 189 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 194 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 199 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 204 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 209 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 214 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 219 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 224 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 229 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 234 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 239 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 244 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 249 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 254 */
+ {0x01000000}, {0x01000000},
+};
+
+/* max table bits 8 */
+
+/* TABLE 6 16 entries maxbits 7 linbits 0 */
+static HUFF_ELEMENT huff_table_6[] =
+{
+ {0xFF000007}, {0x07030302}, {0x07030001}, {0x06030202}, {0x06030202}, /* 4 */
+ {0x06020302}, {0x06020302}, {0x06000301}, {0x06000301}, {0x05030102}, /* 9 */
+ {0x05030102}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302}, /* 14 */
+ {0x05010302}, {0x05010302}, {0x05020202}, {0x05020202}, {0x05020202}, /* 19 */
+ {0x05020202}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, /* 24 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 29 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202}, /* 34 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, /* 39 */
+ {0x04010202}, {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201}, /* 44 */
+ {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201}, {0x03010001}, /* 49 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 54 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 59 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 64 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 69 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 74 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 79 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 84 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 89 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 94 */
+ {0x02010102}, {0x02010102}, {0x03000101}, {0x03000101}, {0x03000101}, /* 99 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 104 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 109 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000}, /* 114 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 119 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 124 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},
+};
+
+/* max table bits 7 */
+
+/* TABLE 7 36 entries maxbits 10 linbits 0 */
+static HUFF_ELEMENT huff_table_7[] =
+{
+ {0xFF000006}, {0x00000041}, {0x00000052}, {0x0000005B}, {0x00000060}, /* 4 */
+ {0x00000063}, {0x00000068}, {0x0000006B}, {0x06020102}, {0x05010202}, /* 9 */
+ {0x05010202}, {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102}, /* 14 */
+ {0x04010102}, {0x04010102}, {0x03010001}, {0x03010001}, {0x03010001}, /* 19 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 24 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 29 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000}, /* 34 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 39 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 44 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 49 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 54 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 59 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 64 */
+ {0xFF000004}, {0x04050502}, {0x04050402}, {0x04040502}, {0x04030502}, /* 69 */
+ {0x03050302}, {0x03050302}, {0x03040402}, {0x03040402}, {0x03050202}, /* 74 */
+ {0x03050202}, {0x03020502}, {0x03020502}, {0x02050102}, {0x02050102}, /* 79 */
+ {0x02050102}, {0x02050102}, {0xFF000003}, {0x02010502}, {0x02010502}, /* 84 */
+ {0x03050001}, {0x03040302}, {0x02000501}, {0x02000501}, {0x03030402}, /* 89 */
+ {0x03030302}, {0xFF000002}, {0x02040202}, {0x02020402}, {0x01040102}, /* 94 */
+ {0x01040102}, {0xFF000001}, {0x01010402}, {0x01000401}, {0xFF000002}, /* 99 */
+ {0x02040001}, {0x02030202}, {0x02020302}, {0x02030001}, {0xFF000001}, /* 104 */
+ {0x01030102}, {0x01010302}, {0xFF000001}, {0x01000301}, {0x01020202}, /* 109 */
+};
+
+/* max table bits 6 */
+
+/* TABLE 8 36 entries maxbits 11 linbits 0 */
+static HUFF_ELEMENT huff_table_8[] =
+{
+ {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x08050102}, /* 4 */
+ {0x08010502}, {0x00000112}, {0x00000115}, {0x08040202}, {0x08020402}, /* 9 */
+ {0x08040102}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08000401}, /* 14 */
+ {0x08030202}, {0x08020302}, {0x08030102}, {0x08010302}, {0x08030001}, /* 19 */
+ {0x08000301}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202}, /* 24 */
+ {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201}, /* 29 */
+ {0x06000201}, {0x06000201}, {0x06000201}, {0x04020102}, {0x04020102}, /* 34 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 39 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 44 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202}, /* 49 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, /* 54 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, /* 59 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, /* 64 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 69 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 74 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 79 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 84 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 89 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 94 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 99 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 104 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 109 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 114 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 119 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, /* 124 */
+ {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x03010001}, /* 129 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 134 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 139 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 144 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 149 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 154 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 159 */
+ {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 164 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 169 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 174 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 179 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 184 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 189 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000}, /* 194 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 199 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 204 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 209 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 214 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 219 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 224 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 229 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 234 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 239 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 244 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 249 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 254 */
+ {0x02000000}, {0x02000000}, {0xFF000003}, {0x03050502}, {0x03040502}, /* 259 */
+ {0x02050402}, {0x02050402}, {0x01030502}, {0x01030502}, {0x01030502}, /* 264 */
+ {0x01030502}, {0xFF000002}, {0x02050302}, {0x02040402}, {0x01050202}, /* 269 */
+ {0x01050202}, {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001}, /* 274 */
+ {0x01040302}, {0x01030402}, {0xFF000001}, {0x01000501}, {0x01030302}, /* 279 */
+};
+
+/* max table bits 8 */
+
+/* TABLE 9 36 entries maxbits 9 linbits 0 */
+static HUFF_ELEMENT huff_table_9[] =
+{
+ {0xFF000006}, {0x00000041}, {0x0000004A}, {0x0000004F}, {0x00000052}, /* 4 */
+ {0x00000057}, {0x0000005A}, {0x06040102}, {0x06010402}, {0x06030202}, /* 9 */
+ {0x06020302}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302}, /* 14 */
+ {0x06030001}, {0x06000301}, {0x05020202}, {0x05020202}, {0x05020001}, /* 19 */
+ {0x05020001}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 24 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04000201}, /* 29 */
+ {0x04000201}, {0x04000201}, {0x04000201}, {0x03010102}, {0x03010102}, /* 34 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 39 */
+ {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 44 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101}, /* 49 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 54 */
+ {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000}, {0x03000000}, /* 59 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 64 */
+ {0xFF000003}, {0x03050502}, {0x03050402}, {0x02050302}, {0x02050302}, /* 69 */
+ {0x02030502}, {0x02030502}, {0x03040502}, {0x03050001}, {0xFF000002}, /* 74 */
+ {0x02040402}, {0x02050202}, {0x02020502}, {0x02050102}, {0xFF000001}, /* 79 */
+ {0x01010502}, {0x01040302}, {0xFF000002}, {0x01030402}, {0x01030402}, /* 84 */
+ {0x02000501}, {0x02040001}, {0xFF000001}, {0x01040202}, {0x01020402}, /* 89 */
+ {0xFF000001}, {0x01030302}, {0x01000401},
+};
+
+/* max table bits 6 */
+
+/* TABLE 10 64 entries maxbits 11 linbits 0 */
+static HUFF_ELEMENT huff_table_10[] =
+{
+ {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x00000118}, /* 4 */
+ {0x0000011B}, {0x00000120}, {0x00000125}, {0x08070102}, {0x08010702}, /* 9 */
+ {0x0000012A}, {0x0000012D}, {0x00000132}, {0x08060102}, {0x08010602}, /* 14 */
+ {0x08000601}, {0x00000137}, {0x0000013A}, {0x0000013D}, {0x08040102}, /* 19 */
+ {0x08010402}, {0x08000401}, {0x08030202}, {0x08020302}, {0x08030001}, /* 24 */
+ {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302}, {0x07000301}, /* 29 */
+ {0x07000301}, {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102}, /* 34 */
+ {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202}, /* 39 */
+ {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, /* 44 */
+ {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x04010102}, /* 49 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 54 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 59 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 64 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 69 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 74 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 79 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 84 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 89 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 94 */
+ {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, /* 99 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 104 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 109 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 114 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 119 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 124 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, /* 129 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 134 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 139 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 144 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 149 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 154 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 159 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 164 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 169 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 174 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 179 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 184 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 189 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 194 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 199 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 204 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 209 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 214 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 219 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 224 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 229 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 234 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 239 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 244 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 249 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 254 */
+ {0x01000000}, {0x01000000}, {0xFF000003}, {0x03070702}, {0x03070602}, /* 259 */
+ {0x03060702}, {0x03070502}, {0x03050702}, {0x03060602}, {0x02070402}, /* 264 */
+ {0x02070402}, {0xFF000002}, {0x02040702}, {0x02060502}, {0x02050602}, /* 269 */
+ {0x02070302}, {0xFF000003}, {0x02030702}, {0x02030702}, {0x02060402}, /* 274 */
+ {0x02060402}, {0x03050502}, {0x03040502}, {0x02030602}, {0x02030602}, /* 279 */
+ {0xFF000001}, {0x01070202}, {0x01020702}, {0xFF000002}, {0x02040602}, /* 284 */
+ {0x02070001}, {0x01000701}, {0x01000701}, {0xFF000002}, {0x01020602}, /* 289 */
+ {0x01020602}, {0x02050402}, {0x02050302}, {0xFF000002}, {0x01060001}, /* 294 */
+ {0x01060001}, {0x02030502}, {0x02040402}, {0xFF000001}, {0x01060302}, /* 299 */
+ {0x01060202}, {0xFF000002}, {0x02050202}, {0x02020502}, {0x01050102}, /* 304 */
+ {0x01050102}, {0xFF000002}, {0x01010502}, {0x01010502}, {0x02040302}, /* 309 */
+ {0x02030402}, {0xFF000001}, {0x01050001}, {0x01000501}, {0xFF000001}, /* 314 */
+ {0x01040202}, {0x01020402}, {0xFF000001}, {0x01030302}, {0x01040001}, /* 319 */
+};
+
+/* max table bits 8 */
+
+/* TABLE 11 64 entries maxbits 11 linbits 0 */
+static HUFF_ELEMENT huff_table_11[] =
+{
+ {0xFF000008}, {0x00000101}, {0x00000106}, {0x0000010F}, {0x00000114}, /* 4 */
+ {0x00000117}, {0x08070202}, {0x08020702}, {0x0000011C}, {0x07010702}, /* 9 */
+ {0x07010702}, {0x08070102}, {0x08000701}, {0x08060302}, {0x08030602}, /* 14 */
+ {0x08000601}, {0x0000011F}, {0x00000122}, {0x08050102}, {0x07020602}, /* 19 */
+ {0x07020602}, {0x08060202}, {0x08060001}, {0x07060102}, {0x07060102}, /* 24 */
+ {0x07010602}, {0x07010602}, {0x08010502}, {0x08040302}, {0x08000501}, /* 29 */
+ {0x00000125}, {0x08040202}, {0x08020402}, {0x08040102}, {0x08010402}, /* 34 */
+ {0x08040001}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07020302}, /* 39 */
+ {0x07020302}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102}, /* 44 */
+ {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030001}, /* 49 */
+ {0x07030001}, {0x07000301}, {0x07000301}, {0x06020202}, {0x06020202}, /* 54 */
+ {0x06020202}, {0x06020202}, {0x05010202}, {0x05010202}, {0x05010202}, /* 59 */
+ {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, /* 64 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 69 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 74 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 79 */
+ {0x04020102}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, /* 84 */
+ {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201}, /* 89 */
+ {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, /* 94 */
+ {0x05000201}, {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102}, /* 99 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 104 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 109 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 114 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 119 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 124 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010001}, /* 129 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 134 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 139 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 144 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 149 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 154 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 159 */
+ {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 164 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 169 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 174 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 179 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 184 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 189 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000}, /* 194 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 199 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 204 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 209 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 214 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 219 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 224 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 229 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 234 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 239 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 244 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 249 */
+ {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 254 */
+ {0x02000000}, {0x02000000}, {0xFF000002}, {0x02070702}, {0x02070602}, /* 259 */
+ {0x02060702}, {0x02050702}, {0xFF000003}, {0x02060602}, {0x02060602}, /* 264 */
+ {0x02070402}, {0x02070402}, {0x02040702}, {0x02040702}, {0x03070502}, /* 269 */
+ {0x03050502}, {0xFF000002}, {0x02060502}, {0x02050602}, {0x01070302}, /* 274 */
+ {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000002}, /* 279 */
+ {0x02050402}, {0x02040502}, {0x02050302}, {0x02030502}, {0xFF000001}, /* 284 */
+ {0x01040602}, {0x01070001}, {0xFF000001}, {0x01040402}, {0x01050202}, /* 289 */
+ {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001}, {0x01030402}, /* 294 */
+ {0x01030302},
+};
+
+/* max table bits 8 */
+
+/* TABLE 12 64 entries maxbits 10 linbits 0 */
+static HUFF_ELEMENT huff_table_12[] =
+{
+ {0xFF000007}, {0x00000081}, {0x0000008A}, {0x0000008F}, {0x00000092}, /* 4 */
+ {0x00000097}, {0x0000009A}, {0x0000009D}, {0x000000A2}, {0x000000A5}, /* 9 */
+ {0x000000A8}, {0x07060202}, {0x07020602}, {0x07010602}, {0x000000AD}, /* 14 */
+ {0x000000B0}, {0x000000B3}, {0x07050102}, {0x07010502}, {0x07040302}, /* 19 */
+ {0x07030402}, {0x000000B6}, {0x07040202}, {0x07020402}, {0x07040102}, /* 24 */
+ {0x06030302}, {0x06030302}, {0x06010402}, {0x06010402}, {0x06030202}, /* 29 */
+ {0x06030202}, {0x06020302}, {0x06020302}, {0x07000401}, {0x07030001}, /* 34 */
+ {0x06000301}, {0x06000301}, {0x05030102}, {0x05030102}, {0x05030102}, /* 39 */
+ {0x05030102}, {0x05010302}, {0x05010302}, {0x05010302}, {0x05010302}, /* 44 */
+ {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x04020102}, /* 49 */
+ {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, /* 54 */
+ {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202}, {0x04010202}, /* 59 */
+ {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, /* 64 */
+ {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201}, /* 69 */
+ {0x05000201}, {0x05000201}, {0x05000201}, {0x04000000}, {0x04000000}, /* 74 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 79 */
+ {0x04000000}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 84 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 89 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 94 */
+ {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001}, /* 99 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 104 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, /* 109 */
+ {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, /* 114 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 119 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 124 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0xFF000003}, /* 129 */
+ {0x03070702}, {0x03070602}, {0x02060702}, {0x02060702}, {0x02070502}, /* 134 */
+ {0x02070502}, {0x02050702}, {0x02050702}, {0xFF000002}, {0x02060602}, /* 139 */
+ {0x02070402}, {0x02040702}, {0x02050602}, {0xFF000001}, {0x01060502}, /* 144 */
+ {0x01070302}, {0xFF000002}, {0x02030702}, {0x02050502}, {0x01070202}, /* 149 */
+ {0x01070202}, {0xFF000001}, {0x01020702}, {0x01060402}, {0xFF000001}, /* 154 */
+ {0x01040602}, {0x01070102}, {0xFF000002}, {0x01010702}, {0x01010702}, /* 159 */
+ {0x02070001}, {0x02000701}, {0xFF000001}, {0x01060302}, {0x01030602}, /* 164 */
+ {0xFF000001}, {0x01050402}, {0x01040502}, {0xFF000002}, {0x01040402}, /* 169 */
+ {0x01040402}, {0x02060001}, {0x02050001}, {0xFF000001}, {0x01060102}, /* 174 */
+ {0x01000601}, {0xFF000001}, {0x01050302}, {0x01030502}, {0xFF000001}, /* 179 */
+ {0x01050202}, {0x01020502}, {0xFF000001}, {0x01000501}, {0x01040001}, /* 184 */
+};
+
+/* max table bits 7 */
+
+/* TABLE 13 256 entries maxbits 19 linbits 0 */
+static HUFF_ELEMENT huff_table_13[] =
+{
+ {0xFF000006}, {0x00000041}, {0x00000082}, {0x000000C3}, {0x000000E4}, /* 4 */
+ {0x00000105}, {0x00000116}, {0x0000011F}, {0x00000130}, {0x00000139}, /* 9 */
+ {0x0000013E}, {0x00000143}, {0x00000146}, {0x06020102}, {0x06010202}, /* 14 */
+ {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102}, {0x04010102}, /* 19 */
+ {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 24 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 29 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000}, /* 34 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 39 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 44 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 49 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 54 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 59 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 64 */
+ {0xFF000006}, {0x00000108}, {0x00000111}, {0x0000011A}, {0x00000123}, /* 69 */
+ {0x0000012C}, {0x00000131}, {0x00000136}, {0x0000013F}, {0x00000144}, /* 74 */
+ {0x00000147}, {0x0000014C}, {0x00000151}, {0x00000156}, {0x0000015B}, /* 79 */
+ {0x060F0102}, {0x06010F02}, {0x06000F01}, {0x00000160}, {0x00000163}, /* 84 */
+ {0x00000166}, {0x06020E02}, {0x00000169}, {0x060E0102}, {0x06010E02}, /* 89 */
+ {0x0000016C}, {0x0000016F}, {0x00000172}, {0x00000175}, {0x00000178}, /* 94 */
+ {0x0000017B}, {0x06060C02}, {0x060D0302}, {0x0000017E}, {0x060D0202}, /* 99 */
+ {0x06020D02}, {0x060D0102}, {0x06070B02}, {0x00000181}, {0x00000184}, /* 104 */
+ {0x06030C02}, {0x00000187}, {0x060B0402}, {0x05010D02}, {0x05010D02}, /* 109 */
+ {0x060D0001}, {0x06000D01}, {0x060A0802}, {0x06080A02}, {0x060C0402}, /* 114 */
+ {0x06040C02}, {0x060B0602}, {0x06060B02}, {0x050C0302}, {0x050C0302}, /* 119 */
+ {0x050C0202}, {0x050C0202}, {0x05020C02}, {0x05020C02}, {0x050B0502}, /* 124 */
+ {0x050B0502}, {0x06050B02}, {0x06090802}, {0x050C0102}, {0x050C0102}, /* 129 */
+ {0xFF000006}, {0x05010C02}, {0x05010C02}, {0x06080902}, {0x060C0001}, /* 134 */
+ {0x05000C01}, {0x05000C01}, {0x06040B02}, {0x060A0602}, {0x06060A02}, /* 139 */
+ {0x06090702}, {0x050B0302}, {0x050B0302}, {0x05030B02}, {0x05030B02}, /* 144 */
+ {0x06080802}, {0x060A0502}, {0x050B0202}, {0x050B0202}, {0x06050A02}, /* 149 */
+ {0x06090602}, {0x05040A02}, {0x05040A02}, {0x06080702}, {0x06070802}, /* 154 */
+ {0x05040902}, {0x05040902}, {0x06070702}, {0x06060702}, {0x04020B02}, /* 159 */
+ {0x04020B02}, {0x04020B02}, {0x04020B02}, {0x040B0102}, {0x040B0102}, /* 164 */
+ {0x040B0102}, {0x040B0102}, {0x04010B02}, {0x04010B02}, {0x04010B02}, /* 169 */
+ {0x04010B02}, {0x050B0001}, {0x050B0001}, {0x05000B01}, {0x05000B01}, /* 174 */
+ {0x05060902}, {0x05060902}, {0x050A0402}, {0x050A0402}, {0x050A0302}, /* 179 */
+ {0x050A0302}, {0x05030A02}, {0x05030A02}, {0x05090502}, {0x05090502}, /* 184 */
+ {0x05050902}, {0x05050902}, {0x040A0202}, {0x040A0202}, {0x040A0202}, /* 189 */
+ {0x040A0202}, {0x04020A02}, {0x04020A02}, {0x04020A02}, {0x04020A02}, /* 194 */
+ {0xFF000005}, {0x040A0102}, {0x040A0102}, {0x04010A02}, {0x04010A02}, /* 199 */
+ {0x050A0001}, {0x05080602}, {0x04000A01}, {0x04000A01}, {0x05060802}, /* 204 */
+ {0x05090402}, {0x04030902}, {0x04030902}, {0x05090302}, {0x05080502}, /* 209 */
+ {0x05050802}, {0x05070602}, {0x04090202}, {0x04090202}, {0x04020902}, /* 214 */
+ {0x04020902}, {0x05070502}, {0x05050702}, {0x04080302}, {0x04080302}, /* 219 */
+ {0x04030802}, {0x04030802}, {0x05060602}, {0x05070402}, {0x05040702}, /* 224 */
+ {0x05060502}, {0x05050602}, {0x05030702}, {0xFF000005}, {0x03090102}, /* 229 */
+ {0x03090102}, {0x03090102}, {0x03090102}, {0x03010902}, {0x03010902}, /* 234 */
+ {0x03010902}, {0x03010902}, {0x04090001}, {0x04090001}, {0x04000901}, /* 239 */
+ {0x04000901}, {0x04080402}, {0x04080402}, {0x04040802}, {0x04040802}, /* 244 */
+ {0x04020702}, {0x04020702}, {0x05060402}, {0x05040602}, {0x03080202}, /* 249 */
+ {0x03080202}, {0x03080202}, {0x03080202}, {0x03020802}, {0x03020802}, /* 254 */
+ {0x03020802}, {0x03020802}, {0x03080102}, {0x03080102}, {0x03080102}, /* 259 */
+ {0x03080102}, {0xFF000004}, {0x04070302}, {0x04070202}, {0x03070102}, /* 264 */
+ {0x03070102}, {0x03010702}, {0x03010702}, {0x04050502}, {0x04070001}, /* 269 */
+ {0x04000701}, {0x04060302}, {0x04030602}, {0x04050402}, {0x04040502}, /* 274 */
+ {0x04060202}, {0x04020602}, {0x04050302}, {0xFF000003}, {0x02010802}, /* 279 */
+ {0x02010802}, {0x03080001}, {0x03000801}, {0x03060102}, {0x03010602}, /* 284 */
+ {0x03060001}, {0x03000601}, {0xFF000004}, {0x04030502}, {0x04040402}, /* 289 */
+ {0x03050202}, {0x03050202}, {0x03020502}, {0x03020502}, {0x03050001}, /* 294 */
+ {0x03050001}, {0x02050102}, {0x02050102}, {0x02050102}, {0x02050102}, /* 299 */
+ {0x02010502}, {0x02010502}, {0x02010502}, {0x02010502}, {0xFF000003}, /* 304 */
+ {0x03040302}, {0x03030402}, {0x03000501}, {0x03040202}, {0x03020402}, /* 309 */
+ {0x03030302}, {0x02040102}, {0x02040102}, {0xFF000002}, {0x01010402}, /* 314 */
+ {0x01010402}, {0x02040001}, {0x02000401}, {0xFF000002}, {0x02030202}, /* 319 */
+ {0x02020302}, {0x01030102}, {0x01030102}, {0xFF000001}, {0x01010302}, /* 324 */
+ {0x01030001}, {0xFF000001}, {0x01000301}, {0x01020202}, {0xFF000003}, /* 329 */
+ {0x00000082}, {0x0000008B}, {0x0000008E}, {0x00000091}, {0x00000094}, /* 334 */
+ {0x00000097}, {0x030C0E02}, {0x030D0D02}, {0xFF000003}, {0x00000093}, /* 339 */
+ {0x030E0B02}, {0x030B0E02}, {0x030F0902}, {0x03090F02}, {0x030A0E02}, /* 344 */
+ {0x030D0B02}, {0x030B0D02}, {0xFF000003}, {0x030F0802}, {0x03080F02}, /* 349 */
+ {0x030C0C02}, {0x0000008D}, {0x030E0802}, {0x00000090}, {0x02070F02}, /* 354 */
+ {0x02070F02}, {0xFF000003}, {0x020A0D02}, {0x020A0D02}, {0x030D0A02}, /* 359 */
+ {0x030C0B02}, {0x030B0C02}, {0x03060F02}, {0x020F0602}, {0x020F0602}, /* 364 */
+ {0xFF000002}, {0x02080E02}, {0x020F0502}, {0x020D0902}, {0x02090D02}, /* 369 */
+ {0xFF000002}, {0x02050F02}, {0x02070E02}, {0x020C0A02}, {0x020B0B02}, /* 374 */
+ {0xFF000003}, {0x020F0402}, {0x020F0402}, {0x02040F02}, {0x02040F02}, /* 379 */
+ {0x030A0C02}, {0x03060E02}, {0x02030F02}, {0x02030F02}, {0xFF000002}, /* 384 */
+ {0x010F0302}, {0x010F0302}, {0x020D0802}, {0x02080D02}, {0xFF000001}, /* 389 */
+ {0x010F0202}, {0x01020F02}, {0xFF000002}, {0x020E0602}, {0x020C0902}, /* 394 */
+ {0x010F0001}, {0x010F0001}, {0xFF000002}, {0x02090C02}, {0x020E0502}, /* 399 */
+ {0x010B0A02}, {0x010B0A02}, {0xFF000002}, {0x020D0702}, {0x02070D02}, /* 404 */
+ {0x010E0402}, {0x010E0402}, {0xFF000002}, {0x02080C02}, {0x02060D02}, /* 409 */
+ {0x010E0302}, {0x010E0302}, {0xFF000002}, {0x01090B02}, {0x01090B02}, /* 414 */
+ {0x020B0902}, {0x020A0A02}, {0xFF000001}, {0x010A0B02}, {0x01050E02}, /* 419 */
+ {0xFF000001}, {0x01040E02}, {0x010C0802}, {0xFF000001}, {0x010D0602}, /* 424 */
+ {0x01030E02}, {0xFF000001}, {0x010E0202}, {0x010E0001}, {0xFF000001}, /* 429 */
+ {0x01000E01}, {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702}, /* 434 */
+ {0xFF000001}, {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802}, /* 439 */
+ {0x01080B02}, {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001}, /* 444 */
+ {0x01090A02}, {0x010C0602}, {0xFF000001}, {0x01030D02}, {0x010B0702}, /* 449 */
+ {0xFF000001}, {0x010C0502}, {0x01050C02}, {0xFF000001}, {0x01090902}, /* 454 */
+ {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x01070902}, {0xFF000003}, /* 459 */
+ {0x00000023}, {0x030D0F02}, {0x020D0E02}, {0x020D0E02}, {0x010F0F02}, /* 464 */
+ {0x010F0F02}, {0x010F0F02}, {0x010F0F02}, {0xFF000001}, {0x010F0E02}, /* 469 */
+ {0x010F0D02}, {0xFF000001}, {0x010E0E02}, {0x010F0C02}, {0xFF000001}, /* 474 */
+ {0x010E0D02}, {0x010F0B02}, {0xFF000001}, {0x010B0F02}, {0x010E0C02}, /* 479 */
+ {0xFF000002}, {0x010C0D02}, {0x010C0D02}, {0x020F0A02}, {0x02090E02}, /* 484 */
+ {0xFF000001}, {0x010A0F02}, {0x010D0C02}, {0xFF000001}, {0x010E0A02}, /* 489 */
+ {0x010E0902}, {0xFF000001}, {0x010F0702}, {0x010E0702}, {0xFF000001}, /* 494 */
+ {0x010E0F02}, {0x010C0F02},
+};
+
+/* max table bits 6 */
+/* NO XING TABLE 14 */
+
+/* TABLE 15 256 entries maxbits 13 linbits 0 */
+static HUFF_ELEMENT huff_table_15[] =
+{
+ {0xFF000008}, {0x00000101}, {0x00000122}, {0x00000143}, {0x00000154}, /* 4 */
+ {0x00000165}, {0x00000176}, {0x0000017F}, {0x00000188}, {0x00000199}, /* 9 */
+ {0x000001A2}, {0x000001AB}, {0x000001B4}, {0x000001BD}, {0x000001C2}, /* 14 */
+ {0x000001CB}, {0x000001D4}, {0x000001D9}, {0x000001DE}, {0x000001E3}, /* 19 */
+ {0x000001E8}, {0x000001ED}, {0x000001F2}, {0x000001F7}, {0x000001FC}, /* 24 */
+ {0x00000201}, {0x00000204}, {0x00000207}, {0x0000020A}, {0x0000020F}, /* 29 */
+ {0x00000212}, {0x00000215}, {0x0000021A}, {0x0000021D}, {0x00000220}, /* 34 */
+ {0x08010902}, {0x00000223}, {0x00000226}, {0x00000229}, {0x0000022C}, /* 39 */
+ {0x0000022F}, {0x08080202}, {0x08020802}, {0x08080102}, {0x08010802}, /* 44 */
+ {0x00000232}, {0x00000235}, {0x00000238}, {0x0000023B}, {0x08070202}, /* 49 */
+ {0x08020702}, {0x08040602}, {0x08070102}, {0x08050502}, {0x08010702}, /* 54 */
+ {0x0000023E}, {0x08060302}, {0x08030602}, {0x08050402}, {0x08040502}, /* 59 */
+ {0x08060202}, {0x08020602}, {0x08060102}, {0x00000241}, {0x08050302}, /* 64 */
+ {0x07010602}, {0x07010602}, {0x08030502}, {0x08040402}, {0x07050202}, /* 69 */
+ {0x07050202}, {0x07020502}, {0x07020502}, {0x07050102}, {0x07050102}, /* 74 */
+ {0x07010502}, {0x07010502}, {0x08050001}, {0x08000501}, {0x07040302}, /* 79 */
+ {0x07040302}, {0x07030402}, {0x07030402}, {0x07040202}, {0x07040202}, /* 84 */
+ {0x07020402}, {0x07020402}, {0x07030302}, {0x07030302}, {0x06010402}, /* 89 */
+ {0x06010402}, {0x06010402}, {0x06010402}, {0x07040102}, {0x07040102}, /* 94 */
+ {0x07040001}, {0x07040001}, {0x06030202}, {0x06030202}, {0x06030202}, /* 99 */
+ {0x06030202}, {0x06020302}, {0x06020302}, {0x06020302}, {0x06020302}, /* 104 */
+ {0x07000401}, {0x07000401}, {0x07030001}, {0x07030001}, {0x06030102}, /* 109 */
+ {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302}, /* 114 */
+ {0x06010302}, {0x06010302}, {0x06000301}, {0x06000301}, {0x06000301}, /* 119 */
+ {0x06000301}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, /* 124 */
+ {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020102}, /* 129 */
+ {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, /* 134 */
+ {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202}, {0x05010202}, /* 139 */
+ {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, /* 144 */
+ {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, /* 149 */
+ {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201}, {0x05000201}, /* 154 */
+ {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, /* 159 */
+ {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 164 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 169 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 174 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 179 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 184 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, /* 189 */
+ {0x03010102}, {0x03010102}, {0x03010102}, {0x04010001}, {0x04010001}, /* 194 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 199 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 204 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101}, /* 209 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 214 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 219 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 224 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 229 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 234 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 239 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 244 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 249 */
+ {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, /* 254 */
+ {0x03000000}, {0x03000000}, {0xFF000005}, {0x050F0F02}, {0x050F0E02}, /* 259 */
+ {0x050E0F02}, {0x050F0D02}, {0x040E0E02}, {0x040E0E02}, {0x050D0F02}, /* 264 */
+ {0x050F0C02}, {0x050C0F02}, {0x050E0D02}, {0x050D0E02}, {0x050F0B02}, /* 269 */
+ {0x040B0F02}, {0x040B0F02}, {0x050E0C02}, {0x050C0E02}, {0x040D0D02}, /* 274 */
+ {0x040D0D02}, {0x040F0A02}, {0x040F0A02}, {0x040A0F02}, {0x040A0F02}, /* 279 */
+ {0x040E0B02}, {0x040E0B02}, {0x040B0E02}, {0x040B0E02}, {0x040D0C02}, /* 284 */
+ {0x040D0C02}, {0x040C0D02}, {0x040C0D02}, {0x040F0902}, {0x040F0902}, /* 289 */
+ {0xFF000005}, {0x04090F02}, {0x04090F02}, {0x040A0E02}, {0x040A0E02}, /* 294 */
+ {0x040D0B02}, {0x040D0B02}, {0x040B0D02}, {0x040B0D02}, {0x040F0802}, /* 299 */
+ {0x040F0802}, {0x04080F02}, {0x04080F02}, {0x040C0C02}, {0x040C0C02}, /* 304 */
+ {0x040E0902}, {0x040E0902}, {0x04090E02}, {0x04090E02}, {0x040F0702}, /* 309 */
+ {0x040F0702}, {0x04070F02}, {0x04070F02}, {0x040D0A02}, {0x040D0A02}, /* 314 */
+ {0x040A0D02}, {0x040A0D02}, {0x040C0B02}, {0x040C0B02}, {0x040F0602}, /* 319 */
+ {0x040F0602}, {0x050E0A02}, {0x050F0001}, {0xFF000004}, {0x030B0C02}, /* 324 */
+ {0x030B0C02}, {0x03060F02}, {0x03060F02}, {0x040E0802}, {0x04080E02}, /* 329 */
+ {0x040F0502}, {0x040D0902}, {0x03050F02}, {0x03050F02}, {0x030E0702}, /* 334 */
+ {0x030E0702}, {0x03070E02}, {0x03070E02}, {0x030C0A02}, {0x030C0A02}, /* 339 */
+ {0xFF000004}, {0x030A0C02}, {0x030A0C02}, {0x030B0B02}, {0x030B0B02}, /* 344 */
+ {0x04090D02}, {0x040D0802}, {0x030F0402}, {0x030F0402}, {0x03040F02}, /* 349 */
+ {0x03040F02}, {0x030F0302}, {0x030F0302}, {0x03030F02}, {0x03030F02}, /* 354 */
+ {0x03080D02}, {0x03080D02}, {0xFF000004}, {0x03060E02}, {0x03060E02}, /* 359 */
+ {0x030F0202}, {0x030F0202}, {0x03020F02}, {0x03020F02}, {0x040E0602}, /* 364 */
+ {0x04000F01}, {0x030F0102}, {0x030F0102}, {0x03010F02}, {0x03010F02}, /* 369 */
+ {0x030C0902}, {0x030C0902}, {0x03090C02}, {0x03090C02}, {0xFF000003}, /* 374 */
+ {0x030E0502}, {0x030B0A02}, {0x030A0B02}, {0x03050E02}, {0x030D0702}, /* 379 */
+ {0x03070D02}, {0x030E0402}, {0x03040E02}, {0xFF000003}, {0x030C0802}, /* 384 */
+ {0x03080C02}, {0x030E0302}, {0x030D0602}, {0x03060D02}, {0x03030E02}, /* 389 */
+ {0x030B0902}, {0x03090B02}, {0xFF000004}, {0x030E0202}, {0x030E0202}, /* 394 */
+ {0x030A0A02}, {0x030A0A02}, {0x03020E02}, {0x03020E02}, {0x030E0102}, /* 399 */
+ {0x030E0102}, {0x03010E02}, {0x03010E02}, {0x040E0001}, {0x04000E01}, /* 404 */
+ {0x030D0502}, {0x030D0502}, {0x03050D02}, {0x03050D02}, {0xFF000003}, /* 409 */
+ {0x030C0702}, {0x03070C02}, {0x030D0402}, {0x030B0802}, {0x02040D02}, /* 414 */
+ {0x02040D02}, {0x03080B02}, {0x030A0902}, {0xFF000003}, {0x03090A02}, /* 419 */
+ {0x030C0602}, {0x03060C02}, {0x030D0302}, {0x02030D02}, {0x02030D02}, /* 424 */
+ {0x02020D02}, {0x02020D02}, {0xFF000003}, {0x030D0202}, {0x030D0001}, /* 429 */
+ {0x020D0102}, {0x020D0102}, {0x020B0702}, {0x020B0702}, {0x02070B02}, /* 434 */
+ {0x02070B02}, {0xFF000003}, {0x02010D02}, {0x02010D02}, {0x030C0502}, /* 439 */
+ {0x03000D01}, {0x02050C02}, {0x02050C02}, {0x020A0802}, {0x020A0802}, /* 444 */
+ {0xFF000002}, {0x02080A02}, {0x020C0402}, {0x02040C02}, {0x020B0602}, /* 449 */
+ {0xFF000003}, {0x02060B02}, {0x02060B02}, {0x03090902}, {0x030C0001}, /* 454 */
+ {0x020C0302}, {0x020C0302}, {0x02030C02}, {0x02030C02}, {0xFF000003}, /* 459 */
+ {0x020A0702}, {0x020A0702}, {0x02070A02}, {0x02070A02}, {0x02060A02}, /* 464 */
+ {0x02060A02}, {0x03000C01}, {0x030B0001}, {0xFF000002}, {0x01020C02}, /* 469 */
+ {0x01020C02}, {0x020C0202}, {0x020B0502}, {0xFF000002}, {0x02050B02}, /* 474 */
+ {0x020C0102}, {0x02090802}, {0x02080902}, {0xFF000002}, {0x02010C02}, /* 479 */
+ {0x020B0402}, {0x02040B02}, {0x020A0602}, {0xFF000002}, {0x020B0302}, /* 484 */
+ {0x02090702}, {0x01030B02}, {0x01030B02}, {0xFF000002}, {0x02070902}, /* 489 */
+ {0x02080802}, {0x020B0202}, {0x020A0502}, {0xFF000002}, {0x01020B02}, /* 494 */
+ {0x01020B02}, {0x02050A02}, {0x020B0102}, {0xFF000002}, {0x01010B02}, /* 499 */
+ {0x01010B02}, {0x02000B01}, {0x02090602}, {0xFF000002}, {0x02060902}, /* 504 */
+ {0x020A0402}, {0x02040A02}, {0x02080702}, {0xFF000002}, {0x02070802}, /* 509 */
+ {0x020A0302}, {0x01030A02}, {0x01030A02}, {0xFF000001}, {0x01090502}, /* 514 */
+ {0x01050902}, {0xFF000001}, {0x010A0202}, {0x01020A02}, {0xFF000001}, /* 519 */
+ {0x010A0102}, {0x01010A02}, {0xFF000002}, {0x020A0001}, {0x02000A01}, /* 524 */
+ {0x01080602}, {0x01080602}, {0xFF000001}, {0x01060802}, {0x01090402}, /* 529 */
+ {0xFF000001}, {0x01040902}, {0x01090302}, {0xFF000002}, {0x01030902}, /* 534 */
+ {0x01030902}, {0x02070702}, {0x02090001}, {0xFF000001}, {0x01080502}, /* 539 */
+ {0x01050802}, {0xFF000001}, {0x01090202}, {0x01070602}, {0xFF000001}, /* 544 */
+ {0x01060702}, {0x01020902}, {0xFF000001}, {0x01090102}, {0x01000901}, /* 549 */
+ {0xFF000001}, {0x01080402}, {0x01040802}, {0xFF000001}, {0x01070502}, /* 554 */
+ {0x01050702}, {0xFF000001}, {0x01080302}, {0x01030802}, {0xFF000001}, /* 559 */
+ {0x01060602}, {0x01070402}, {0xFF000001}, {0x01040702}, {0x01080001}, /* 564 */
+ {0xFF000001}, {0x01000801}, {0x01060502}, {0xFF000001}, {0x01050602}, /* 569 */
+ {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000001}, /* 574 */
+ {0x01070001}, {0x01000701}, {0xFF000001}, {0x01060001}, {0x01000601}, /* 579 */
+};
+
+/* max table bits 8 */
+
+/* TABLE 16 256 entries maxbits 17 linbits 0 */
+static HUFF_ELEMENT huff_table_16[] =
+{
+ {0xFF000008}, {0x00000101}, {0x0000010A}, {0x00000113}, {0x080F0F02}, /* 4 */
+ {0x00000118}, {0x0000011D}, {0x00000120}, {0x08020F02}, {0x00000131}, /* 9 */
+ {0x080F0102}, {0x08010F02}, {0x00000134}, {0x00000145}, {0x00000156}, /* 14 */
+ {0x00000167}, {0x00000178}, {0x00000189}, {0x0000019A}, {0x000001A3}, /* 19 */
+ {0x000001AC}, {0x000001B5}, {0x000001BE}, {0x000001C7}, {0x000001D0}, /* 24 */
+ {0x000001D9}, {0x000001DE}, {0x000001E3}, {0x000001E6}, {0x000001EB}, /* 29 */
+ {0x000001F0}, {0x08010502}, {0x000001F3}, {0x000001F6}, {0x000001F9}, /* 34 */
+ {0x000001FC}, {0x08040102}, {0x08010402}, {0x000001FF}, {0x08030202}, /* 39 */
+ {0x08020302}, {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302}, /* 44 */
+ {0x08030001}, {0x08000301}, {0x07020202}, {0x07020202}, {0x06020102}, /* 49 */
+ {0x06020102}, {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202}, /* 54 */
+ {0x06010202}, {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001}, /* 59 */
+ {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, /* 64 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 69 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 74 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 79 */
+ {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 84 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 89 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 94 */
+ {0x04010001}, {0x04010001}, {0x03000101}, {0x03000101}, {0x03000101}, /* 99 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 104 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 109 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 114 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 119 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, /* 124 */
+ {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, /* 129 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 134 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 139 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 144 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 149 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 154 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 159 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 164 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 169 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 174 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 179 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 184 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 189 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 194 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 199 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 204 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 209 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 214 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 219 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 224 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 229 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 234 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 239 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 244 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 249 */
+ {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 254 */
+ {0x01000000}, {0x01000000}, {0xFF000003}, {0x030F0E02}, {0x030E0F02}, /* 259 */
+ {0x030F0D02}, {0x030D0F02}, {0x030F0C02}, {0x030C0F02}, {0x030F0B02}, /* 264 */
+ {0x030B0F02}, {0xFF000003}, {0x020F0A02}, {0x020F0A02}, {0x030A0F02}, /* 269 */
+ {0x030F0902}, {0x03090F02}, {0x03080F02}, {0x020F0802}, {0x020F0802}, /* 274 */
+ {0xFF000002}, {0x020F0702}, {0x02070F02}, {0x020F0602}, {0x02060F02}, /* 279 */
+ {0xFF000002}, {0x020F0502}, {0x02050F02}, {0x010F0402}, {0x010F0402}, /* 284 */
+ {0xFF000001}, {0x01040F02}, {0x01030F02}, {0xFF000004}, {0x01000F01}, /* 289 */
+ {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01}, /* 294 */
+ {0x01000F01}, {0x01000F01}, {0x020F0302}, {0x020F0302}, {0x020F0302}, /* 299 */
+ {0x020F0302}, {0x000000E2}, {0x000000F3}, {0x000000FC}, {0x00000105}, /* 304 */
+ {0xFF000001}, {0x010F0202}, {0x010F0001}, {0xFF000004}, {0x000000FA}, /* 309 */
+ {0x000000FF}, {0x00000104}, {0x00000109}, {0x0000010C}, {0x00000111}, /* 314 */
+ {0x00000116}, {0x00000119}, {0x0000011E}, {0x00000123}, {0x00000128}, /* 319 */
+ {0x04030E02}, {0x0000012D}, {0x00000130}, {0x00000133}, {0x00000136}, /* 324 */
+ {0xFF000004}, {0x00000128}, {0x0000012B}, {0x0000012E}, {0x040D0001}, /* 329 */
+ {0x00000131}, {0x00000134}, {0x00000137}, {0x040C0302}, {0x0000013A}, /* 334 */
+ {0x040C0102}, {0x04000C01}, {0x0000013D}, {0x03020E02}, {0x03020E02}, /* 339 */
+ {0x040E0202}, {0x040E0102}, {0xFF000004}, {0x04030D02}, {0x040D0202}, /* 344 */
+ {0x04020D02}, {0x04010D02}, {0x040B0302}, {0x0000012F}, {0x030D0102}, /* 349 */
+ {0x030D0102}, {0x04040C02}, {0x040B0602}, {0x04030C02}, {0x04070A02}, /* 354 */
+ {0x030C0202}, {0x030C0202}, {0x04020C02}, {0x04050B02}, {0xFF000004}, /* 359 */
+ {0x04010C02}, {0x040C0001}, {0x040B0402}, {0x04040B02}, {0x040A0602}, /* 364 */
+ {0x04060A02}, {0x03030B02}, {0x03030B02}, {0x040A0502}, {0x04050A02}, /* 369 */
+ {0x030B0202}, {0x030B0202}, {0x03020B02}, {0x03020B02}, {0x030B0102}, /* 374 */
+ {0x030B0102}, {0xFF000004}, {0x03010B02}, {0x03010B02}, {0x040B0001}, /* 379 */
+ {0x04000B01}, {0x04090602}, {0x04060902}, {0x040A0402}, {0x04040A02}, /* 384 */
+ {0x04080702}, {0x04070802}, {0x03030A02}, {0x03030A02}, {0x040A0302}, /* 389 */
+ {0x04090502}, {0x030A0202}, {0x030A0202}, {0xFF000004}, {0x04050902}, /* 394 */
+ {0x04080602}, {0x03010A02}, {0x03010A02}, {0x04060802}, {0x04070702}, /* 399 */
+ {0x03040902}, {0x03040902}, {0x04090402}, {0x04070502}, {0x03070602}, /* 404 */
+ {0x03070602}, {0x02020A02}, {0x02020A02}, {0x02020A02}, {0x02020A02}, /* 409 */
+ {0xFF000003}, {0x020A0102}, {0x020A0102}, {0x030A0001}, {0x03000A01}, /* 414 */
+ {0x03090302}, {0x03030902}, {0x03080502}, {0x03050802}, {0xFF000003}, /* 419 */
+ {0x02090202}, {0x02090202}, {0x02020902}, {0x02020902}, {0x03060702}, /* 424 */
+ {0x03090001}, {0x02090102}, {0x02090102}, {0xFF000003}, {0x02010902}, /* 429 */
+ {0x02010902}, {0x03000901}, {0x03080402}, {0x03040802}, {0x03050702}, /* 434 */
+ {0x03080302}, {0x03030802}, {0xFF000003}, {0x03060602}, {0x03080202}, /* 439 */
+ {0x02020802}, {0x02020802}, {0x03070402}, {0x03040702}, {0x02080102}, /* 444 */
+ {0x02080102}, {0xFF000003}, {0x02010802}, {0x02010802}, {0x02000801}, /* 449 */
+ {0x02000801}, {0x03080001}, {0x03060502}, {0x02070302}, {0x02070302}, /* 454 */
+ {0xFF000003}, {0x02030702}, {0x02030702}, {0x03050602}, {0x03060402}, /* 459 */
+ {0x02070202}, {0x02070202}, {0x02020702}, {0x02020702}, {0xFF000003}, /* 464 */
+ {0x03040602}, {0x03050502}, {0x02070001}, {0x02070001}, {0x01070102}, /* 469 */
+ {0x01070102}, {0x01070102}, {0x01070102}, {0xFF000002}, {0x01010702}, /* 474 */
+ {0x01010702}, {0x02000701}, {0x02060302}, {0xFF000002}, {0x02030602}, /* 479 */
+ {0x02050402}, {0x02040502}, {0x02060202}, {0xFF000001}, {0x01020602}, /* 484 */
+ {0x01060102}, {0xFF000002}, {0x01010602}, {0x01010602}, {0x02060001}, /* 489 */
+ {0x02000601}, {0xFF000002}, {0x01030502}, {0x01030502}, {0x02050302}, /* 494 */
+ {0x02040402}, {0xFF000001}, {0x01050202}, {0x01020502}, {0xFF000001}, /* 499 */
+ {0x01050102}, {0x01050001}, {0xFF000001}, {0x01040302}, {0x01030402}, /* 504 */
+ {0xFF000001}, {0x01000501}, {0x01040202}, {0xFF000001}, {0x01020402}, /* 509 */
+ {0x01030302}, {0xFF000001}, {0x01040001}, {0x01000401}, {0xFF000004}, /* 514 */
+ {0x040E0C02}, {0x00000086}, {0x030E0D02}, {0x030E0D02}, {0x03090E02}, /* 519 */
+ {0x03090E02}, {0x040A0E02}, {0x04090D02}, {0x020E0E02}, {0x020E0E02}, /* 524 */
+ {0x020E0E02}, {0x020E0E02}, {0x030D0E02}, {0x030D0E02}, {0x030B0E02}, /* 529 */
+ {0x030B0E02}, {0xFF000003}, {0x020E0B02}, {0x020E0B02}, {0x020D0C02}, /* 534 */
+ {0x020D0C02}, {0x030C0D02}, {0x030B0D02}, {0x020E0A02}, {0x020E0A02}, /* 539 */
+ {0xFF000003}, {0x020C0C02}, {0x020C0C02}, {0x030D0A02}, {0x030A0D02}, /* 544 */
+ {0x030E0702}, {0x030C0A02}, {0x020A0C02}, {0x020A0C02}, {0xFF000003}, /* 549 */
+ {0x03090C02}, {0x030D0702}, {0x020E0502}, {0x020E0502}, {0x010D0B02}, /* 554 */
+ {0x010D0B02}, {0x010D0B02}, {0x010D0B02}, {0xFF000002}, {0x010E0902}, /* 559 */
+ {0x010E0902}, {0x020C0B02}, {0x020B0C02}, {0xFF000002}, {0x020E0802}, /* 564 */
+ {0x02080E02}, {0x020D0902}, {0x02070E02}, {0xFF000002}, {0x020B0B02}, /* 569 */
+ {0x020D0802}, {0x02080D02}, {0x020E0602}, {0xFF000001}, {0x01060E02}, /* 574 */
+ {0x010C0902}, {0xFF000002}, {0x020B0A02}, {0x020A0B02}, {0x02050E02}, /* 579 */
+ {0x02070D02}, {0xFF000002}, {0x010E0402}, {0x010E0402}, {0x02040E02}, /* 584 */
+ {0x020C0802}, {0xFF000001}, {0x01080C02}, {0x010E0302}, {0xFF000002}, /* 589 */
+ {0x010D0602}, {0x010D0602}, {0x02060D02}, {0x020B0902}, {0xFF000002}, /* 594 */
+ {0x02090B02}, {0x020A0A02}, {0x01010E02}, {0x01010E02}, {0xFF000002}, /* 599 */
+ {0x01040D02}, {0x01040D02}, {0x02080B02}, {0x02090A02}, {0xFF000002}, /* 604 */
+ {0x010B0702}, {0x010B0702}, {0x02070B02}, {0x02000D01}, {0xFF000001}, /* 609 */
+ {0x010E0001}, {0x01000E01}, {0xFF000001}, {0x010D0502}, {0x01050D02}, /* 614 */
+ {0xFF000001}, {0x010C0702}, {0x01070C02}, {0xFF000001}, {0x010D0402}, /* 619 */
+ {0x010B0802}, {0xFF000001}, {0x010A0902}, {0x010C0602}, {0xFF000001}, /* 624 */
+ {0x01060C02}, {0x010D0302}, {0xFF000001}, {0x010C0502}, {0x01050C02}, /* 629 */
+ {0xFF000001}, {0x010A0802}, {0x01080A02}, {0xFF000001}, {0x01090902}, /* 634 */
+ {0x010C0402}, {0xFF000001}, {0x01060B02}, {0x010A0702}, {0xFF000001}, /* 639 */
+ {0x010B0502}, {0x01090802}, {0xFF000001}, {0x01080902}, {0x01090702}, /* 644 */
+ {0xFF000001}, {0x01070902}, {0x01080802}, {0xFF000001}, {0x010C0E02}, /* 649 */
+ {0x010D0D02},
+};
+
+/* max table bits 8 */
+/* NO XING TABLE 17 */
+/* NO XING TABLE 18 */
+/* NO XING TABLE 19 */
+/* NO XING TABLE 20 */
+/* NO XING TABLE 21 */
+/* NO XING TABLE 22 */
+/* NO XING TABLE 23 */
+
+/* TABLE 24 256 entries maxbits 12 linbits 0 */
+static HUFF_ELEMENT huff_table_24[] =
+{
+ {0xFF000009}, {0x080F0E02}, {0x080F0E02}, {0x080E0F02}, {0x080E0F02}, /* 4 */
+ {0x080F0D02}, {0x080F0D02}, {0x080D0F02}, {0x080D0F02}, {0x080F0C02}, /* 9 */
+ {0x080F0C02}, {0x080C0F02}, {0x080C0F02}, {0x080F0B02}, {0x080F0B02}, /* 14 */
+ {0x080B0F02}, {0x080B0F02}, {0x070A0F02}, {0x070A0F02}, {0x070A0F02}, /* 19 */
+ {0x070A0F02}, {0x080F0A02}, {0x080F0A02}, {0x080F0902}, {0x080F0902}, /* 24 */
+ {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07080F02}, /* 29 */
+ {0x07080F02}, {0x07080F02}, {0x07080F02}, {0x080F0802}, {0x080F0802}, /* 34 */
+ {0x080F0702}, {0x080F0702}, {0x07070F02}, {0x07070F02}, {0x07070F02}, /* 39 */
+ {0x07070F02}, {0x070F0602}, {0x070F0602}, {0x070F0602}, {0x070F0602}, /* 44 */
+ {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x070F0502}, /* 49 */
+ {0x070F0502}, {0x070F0502}, {0x070F0502}, {0x07050F02}, {0x07050F02}, /* 54 */
+ {0x07050F02}, {0x07050F02}, {0x070F0402}, {0x070F0402}, {0x070F0402}, /* 59 */
+ {0x070F0402}, {0x07040F02}, {0x07040F02}, {0x07040F02}, {0x07040F02}, /* 64 */
+ {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x07030F02}, /* 69 */
+ {0x07030F02}, {0x07030F02}, {0x07030F02}, {0x070F0202}, {0x070F0202}, /* 74 */
+ {0x070F0202}, {0x070F0202}, {0x07020F02}, {0x07020F02}, {0x07020F02}, /* 79 */
+ {0x07020F02}, {0x07010F02}, {0x07010F02}, {0x07010F02}, {0x07010F02}, /* 84 */
+ {0x080F0102}, {0x080F0102}, {0x08000F01}, {0x08000F01}, {0x090F0001}, /* 89 */
+ {0x00000201}, {0x00000206}, {0x0000020B}, {0x00000210}, {0x00000215}, /* 94 */
+ {0x0000021A}, {0x0000021F}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 99 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 104 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 109 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 114 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 119 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, /* 124 */
+ {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x00000224}, /* 129 */
+ {0x00000229}, {0x00000232}, {0x00000237}, {0x0000023A}, {0x0000023F}, /* 134 */
+ {0x00000242}, {0x00000245}, {0x0000024A}, {0x0000024D}, {0x00000250}, /* 139 */
+ {0x00000253}, {0x00000256}, {0x00000259}, {0x0000025C}, {0x0000025F}, /* 144 */
+ {0x00000262}, {0x00000265}, {0x00000268}, {0x0000026B}, {0x0000026E}, /* 149 */
+ {0x00000271}, {0x00000274}, {0x00000277}, {0x0000027A}, {0x0000027D}, /* 154 */
+ {0x00000280}, {0x00000283}, {0x00000288}, {0x0000028B}, {0x0000028E}, /* 159 */
+ {0x00000291}, {0x00000294}, {0x00000297}, {0x0000029A}, {0x0000029F}, /* 164 */
+ {0x09040B02}, {0x000002A4}, {0x000002A7}, {0x000002AA}, {0x09030B02}, /* 169 */
+ {0x09080802}, {0x000002AF}, {0x09020B02}, {0x000002B2}, {0x000002B5}, /* 174 */
+ {0x09060902}, {0x09040A02}, {0x000002B8}, {0x09070802}, {0x090A0302}, /* 179 */
+ {0x09030A02}, {0x09090502}, {0x09050902}, {0x090A0202}, {0x09020A02}, /* 184 */
+ {0x09010A02}, {0x09080602}, {0x09060802}, {0x09070702}, {0x09090402}, /* 189 */
+ {0x09040902}, {0x09090302}, {0x09030902}, {0x09080502}, {0x09050802}, /* 194 */
+ {0x09090202}, {0x09070602}, {0x09060702}, {0x09020902}, {0x09090102}, /* 199 */
+ {0x09010902}, {0x09080402}, {0x09040802}, {0x09070502}, {0x09050702}, /* 204 */
+ {0x09080302}, {0x09030802}, {0x09060602}, {0x09080202}, {0x09020802}, /* 209 */
+ {0x09080102}, {0x09070402}, {0x09040702}, {0x09010802}, {0x000002BB}, /* 214 */
+ {0x09060502}, {0x09050602}, {0x09070102}, {0x000002BE}, {0x08030702}, /* 219 */
+ {0x08030702}, {0x09070302}, {0x09070202}, {0x08020702}, {0x08020702}, /* 224 */
+ {0x08060402}, {0x08060402}, {0x08040602}, {0x08040602}, {0x08050502}, /* 229 */
+ {0x08050502}, {0x08010702}, {0x08010702}, {0x08060302}, {0x08060302}, /* 234 */
+ {0x08030602}, {0x08030602}, {0x08050402}, {0x08050402}, {0x08040502}, /* 239 */
+ {0x08040502}, {0x08060202}, {0x08060202}, {0x08020602}, {0x08020602}, /* 244 */
+ {0x08060102}, {0x08060102}, {0x08010602}, {0x08010602}, {0x09060001}, /* 249 */
+ {0x09000601}, {0x08050302}, {0x08050302}, {0x08030502}, {0x08030502}, /* 254 */
+ {0x08040402}, {0x08040402}, {0x08050202}, {0x08050202}, {0x08020502}, /* 259 */
+ {0x08020502}, {0x08050102}, {0x08050102}, {0x09050001}, {0x09000501}, /* 264 */
+ {0x07010502}, {0x07010502}, {0x07010502}, {0x07010502}, {0x08040302}, /* 269 */
+ {0x08040302}, {0x08030402}, {0x08030402}, {0x07040202}, {0x07040202}, /* 274 */
+ {0x07040202}, {0x07040202}, {0x07020402}, {0x07020402}, {0x07020402}, /* 279 */
+ {0x07020402}, {0x07030302}, {0x07030302}, {0x07030302}, {0x07030302}, /* 284 */
+ {0x07040102}, {0x07040102}, {0x07040102}, {0x07040102}, {0x07010402}, /* 289 */
+ {0x07010402}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08040001}, /* 294 */
+ {0x08000401}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07030202}, /* 299 */
+ {0x07030202}, {0x07020302}, {0x07020302}, {0x07020302}, {0x07020302}, /* 304 */
+ {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102}, /* 309 */
+ {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302}, /* 314 */
+ {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, /* 319 */
+ {0x06010302}, {0x07030001}, {0x07030001}, {0x07030001}, {0x07030001}, /* 324 */
+ {0x07000301}, {0x07000301}, {0x07000301}, {0x07000301}, {0x06020202}, /* 329 */
+ {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202}, /* 334 */
+ {0x06020202}, {0x06020202}, {0x05020102}, {0x05020102}, {0x05020102}, /* 339 */
+ {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, /* 344 */
+ {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, /* 349 */
+ {0x05020102}, {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202}, /* 354 */
+ {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, /* 359 */
+ {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, /* 364 */
+ {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x06020001}, /* 369 */
+ {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, /* 374 */
+ {0x06020001}, {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201}, /* 379 */
+ {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, /* 384 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 389 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 394 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 399 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 404 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 409 */
+ {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, /* 414 */
+ {0x04010102}, {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, /* 419 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 424 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 429 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 434 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 439 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, /* 444 */
+ {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101}, /* 449 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 454 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 459 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 464 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 469 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 474 */
+ {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, /* 479 */
+ {0x04000101}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 484 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 489 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 494 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 499 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 504 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, /* 509 */
+ {0x04000000}, {0x04000000}, {0x04000000}, {0xFF000002}, {0x020E0E02}, /* 514 */
+ {0x020E0D02}, {0x020D0E02}, {0x020E0C02}, {0xFF000002}, {0x020C0E02}, /* 519 */
+ {0x020D0D02}, {0x020E0B02}, {0x020B0E02}, {0xFF000002}, {0x020D0C02}, /* 524 */
+ {0x020C0D02}, {0x020E0A02}, {0x020A0E02}, {0xFF000002}, {0x020D0B02}, /* 529 */
+ {0x020B0D02}, {0x020C0C02}, {0x020E0902}, {0xFF000002}, {0x02090E02}, /* 534 */
+ {0x020D0A02}, {0x020A0D02}, {0x020C0B02}, {0xFF000002}, {0x020B0C02}, /* 539 */
+ {0x020E0802}, {0x02080E02}, {0x020D0902}, {0xFF000002}, {0x02090D02}, /* 544 */
+ {0x020E0702}, {0x02070E02}, {0x020C0A02}, {0xFF000002}, {0x020A0C02}, /* 549 */
+ {0x020B0B02}, {0x020D0802}, {0x02080D02}, {0xFF000003}, {0x030E0001}, /* 554 */
+ {0x03000E01}, {0x020D0001}, {0x020D0001}, {0x01060E02}, {0x01060E02}, /* 559 */
+ {0x01060E02}, {0x01060E02}, {0xFF000002}, {0x020E0602}, {0x020C0902}, /* 564 */
+ {0x01090C02}, {0x01090C02}, {0xFF000001}, {0x010E0502}, {0x010A0B02}, /* 569 */
+ {0xFF000002}, {0x01050E02}, {0x01050E02}, {0x020B0A02}, {0x020D0702}, /* 574 */
+ {0xFF000001}, {0x01070D02}, {0x01040E02}, {0xFF000001}, {0x010C0802}, /* 579 */
+ {0x01080C02}, {0xFF000002}, {0x020E0402}, {0x020E0202}, {0x010E0302}, /* 584 */
+ {0x010E0302}, {0xFF000001}, {0x010D0602}, {0x01060D02}, {0xFF000001}, /* 589 */
+ {0x01030E02}, {0x010B0902}, {0xFF000001}, {0x01090B02}, {0x010A0A02}, /* 594 */
+ {0xFF000001}, {0x01020E02}, {0x010E0102}, {0xFF000001}, {0x01010E02}, /* 599 */
+ {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702}, {0xFF000001}, /* 604 */
+ {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802}, {0x01080B02}, /* 609 */
+ {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001}, {0x01090A02}, /* 614 */
+ {0x010C0602}, {0xFF000001}, {0x01060C02}, {0x010D0302}, {0xFF000001}, /* 619 */
+ {0x01030D02}, {0x010D0202}, {0xFF000001}, {0x01020D02}, {0x010D0102}, /* 624 */
+ {0xFF000001}, {0x010B0702}, {0x01070B02}, {0xFF000001}, {0x01010D02}, /* 629 */
+ {0x010C0502}, {0xFF000001}, {0x01050C02}, {0x010A0802}, {0xFF000001}, /* 634 */
+ {0x01080A02}, {0x01090902}, {0xFF000001}, {0x010C0402}, {0x01040C02}, /* 639 */
+ {0xFF000001}, {0x010B0602}, {0x01060B02}, {0xFF000002}, {0x02000D01}, /* 644 */
+ {0x020C0001}, {0x010C0302}, {0x010C0302}, {0xFF000001}, {0x01030C02}, /* 649 */
+ {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x010C0202}, {0xFF000001}, /* 654 */
+ {0x01020C02}, {0x010B0502}, {0xFF000001}, {0x01050B02}, {0x010C0102}, /* 659 */
+ {0xFF000001}, {0x01090802}, {0x01080902}, {0xFF000001}, {0x01010C02}, /* 664 */
+ {0x010B0402}, {0xFF000002}, {0x02000C01}, {0x020B0001}, {0x010B0302}, /* 669 */
+ {0x010B0302}, {0xFF000002}, {0x02000B01}, {0x020A0001}, {0x010A0102}, /* 674 */
+ {0x010A0102}, {0xFF000001}, {0x010A0602}, {0x01060A02}, {0xFF000001}, /* 679 */
+ {0x01090702}, {0x01070902}, {0xFF000002}, {0x02000A01}, {0x02090001}, /* 684 */
+ {0x01000901}, {0x01000901}, {0xFF000001}, {0x010B0202}, {0x010A0502}, /* 689 */
+ {0xFF000001}, {0x01050A02}, {0x010B0102}, {0xFF000001}, {0x01010B02}, /* 694 */
+ {0x01090602}, {0xFF000001}, {0x010A0402}, {0x01080702}, {0xFF000001}, /* 699 */
+ {0x01080001}, {0x01000801}, {0xFF000001}, {0x01070001}, {0x01000701}, /* 704 */
+};
+
+/* max table bits 9 */
+/* NO XING TABLE 25 */
+/* NO XING TABLE 26 */
+/* NO XING TABLE 27 */
+/* NO XING TABLE 28 */
+/* NO XING TABLE 29 */
+/* NO XING TABLE 30 */
+/* NO XING TABLE 31 */
+/* done */
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*---------------------------------------------------------------
+
+mpeg Layer II audio decoder, integer version
+variable type control
+
+-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------
+Variable types can have a large impact on performance. If the
+native type int is 32 bit or better, setting all variables to the
+native int is probably the best bet. Machines with fast floating
+point handware will probably run faster with the floating point
+version of this decoder.
+
+On 16 bit machines, use the native 16 bit int where possible
+with special consideration given to the multiplies used in
+the dct and window (see below).
+
+
+The code uses the type INT32 when 32 or more bits are required.
+Use the native int if possible.
+Signed types are required for all but DCTCOEF which may be unsigned.
+
+THe major parts of the decoder are: bit stream unpack (iup.c),
+dct (cidct.c), and window (iwinq.c). The compute time relationship
+is usually unpack < dct < window.
+
+-------------------------------------------------------------------*/
+
+/*-------------- dct cidct.c -------------------------------------------
+dct input is type SAMPLEINT, output is WININT
+
+DCTCOEF: dct coefs, 16 or more bits required
+DCTBITS: fractional bits in dct coefs. Coefs are unsigned in
+ the range 0.50 to 10.2. DCTBITS=10 is a compromise
+ between precision and the possibility of overflowing
+ intermediate results.
+
+
+DCTSATURATE: If set, saturates dct output to 16 bit.
+ Dct output may overflow if WININT is 16 bit, overflow
+ is rare, but very noisy. Define to 1 for 16 bit WININT.
+ Define to 0 otherwise.
+
+The multiply used in the dct (routine forward_bf in cidct.c) requires
+the multiplication of a 32 bit variable by a 16 bit unsigned coef
+to produce a signed 32 bit result. On 16 bit machines this could be
+faster than a full 32x32 multiply.
+
+------------------------------------------------------------------*/
+/*-------------- WINDOW iwinq.c ---------------------------------------
+window input is type WININT, output is short (16 bit pcm audio)
+
+window coefs WINBITS fractional bits,
+ coefs are signed range in -1.15 to 0.96.
+ WINBITS=14 is maximum for 16 bit signed representation.
+ Some CPU's will multiply faster with fewer bits.
+ WINBITS less that 8 may cause noticeable quality loss.
+
+WINMULT defines the multiply used in the window (iwinq.c)
+WINMULT must produce a 32 bit (or better) result, although both
+multipliers may be 16 bit. A 16x16-->32 multiply may offer
+a performance advantage if the compiler can be coerced into
+doing the right thing.
+------------------------------------------------------------------*/
+/*-- settings for MS C++ 4.0 flat 32 bit (long=int=32bit) --*/
+/*-- asm replacement modules must use these settings ---*/
+
+typedef long INT32;
+typedef unsigned long UINT32;
+
+typedef int SAMPLEINT;
+
+typedef int DCTCOEF;
+
+#define DCTBITS 10
+#define DCTSATURATE 0
+
+typedef int WININT;
+typedef int WINCOEF;
+
+#define WINBITS 10
+#define WINMULT(x,coef) ((x)*(coef))
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/* LOL */
+
+#ifndef min
+#define min(a,b) ((a>b)?b:a)
+#endif
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/* portable copy of eco\mhead.h */
+/* mpeg audio header */
+
+typedef struct
+{
+ int sync; /* 1 if valid sync */
+ int id;
+ int option;
+ int prot;
+ int br_index;
+ int sr_index;
+ int pad;
+ int private_bit;
+ int mode;
+ int mode_ext;
+ int cr;
+ int original;
+ int emphasis;
+}
+MPEG_HEAD;
+
+/* portable mpeg audio decoder, decoder functions */
+typedef struct
+{
+ int in_bytes;
+ int out_bytes;
+}
+IN_OUT;
+
+
+typedef struct
+{
+ int channels;
+ int outvalues;
+ long samprate;
+ int bits;
+ int framebytes;
+ int type;
+}
+DEC_INFO;
+
+typedef IN_OUT(*AUDIO_DECODE_ROUTINE) (void *mv, unsigned char *bs, signed short *pcm);
+typedef IN_OUT(*DECODE_FUNCTION) (void *mv, unsigned char *bs, unsigned char *pcm);
+
+struct _mpeg;
+
+typedef struct _mpeg MPEG;
+
+typedef void (*SBT_FUNCTION_F) (MPEG *m, float *sample, short *pcm, int n);
+
+/* main data bit buffer */
+#define NBUF (8*1024)
+#define BUF_TRIGGER (NBUF-1500)
+
+typedef void (*XFORM_FUNCTION) (void *mv, void *pcm, int igr);
+
+struct _mpeg
+{
+ struct {
+ float look_c_value[18]; /* built by init */
+ unsigned char *bs_ptr;
+ unsigned long bitbuf;
+ int bits;
+ long bitval;
+ int outbytes;
+ int framebytes;
+ int outvalues;
+ int pad;
+ int stereo_sb;
+ DEC_INFO decinfo; /* global for Layer III */
+ int max_sb;
+ int nsb_limit;
+ int first_pass;
+ int first_pass_L1;
+ int bit_skip;
+ int nbat[4];
+ int bat[4][16];
+ int ballo[64]; /* set by unpack_ba */
+ unsigned int samp_dispatch[66]; /* set by unpack_ba */
+ float c_value[64]; /* set by unpack_ba */
+ unsigned int sf_dispatch[66]; /* set by unpack_ba */
+ float sf_table[64];
+ float cs_factor[3][64];
+ float *sample; /* global for use by Later 3 */
+ signed char group3_table[32][3];
+ signed char group5_table[128][3];
+ signed short group9_table[1024][3];
+ SBT_FUNCTION_F sbt;
+ AUDIO_DECODE_ROUTINE audio_decode_routine ;
+ float *cs_factorL1;
+ float look_c_valueL1[16];
+ int nbatL1;
+
+ } cup;
+
+ struct {
+ /* cupl3.c */
+ int nBand[2][22]; /* [long/short][cb] */
+ int sfBandIndex[2][22]; /* [long/short][cb] */
+ int mpeg25_flag;
+ int iframe;
+ int band_limit;
+ int band_limit21;
+ int band_limit12;
+ int band_limit_nsb;
+ int nsb_limit;
+ int gaim_adjust;
+ int id;
+ int ncbl_mixed;
+ int gain_adjust;
+ int sr_index;
+ int outvalues;
+ int outbytes;
+ int half_outbytes;
+ int framebytes;
+ int padframebytes;
+ int crcbytes;
+ int pad;
+ int stereo_flag;
+ int nchan;
+ int ms_mode;
+ int is_mode;
+ unsigned int zero_level_pcm;
+ CB_INFO cb_info[2][2];
+ IS_SF_INFO is_sf_info; /* MPEG-2 intensity stereo */
+ unsigned char buf[NBUF];
+ int buf_ptr0;
+ int buf_ptr1;
+ int main_pos_bit;
+ SIDE_INFO side_info;
+ SCALEFACT sf[2][2]; /* [gr][ch] */
+ int nsamp[2][2]; /* must start = 0, for nsamp[igr_prev] */
+ float yout[576]; /* hybrid out, sbt in */
+ SAMPLE sample[2][2][576];
+ SBT_FUNCTION_F sbt_L3;
+ XFORM_FUNCTION Xform;
+ DECODE_FUNCTION decode_function;
+ /* msis.c */
+ /*-- windows by block type --*/
+ float win[4][36];
+ float csa[8][2]; /* antialias */
+ float lr[2][8][2]; /* [ms_mode 0/1][sf][left/right] */
+ float lr2[2][2][64][2];
+ /* l3dq.c */
+ float look_global[256 + 2 + 4];
+ float look_scale[2][4][32];
+#define ISMAX 32
+ float look_pow[2 * ISMAX];
+ float look_subblock[8];
+ float re_buf[192][3];
+ } cupl;
+ struct {
+ signed int vb_ptr;
+ signed int vb2_ptr;
+ float vbuf[512];
+ float vbuf2[512];
+ int first_pass;
+ } csbt;
+ struct {
+ float coef32[31]; /* 32 pt dct coefs */
+ } cdct;
+};
+
+typedef int (*CVT_FUNCTION_8) (void *mv, unsigned char *pcm);
+
+typedef struct
+{
+ struct {
+ unsigned char look_u[8192];
+ short pcm[2304];
+ int ncnt;
+ int ncnt1;
+ int nlast;
+ int ndeci;
+ int kdeci;
+ int first_pass;
+ short xsave;
+ CVT_FUNCTION_8 convert_routine;
+ } dec;
+ MPEG cupper;
+}
+MPEG8;
+
+#include "itype.h"
+
+typedef void (*SBT_FUNCTION) (SAMPLEINT * sample, short *pcm, int n);
+typedef void (*UNPACK_FUNCTION) ();
+
+typedef struct
+{
+ struct {
+ DEC_INFO decinfo;
+ int pad;
+ int look_c_value[18]; /* built by init */
+ int look_c_shift[18]; /* built by init */
+ int outbytes;
+ int framebytes;
+ int outvalues;
+ int max_sb;
+ int stereo_sb;
+ int nsb_limit;
+ int bit_skip;
+ int nbat[4];
+ int bat[4][16];
+ int ballo[64]; /* set by unpack_ba */
+ unsigned int samp_dispatch[66]; /* set by unpack_ba */
+ int c_value[64]; /* set by unpack_ba */
+ int c_shift[64]; /* set by unpack_ba */
+ unsigned int sf_dispatch[66]; /* set by unpack_ba */
+ int sf_table[64];
+ INT32 cs_factor[3][64];
+ SAMPLEINT sample[2304];
+ signed char group3_table[32][3];
+ signed char group5_table[128][3];
+ signed short group9_table[1024][3];
+ int nsbt;
+ SBT_FUNCTION sbt;
+ UNPACK_FUNCTION unpack_routine;
+ unsigned char *bs_ptr;
+ UINT32 bitbuf;
+ int bits;
+ INT32 bitval;
+ int first_pass;
+ int first_pass_L1;
+ int nbatL1;
+ INT32 *cs_factorL1;
+ int look_c_valueL1[16]; /* built by init */
+ int look_c_shiftL1[16]; /* built by init */
+ } iup;
+}
+MPEGI;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+ void mpeg_init(MPEG *m);
+ int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h);
+ int head_info2(unsigned char *buf,
+ unsigned int n, MPEG_HEAD * h, int *br);
+ int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int*br, unsigned int *searchForward);
+/* head_info returns framebytes > 0 for success */
+/* audio_decode_init returns 1 for success, 0 for fail */
+/* audio_decode returns in_bytes = 0 on sync loss */
+
+ int audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+ void audio_decode_info(MPEG *m, DEC_INFO * info);
+ IN_OUT audio_decode(MPEG *m, unsigned char *bs, short *pcm);
+
+ void mpeg8_init(MPEG8 *m);
+ int audio_decode8_init(MPEG8 *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+ void audio_decode8_info(MPEG8 *m, DEC_INFO * info);
+ IN_OUT audio_decode8(MPEG8 *m, unsigned char *bs, short *pcmbuf);
+
+/*-- integer decode --*/
+ void i_mpeg_init(MPEGI *m);
+ int i_audio_decode_init(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+ void i_audio_decode_info(MPEGI *m, DEC_INFO * info);
+ IN_OUT i_audio_decode(MPEGI *m, unsigned char *bs, short *pcm);
+
+
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+
+/*--- no kb function unless DOS ---*/
+
+#ifndef KB_OK
+#ifdef __MSDOS__
+#define KB_OK
+#endif
+#ifdef _CONSOLE
+#define KB_OK
+#endif
+#endif
+
+#ifdef NEED_KBHIT
+#ifdef KB_OK
+#ifdef _MSC_VER
+#pragma warning(disable: 4032)
+#endif
+#include <conio.h>
+#else
+static int kbhit()
+{
+ return 0;
+}
+static int getch()
+{
+ return 0;
+}
+#endif
+#endif
+
+/*-- no pcm conversion to wave required
+ if short = 16 bits and little endian ---*/
+
+/* mods 1/9/97 LITTLE_SHORT16 detect */
+
+#ifndef LITTLE_SHORT16
+ #ifdef __MSDOS__
+ #undef LITTLE_SHORT16
+ #define LITTLE_SHORT16
+ #endif
+ #ifdef WIN32
+ #undef LITTLE_SHORT16
+ #define LITTLE_SHORT16
+ #endif
+ #ifdef _M_IX86
+ #undef LITTLE_SHORT16
+ #define LITTLE_SHORT16
+ #endif
+#endif
+
+
+// JDW //
+//#ifdef LITTLE_SHORT16
+//#define cvt_to_wave_init(a)
+//#define cvt_to_wave(a, b) b
+//#else
+//void cvt_to_wave_init(int bits);
+//unsigned int cvt_to_wave(void *a, unsigned int b);
+//
+//#endif
+#ifdef LITTLE_SHORT16
+#define cvt_to_wave_init(a)
+#define cvt_to_wave(a, b) b
+#else
+void cvt_to_wave_init(int);
+unsigned int cvt_to_wave(unsigned char *,unsigned int);
+#endif
+
+int cvt_to_wave_test(void);
--- /dev/null
+/*====================================================================*/
+int hybrid(MPEG *m, void *xin, void *xprev, float *y,
+ int btype, int nlong, int ntot, int nprev);
+int hybrid_sum(MPEG *m, void *xin, void *xin_left, float *y,
+ int btype, int nlong, int ntot);
+void sum_f_bands(void *a, void *b, int n);
+void FreqInvert(float *y, int n);
+void antialias(MPEG *m, void *x, int n);
+void ms_process(void *x, int n); /* sum-difference stereo */
+void is_process_MPEG1(MPEG *m, void *x, /* intensity stereo */
+ SCALEFACT * sf,
+ CB_INFO cb_info[2], /* [ch] */
+ int nsamp, int ms_mode);
+void is_process_MPEG2(MPEG *m, void *x, /* intensity stereo */
+ SCALEFACT * sf,
+ CB_INFO cb_info[2], /* [ch] */
+ IS_SF_INFO * is_sf_info,
+ int nsamp, int ms_mode);
+
+void unpack_huff(void *xy, int n, int ntable);
+int unpack_huff_quad(void *vwxy, int n, int nbits, int ntable);
+void dequant(MPEG *m, SAMPLE sample[], int *nsamp,
+ SCALEFACT * sf,
+ GR * gr,
+ CB_INFO * cb_info, int ncbl_mixed);
+void unpack_sf_sub_MPEG1(SCALEFACT * scalefac, GR * gr,
+ int scfsi, /* bit flag */
+ int igr);
+void unpack_sf_sub_MPEG2(SCALEFACT sf[], /* return intensity scale */
+ GR * grdat,
+ int is_and_ch, IS_SF_INFO * is_sf_info);
+
+
+/*---------- quant ---------------------------------*/
+/* 8 bit lookup x = pow(2.0, 0.25*(global_gain-210)) */
+float *quant_init_global_addr(MPEG *m);
+
+
+/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+typedef float LS[4][32];
+LS *quant_init_scale_addr(MPEG *m);
+
+
+float *quant_init_pow_addr(MPEG *m);
+float *quant_init_subblock_addr(MPEG *m);
+
+typedef int iARRAY22[22];
+iARRAY22 *quant_init_band_addr(MPEG *m);
+
+/*---------- antialias ---------------------------------*/
+typedef float PAIR[2];
+PAIR *alias_init_addr(MPEG *m);
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/* decoder analysis window gen by dinit.c (asm version table gen) */
+0.000000000f, 0.000442505f, -0.003250122f, 0.007003784f,
+-0.031082151f, 0.078628540f, -0.100311279f, 0.572036743f,
+-1.144989014f, -0.572036743f, -0.100311279f, -0.078628540f,
+-0.031082151f, -0.007003784f, -0.003250122f, -0.000442505f,
+0.000015259f, 0.000473022f, -0.003326416f, 0.007919312f,
+-0.030517576f, 0.084182739f, -0.090927124f, 0.600219727f,
+-1.144287109f, -0.543823242f, -0.108856201f, -0.073059082f,
+-0.031478882f, -0.006118774f, -0.003173828f, -0.000396729f,
+0.000015259f, 0.000534058f, -0.003387451f, 0.008865356f,
+-0.029785154f, 0.089706421f, -0.080688477f, 0.628295898f,
+-1.142211914f, -0.515609741f, -0.116577141f, -0.067520142f,
+-0.031738281f, -0.005294800f, -0.003082275f, -0.000366211f,
+0.000015259f, 0.000579834f, -0.003433228f, 0.009841919f,
+-0.028884888f, 0.095169067f, -0.069595337f, 0.656219482f,
+-1.138763428f, -0.487472534f, -0.123474121f, -0.061996460f,
+-0.031845093f, -0.004486084f, -0.002990723f, -0.000320435f,
+0.000015259f, 0.000625610f, -0.003463745f, 0.010848999f,
+-0.027801514f, 0.100540161f, -0.057617184f, 0.683914185f,
+-1.133926392f, -0.459472656f, -0.129577637f, -0.056533810f,
+-0.031814575f, -0.003723145f, -0.002899170f, -0.000289917f,
+0.000015259f, 0.000686646f, -0.003479004f, 0.011886597f,
+-0.026535034f, 0.105819702f, -0.044784546f, 0.711318970f,
+-1.127746582f, -0.431655884f, -0.134887695f, -0.051132202f,
+-0.031661987f, -0.003005981f, -0.002792358f, -0.000259399f,
+0.000015259f, 0.000747681f, -0.003479004f, 0.012939452f,
+-0.025085449f, 0.110946655f, -0.031082151f, 0.738372803f,
+-1.120223999f, -0.404083252f, -0.139450073f, -0.045837402f,
+-0.031387329f, -0.002334595f, -0.002685547f, -0.000244141f,
+0.000030518f, 0.000808716f, -0.003463745f, 0.014022826f,
+-0.023422241f, 0.115921021f, -0.016510010f, 0.765029907f,
+-1.111373901f, -0.376800537f, -0.143264771f, -0.040634155f,
+-0.031005858f, -0.001693726f, -0.002578735f, -0.000213623f,
+0.000030518f, 0.000885010f, -0.003417969f, 0.015121460f,
+-0.021575928f, 0.120697014f, -0.001068115f, 0.791213989f,
+-1.101211548f, -0.349868774f, -0.146362305f, -0.035552979f,
+-0.030532837f, -0.001098633f, -0.002456665f, -0.000198364f,
+0.000030518f, 0.000961304f, -0.003372192f, 0.016235352f,
+-0.019531250f, 0.125259399f, 0.015228271f, 0.816864014f,
+-1.089782715f, -0.323318481f, -0.148773193f, -0.030609131f,
+-0.029937742f, -0.000549316f, -0.002349854f, -0.000167847f,
+0.000030518f, 0.001037598f, -0.003280640f, 0.017349243f,
+-0.017257690f, 0.129562378f, 0.032379150f, 0.841949463f,
+-1.077117920f, -0.297210693f, -0.150497437f, -0.025817871f,
+-0.029281614f, -0.000030518f, -0.002243042f, -0.000152588f,
+0.000045776f, 0.001113892f, -0.003173828f, 0.018463135f,
+-0.014801024f, 0.133590698f, 0.050354004f, 0.866363525f,
+-1.063217163f, -0.271591187f, -0.151596069f, -0.021179199f,
+-0.028533936f, 0.000442505f, -0.002120972f, -0.000137329f,
+0.000045776f, 0.001205444f, -0.003051758f, 0.019577026f,
+-0.012115479f, 0.137298584f, 0.069168091f, 0.890090942f,
+-1.048156738f, -0.246505737f, -0.152069092f, -0.016708374f,
+-0.027725220f, 0.000869751f, -0.002014160f, -0.000122070f,
+0.000061035f, 0.001296997f, -0.002883911f, 0.020690918f,
+-0.009231566f, 0.140670776f, 0.088775635f, 0.913055420f,
+-1.031936646f, -0.221984863f, -0.151962280f, -0.012420653f,
+-0.026840210f, 0.001266479f, -0.001907349f, -0.000106812f,
+0.000061035f, 0.001388550f, -0.002700806f, 0.021789551f,
+-0.006134033f, 0.143676758f, 0.109161377f, 0.935195923f,
+-1.014617920f, -0.198059082f, -0.151306152f, -0.008316040f,
+-0.025909424f, 0.001617432f, -0.001785278f, -0.000106812f,
+0.000076294f, 0.001480103f, -0.002487183f, 0.022857666f,
+-0.002822876f, 0.146255493f, 0.130310059f, 0.956481934f,
+-0.996246338f, -0.174789429f, -0.150115967f, -0.004394531f,
+-0.024932859f, 0.001937866f, -0.001693726f, -0.000091553f,
+-0.001586914f, -0.023910521f, -0.148422241f, -0.976852417f,
+0.152206421f, 0.000686646f, -0.002227783f, 0.000076294f,
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+
+____________________________________________________________________________*/
+
+#ifndef INCLUDED_XINGLMC_H_
+#define INCLUDED_XINGLMC_H_
+
+/* system headers */
+#include <stdlib.h>
+#include <time.h>
+
+/* project headers */
+#include "config.h"
+
+#include "pmi.h"
+#include "pmo.h"
+#include "mutex.h"
+#include "event.h"
+#include "lmc.h"
+#include "thread.h"
+#include "mutex.h"
+#include "queue.h"
+#include "semaphore.h"
+
+extern "C"
+{
+#include "mhead.h"
+#include "port.h"
+}
+
+#define BS_BUFBYTES 60000U
+#define PCM_BUFBYTES 60000U
+
+typedef struct
+{
+ int (*decode_init) (MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code,
+ int convert_code, int freq_limit);
+ void (*decode_info) (DEC_INFO * info);
+ IN_OUT(*decode) (unsigned char *bs, short *pcm);
+}
+AUDIO;
+
+#define FRAMES_FLAG 0x0001
+#define BYTES_FLAG 0x0002
+#define TOC_FLAG 0x0004
+#define VBR_SCALE_FLAG 0x0008
+
+#define FRAMES_AND_BYTES (FRAMES_FLAG | BYTES_FLAG)
+
+// structure to receive extracted header
+// toc may be NULL
+typedef struct
+{
+ int h_id; // from MPEG header, 0=MPEG2, 1=MPEG1
+ int samprate; // determined from MPEG header
+ int flags; // from Xing header data
+ int frames; // total bit stream frames from Xing header data
+ int bytes; // total bit stream bytes from Xing header data
+ int vbr_scale; // encoded vbr scale from Xing header data
+ unsigned char *toc; // pointer to unsigned char toc_buffer[100]
+ // may be NULL if toc not desired
+} XHEADDATA;
+
+enum
+{
+ lmcError_MinimumError = 1000,
+ lmcError_DecodeFailed,
+ lmcError_AudioDecodeInitFailed,
+ lmcError_DecoderThreadFailed,
+ lmcError_PMIError,
+ lmcError_PMOError,
+ lmcError_MaximumError
+};
+
+class XingLMC:public LogicalMediaConverter
+{
+
+ public:
+ XingLMC(FAContext *context);
+ virtual ~XingLMC();
+
+ virtual uint32 CalculateSongLength(const char *url);
+
+ virtual Error ChangePosition(int32 position);
+
+ virtual Error CanDecode();
+ virtual void Clear();
+ virtual Error ExtractMediaInfo();
+
+ virtual void SetPMI(PhysicalMediaInput *pmi) { m_pPmi = pmi; };
+ virtual void SetPMO(PhysicalMediaOutput *pmo) { m_pPmo = pmo; };
+ virtual Error Prepare(PullBuffer *pInputBuffer, PullBuffer *&pOutBuffer);
+ virtual Error InitDecoder();
+
+ virtual Error SetEQData(float *);
+ virtual Error SetEQData(bool);
+
+ virtual vector<char *> *GetExtensions(void);
+
+ private:
+
+ static void DecodeWorkerThreadFunc(void *);
+ void DecodeWork();
+ Error BeginRead(void *&pBuffer, unsigned int iBytesNeeded,
+ bool bBufferUp = true);
+ Error BlockingBeginRead(void *&pBuffer,
+ unsigned int iBytesNeeded);
+ Error EndRead(size_t iBytesUsed);
+ Error AdvanceBufferToNextFrame();
+ Error GetHeadInfo();
+ Error GetBitstreamStats(float &fTotalSeconds, float &fMsPerFrame,
+ int &iTotalFrames, int &iSampleRate,
+ int &iLayer);
+
+ int GetXingHeader(XHEADDATA *X, unsigned char *buf);
+ int SeekPoint(unsigned char TOC[100], int file_bytes, float percent);
+ int ExtractI4(unsigned char *buf);
+
+ PhysicalMediaInput *m_pPmi;
+ PhysicalMediaOutput *m_pPmo;
+
+ int m_iMaxWriteSize;
+ int32 m_frameBytes, m_iBufferUpInterval, m_iBufferSize;
+ size_t m_lFileSize;
+ MPEG_HEAD m_sMpegHead;
+ int32 m_iBitRate;
+ bool m_bBufferingUp;
+ Thread *m_decoderThread;
+
+ int32 m_frameCounter;
+ time_t m_iBufferUpdate;
+ char *m_szUrl;
+ const char *m_szError;
+ AUDIO m_audioMethods;
+ XHEADDATA *m_pXingHeader;
+
+ // These vars are used for a nasty hack.
+ FILE *m_fpFile;
+ char *m_pLocalReadBuffer;
+};
+
+#endif /* _XINGLMC_H */
+
+
+
+
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** cdct.c ***************************************************
+
+mod 5/16/95 first stage in 8 pt dct does not drop last sb mono
+
+
+MPEG audio decoder, dct
+portable C
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h"
+
+#ifdef ASM_X86
+extern void fdct32_asm(float*a, float*b);
+extern void fdct32_dual_asm(float*a, float*b);
+#endif /* ASM_X86 */
+
+/*------------------------------------------------------------*/
+float *dct_coef_addr(MPEG *m)
+{
+ return m->cdct.coef32;
+}
+/*------------------------------------------------------------*/
+static void forward_bf(int m, int n, float x[], float f[], float coef[])
+{
+ int i, j, n2;
+ int p, q, p0, k;
+
+ p0 = 0;
+ n2 = n >> 1;
+ for (i = 0; i < m; i++, p0 += n)
+ {
+ k = 0;
+ p = p0;
+ q = p + n - 1;
+ for (j = 0; j < n2; j++, p++, q--, k++)
+ {
+ f[p] = x[p] + x[q];
+ f[n2 + p] = coef[k] * (x[p] - x[q]);
+ }
+ }
+}
+/*------------------------------------------------------------*/
+static void back_bf(int m, int n, float x[], float f[])
+{
+ int i, j, n2, n21;
+ int p, q, p0;
+
+ p0 = 0;
+ n2 = n >> 1;
+ n21 = n2 - 1;
+ for (i = 0; i < m; i++, p0 += n)
+ {
+ p = p0;
+ q = p0;
+ for (j = 0; j < n2; j++, p += 2, q++)
+ f[p] = x[q];
+ p = p0 + 1;
+ for (j = 0; j < n21; j++, p += 2, q++)
+ f[p] = x[q] + x[q + 1];
+ f[p] = x[q];
+ }
+}
+/*------------------------------------------------------------*/
+
+#ifdef _EQUALIZER_ENABLE_
+extern float equalizer[32];
+extern int enableEQ;
+#endif
+
+void fdct32(MPEG *m, float x[], float c[])
+{
+#if (!defined(ASM_X86) && !defined(ASM_X86_OLD) || defined(_EQUALIZER_ENABLE_))
+ float a[32]; /* ping pong buffers */
+ float b[32];
+ int p, q;
+#endif
+
+ float *src = x;
+
+#ifdef _EQUALIZER_ENABLE_
+ int i;
+ float b[32];
+ if (enableEQ) {
+ for(i=0; i<32; i++)
+ b[i] = x[i] * equalizer[i];
+ src = b;
+ }
+#endif /* _EQUALIZER_ENABLE_ */
+#undef _EQUALIZER_ENABLE_
+
+#ifdef ASM_X86
+ fdct32_asm(src, c);
+#elif defined(ASM_X86_OLD)
+ asm_fdct32(src, c);
+#else
+/* special first stage */
+ for (p = 0, q = 31; p < 16; p++, q--)
+ {
+ a[p] = src[p] + src[q];
+ a[16 + p] = m->cdct.coef32[p] * (src[p] - src[q]);
+ }
+ forward_bf(2, 16, a, b, m->cdct.coef32 + 16);
+ forward_bf(4, 8, b, a, m->cdct.coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(16, 2, b, a, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf(1, 32, b, c);
+#endif
+}
+/*------------------------------------------------------------*/
+void fdct32_dual(MPEG *m, float x[], float c[])
+{
+#ifdef ASM_X86
+ fdct32_dual_asm(x, c);
+#else
+ float a[32]; /* ping pong buffers */
+ float b[32];
+ int p, pp, qq;
+
+/* special first stage for dual chan (interleaved x) */
+ pp = 0;
+ qq = 2 * 31;
+ for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+ {
+ a[p] = x[pp] + x[qq];
+ a[16 + p] = m->cdct.coef32[p] * (x[pp] - x[qq]);
+ }
+ forward_bf(2, 16, a, b, m->cdct.coef32 + 16);
+ forward_bf(4, 8, b, a, m->cdct.coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(16, 2, b, a, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf(1, 32, b, c);
+#endif
+}
+/*---------------convert dual to mono------------------------------*/
+void fdct32_dual_mono(MPEG *m, float x[], float c[])
+{
+ float a[32]; /* ping pong buffers */
+ float b[32];
+ float t1, t2;
+ int p, pp, qq;
+
+/* special first stage */
+ pp = 0;
+ qq = 2 * 31;
+ for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+ {
+ t1 = 0.5F * (x[pp] + x[pp + 1]);
+ t2 = 0.5F * (x[qq] + x[qq + 1]);
+ a[p] = t1 + t2;
+ a[16 + p] = m->cdct.coef32[p] * (t1 - t2);
+ }
+ forward_bf(2, 16, a, b, m->cdct.coef32 + 16);
+ forward_bf(4, 8, b, a, m->cdct.coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(16, 2, b, a, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf(1, 32, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct -------------------------------*/
+void fdct16(MPEG *m, float x[], float c[])
+{
+ float a[16]; /* ping pong buffers */
+ float b[16];
+ int p, q;
+
+/* special first stage (drop highest sb) */
+ a[0] = x[0];
+ a[8] = m->cdct.coef32[16] * x[0];
+ for (p = 1, q = 14; p < 8; p++, q--)
+ {
+ a[p] = x[p] + x[q];
+ a[8 + p] = m->cdct.coef32[16 + p] * (x[p] - x[q]);
+ }
+ forward_bf(2, 8, a, b, m->cdct.coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(8, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual chan---------------------*/
+void fdct16_dual(MPEG *m, float x[], float c[])
+{
+ float a[16]; /* ping pong buffers */
+ float b[16];
+ int p, pp, qq;
+
+/* special first stage for interleaved input */
+ a[0] = x[0];
+ a[8] = m->cdct.coef32[16] * x[0];
+ pp = 2;
+ qq = 2 * 14;
+ for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+ {
+ a[p] = x[pp] + x[qq];
+ a[8 + p] = m->cdct.coef32[16 + p] * (x[pp] - x[qq]);
+ }
+ forward_bf(2, 8, a, b, m->cdct.coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(8, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual to mono-------------------*/
+void fdct16_dual_mono(MPEG *m, float x[], float c[])
+{
+ float a[16]; /* ping pong buffers */
+ float b[16];
+ float t1, t2;
+ int p, pp, qq;
+
+/* special first stage */
+ a[0] = 0.5F * (x[0] + x[1]);
+ a[8] = m->cdct.coef32[16] * a[0];
+ pp = 2;
+ qq = 2 * 14;
+ for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+ {
+ t1 = 0.5F * (x[pp] + x[pp + 1]);
+ t2 = 0.5F * (x[qq] + x[qq + 1]);
+ a[p] = t1 + t2;
+ a[8 + p] = m->cdct.coef32[16 + p] * (t1 - t2);
+ }
+ forward_bf(2, 8, a, b, m->cdct.coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(8, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct -------------------------------*/
+void fdct8(MPEG *m, float x[], float c[])
+{
+ float a[8]; /* ping pong buffers */
+ float b[8];
+ int p, q;
+
+/* special first stage */
+
+ b[0] = x[0] + x[7];
+ b[4] = m->cdct.coef32[16 + 8] * (x[0] - x[7]);
+ for (p = 1, q = 6; p < 4; p++, q--)
+ {
+ b[p] = x[p] + x[q];
+ b[4 + p] = m->cdct.coef32[16 + 8 + p] * (x[p] - x[q]);
+ }
+
+ forward_bf(2, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(4, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(2, 4, b, a);
+ back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual chan---------------------*/
+void fdct8_dual(MPEG *m, float x[], float c[])
+{
+ float a[8]; /* ping pong buffers */
+ float b[8];
+ int p, pp, qq;
+
+/* special first stage for interleaved input */
+ b[0] = x[0] + x[14];
+ b[4] = m->cdct.coef32[16 + 8] * (x[0] - x[14]);
+ pp = 2;
+ qq = 2 * 6;
+ for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+ {
+ b[p] = x[pp] + x[qq];
+ b[4 + p] = m->cdct.coef32[16 + 8 + p] * (x[pp] - x[qq]);
+ }
+ forward_bf(2, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(4, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(2, 4, b, a);
+ back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual to mono---------------------*/
+void fdct8_dual_mono(MPEG *m, float x[], float c[])
+{
+ float a[8]; /* ping pong buffers */
+ float b[8];
+ float t1, t2;
+ int p, pp, qq;
+
+/* special first stage */
+ t1 = 0.5F * (x[0] + x[1]);
+ t2 = 0.5F * (x[14] + x[15]);
+ b[0] = t1 + t2;
+ b[4] = m->cdct.coef32[16 + 8] * (t1 - t2);
+ pp = 2;
+ qq = 2 * 6;
+ for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+ {
+ t1 = 0.5F * (x[pp] + x[pp + 1]);
+ t2 = 0.5F * (x[qq] + x[qq + 1]);
+ b[p] = t1 + t2;
+ b[4 + p] = m->cdct.coef32[16 + 8 + p] * (t1 - t2);
+ }
+ forward_bf(2, 4, b, a, m->cdct.coef32 + 16 + 8 + 4);
+ forward_bf(4, 2, a, b, m->cdct.coef32 + 16 + 8 + 4 + 2);
+ back_bf(2, 4, b, a);
+ back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** csbt.c ***************************************************
+
+MPEG audio decoder, dct and window
+portable C
+
+1/7/96 mod for Layer III
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h"
+
+void fdct32(MPEG *m, float *, float *);
+void fdct32_dual(MPEG *m, float *, float *);
+void fdct32_dual_mono(MPEG *m, float *, float *);
+void fdct16(MPEG *m, float *, float *);
+void fdct16_dual(MPEG *m, float *, float *);
+void fdct16_dual_mono(MPEG *m, float *, float *);
+void fdct8(MPEG *m, float *, float *);
+void fdct8_dual(MPEG *m, float *, float *);
+void fdct8_dual_mono(MPEG *m, float *, float *);
+
+void window(float *, int , short *pcm);
+void window_dual(MPEG *m, float *, int , short *pcm);
+void window16(MPEG *m, float *, int , short *pcm);
+void window16_dual(MPEG *m, float *, int , short *pcm);
+void window8(MPEG *m, float *, int , short *pcm);
+void window8_dual(MPEG *m, float *, int , short *pcm);
+float *dct_coef_addr(MPEG *m);
+
+/*-------------------------------------------------------------------------*/
+/* circular window buffers */
+
+/*======================================================================*/
+static void gencoef(MPEG *m) /* gen coef for N=32 (31 coefs) */
+{
+ int p, n, i, k;
+ double t, pi;
+ float *coef32;
+
+ coef32 = dct_coef_addr(m);
+
+ pi = 4.0 * atan(1.0);
+ n = 16;
+ k = 0;
+ for (i = 0; i < 5; i++, n = n / 2)
+ {
+
+ for (p = 0; p < n; p++, k++)
+ {
+ t = (pi / (4 * n)) * (2 * p + 1);
+ coef32[k] = (float) (0.50 / cos(t));
+ }
+ }
+}
+/*------------------------------------------------------------*/
+void sbt_init(MPEG *m)
+{
+ int i;
+
+ if (m->csbt.first_pass)
+ {
+ gencoef(m);
+ m->csbt.first_pass = 0;
+ }
+
+/* clear window m->csbt.vbuf */
+ for (i = 0; i < 512; i++)
+ {
+ m->csbt.vbuf[i] = 0.0F;
+ m->csbt.vbuf2[i] = 0.0F;
+ }
+ m->csbt.vb2_ptr = m->csbt.vb_ptr = 0;
+
+}
+/*============================================================*/
+/*============================================================*/
+/*============================================================*/
+void sbt_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32(m, sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window(m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbt_dual(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct32_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ window_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ window_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbt_dual_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window(m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbt_dual_left(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window(m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbt_dual_right(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ sample++; /* point to right chan */
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window(m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+void sbt16_dual(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct16_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ window16_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ window16_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_left(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_right(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbt8_dual(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct8_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ window8_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ window8_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_mono(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_left(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_right(MPEG *m, float *sample, short *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+#include "csbtb.c" /* 8 bit output */
+#include "csbtL3.c" /* Layer III */
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** csbtL3.c ***************************************************
+
+layer III
+
+ include to csbt.c
+
+******************************************************************/
+/*============================================================*/
+/*============ Layer III =====================================*/
+/*============================================================*/
+void sbt_mono_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window(m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbt_dual_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+ if (ch == 0)
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+ else
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ window_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 32) & 511;
+ pcm += 64;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+
+ if (ch == 0)
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window16_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ window16_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 16) & 255;
+ pcm += 32;
+ }
+ }
+
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_L3(MPEG *m, float *sample, short *pcm, int ch)
+{
+ int i;
+
+ if (ch == 0)
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ window8_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ window8_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 8) & 127;
+ pcm += 16;
+ }
+ }
+
+
+
+}
+/*------------------------------------------------------------*/
+/*------- 8 bit output ---------------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbtB_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ if (ch == 0)
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+ else
+ for (i = 0; i < 18; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ windowB_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 32) & 511;
+ pcm += 64;
+ }
+
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbtB's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ if (ch == 0)
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ windowB16_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 16) & 255;
+ pcm += 32;
+ }
+ }
+
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbtB's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ ch = 0;
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch)
+{
+ int i;
+
+ if (ch == 0)
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 32;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 18; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf2 + m->csbt.vb2_ptr);
+ windowB8_dual(m,m->csbt.vbuf2, m->csbt.vb2_ptr, pcm + 1);
+ sample += 32;
+ m->csbt.vb2_ptr = (m->csbt.vb2_ptr - 8) & 127;
+ pcm += 16;
+ }
+ }
+
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** csbtb.c ***************************************************
+include to csbt.c
+
+MPEG audio decoder, dct and window - byte (8 pcm bit output)
+portable C
+
+******************************************************************/
+/*============================================================*/
+/*============================================================*/
+void windowB(MPEG *m, float *, int , unsigned char *pcm);
+void windowB_dual(MPEG *m, float *, int , unsigned char *pcm);
+void windowB16(MPEG *m, float *, int , unsigned char *pcm);
+void windowB16_dual(MPEG *m, float *, int , unsigned char *pcm);
+void windowB8(MPEG *m, float *, int , unsigned char *pcm);
+void windowB8_dual(MPEG *m, float *, int , unsigned char *pcm);
+
+/*============================================================*/
+void sbtB_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbtB_dual(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct32_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ windowB_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ windowB_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbtB_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbtB_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbtB_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++; /* point to right chan */
+ for (i = 0; i < n; i++)
+ {
+ fdct32_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct16_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ windowB16_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ windowB16_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ fdct16_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB16(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ fdct8_dual(m,sample + 1, m->csbt.vbuf2 + m->csbt.vb_ptr);
+ windowB8_dual(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ windowB8_dual(m,m->csbt.vbuf2, m->csbt.vb_ptr, pcm + 1);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual_mono(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ fdct8_dual(m,sample, m->csbt.vbuf + m->csbt.vb_ptr);
+ windowB8(m,m->csbt.vbuf, m->csbt.vb_ptr, pcm);
+ sample += 64;
+ m->csbt.vb_ptr = (m->csbt.vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*=========================================================
+ initialization for cup.c - include to cup.c
+ mpeg audio decoder portable "c"
+
+mod 8/6/96 add 8 bit output
+
+mod 5/10/95 add quick (low precision) window
+
+mod 5/16/95 sb limit for reduced samprate output
+ changed from 94% to 100% of Nyquist sb
+
+mod 11/15/95 for Layer I
+
+
+=========================================================*/
+/*-- compiler bug, floating constant overflow w/ansi --*/
+#ifdef _MSC_VER
+#pragma warning(disable:4056)
+#endif
+
+
+
+/* Read Only */
+static long steps[18] =
+{
+ 0, 3, 5, 7, 9, 15, 31, 63, 127,
+ 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
+
+
+/* ABCD_INDEX = lookqt[mode][sr_index][br_index] */
+/* -1 = invalid */
+/* Read Only */
+static signed char lookqt[4][3][16] =
+{
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks stereo */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks joint stereo */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks dual chan */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+// mono extended beyond legal br index
+// 1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 44ks single chan */
+// 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1, /* 48ks */
+// 1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 32ks */
+// legal mono
+ {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}, /* 44ks single chan */
+ {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1}, /* 48ks */
+ {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}}, /* 32ks */
+};
+/* Read Only */
+static long sr_table[8] =
+{22050L, 24000L, 16000L, 1L,
+ 44100L, 48000L, 32000L, 1L};
+
+/* bit allocation table look up */
+/* table per mpeg spec tables 3b2a/b/c/d /e is mpeg2 */
+/* look_bat[abcd_index][4][16] */
+/* Read Only */
+static unsigned char look_bat[5][4][16] =
+{
+/* LOOK_BATA */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+ {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATB */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+ {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATC */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATD */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATE */
+ {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+};
+
+/* look_nbat[abcd_index]][4] */
+/* Read Only */
+static unsigned char look_nbat[5][4] =
+{
+ {3, 8, 12, 4},
+ {3, 8, 12, 7},
+ {2, 0, 6, 0},
+ {2, 0, 10, 0},
+ {4, 0, 7, 19},
+};
+
+
+void sbt_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt_dual(MPEG *m, float *sample, short *pcm, int n);
+void sbt_dual_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt_dual_left(MPEG *m, float *sample, short *pcm, int n);
+void sbt_dual_right(MPEG *m, float *sample, short *pcm, int n);
+void sbt16_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt16_dual(MPEG *m, float *sample, short *pcm, int n);
+void sbt16_dual_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt16_dual_left(MPEG *m, float *sample, short *pcm, int n);
+void sbt16_dual_right(MPEG *m, float *sample, short *pcm, int n);
+void sbt8_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt8_dual(MPEG *m, float *sample, short *pcm, int n);
+void sbt8_dual_mono(MPEG *m, float *sample, short *pcm, int n);
+void sbt8_dual_left(MPEG *m, float *sample, short *pcm, int n);
+void sbt8_dual_right(MPEG *m, float *sample, short *pcm, int n);
+
+/*--- 8 bit output ---*/
+void sbtB_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB16_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB16_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB8_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB8_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
+
+
+static SBT_FUNCTION_F sbt_table[2][3][5] =
+{
+ {{sbt_mono, sbt_dual, sbt_dual_mono, sbt_dual_left, sbt_dual_right},
+ {sbt16_mono, sbt16_dual, sbt16_dual_mono, sbt16_dual_left, sbt16_dual_right},
+ {sbt8_mono, sbt8_dual, sbt8_dual_mono, sbt8_dual_left, sbt8_dual_right}},
+ {{(SBT_FUNCTION_F) sbtB_mono,
+ (SBT_FUNCTION_F) sbtB_dual,
+ (SBT_FUNCTION_F) sbtB_dual_mono,
+ (SBT_FUNCTION_F) sbtB_dual_left,
+ (SBT_FUNCTION_F) sbtB_dual_right},
+ {(SBT_FUNCTION_F) sbtB16_mono,
+ (SBT_FUNCTION_F) sbtB16_dual,
+ (SBT_FUNCTION_F) sbtB16_dual_mono,
+ (SBT_FUNCTION_F) sbtB16_dual_left,
+ (SBT_FUNCTION_F) sbtB16_dual_right},
+ {(SBT_FUNCTION_F) sbtB8_mono,
+ (SBT_FUNCTION_F) sbtB8_dual,
+ (SBT_FUNCTION_F) sbtB8_dual_mono,
+ (SBT_FUNCTION_F) sbtB8_dual_left,
+ (SBT_FUNCTION_F) sbtB8_dual_right}},
+};
+
+static int out_chans[5] =
+{1, 2, 1, 1, 1};
+
+
+int audio_decode_initL1(MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+void sbt_init();
+
+
+IN_OUT L1audio_decode(void *mv, unsigned char *bs, signed short *pcm);
+IN_OUT L2audio_decode(void *mv, unsigned char *bs, signed short *pcm);
+IN_OUT L3audio_decode(void *mv, unsigned char *bs, unsigned char *pcm);
+static AUDIO_DECODE_ROUTINE decode_routine_table[4] =
+{
+ L2audio_decode,
+ (AUDIO_DECODE_ROUTINE)L3audio_decode,
+ L2audio_decode,
+ L1audio_decode,};
+
+extern void cup3_init(MPEG *m);
+
+void mpeg_init(MPEG *m)
+{
+ memset(m, 0, sizeof(MPEG));
+ m->cup.nsb_limit = 6;
+ m->cup.nbat[0] = 3;
+ m->cup.nbat[1] = 8;
+ m->cup.nbat[3] = 12;
+ m->cup.nbat[4] = 7;
+ m->cup.sbt = sbt_mono;
+ m->cup.first_pass = 1;
+ m->cup.first_pass_L1 = 1;
+ m->cup.audio_decode_routine = L2audio_decode;
+ m->cup.cs_factorL1 = m->cup.cs_factor[0];
+ m->cup.nbatL1 = 32;
+ m->cupl.band_limit = 576;
+ m->cupl.band_limit21 = 567;
+ m->cupl.band_limit12 = 576;
+ m->cupl.band_limit_nsb = 32;
+ m->cupl.nsb_limit=32;
+ m->cup.sample = (float *)&m->cupl.sample;
+ m->csbt.first_pass = 1;
+ cup3_init(m);
+}
+
+/*---------------------------------------------------------*/
+static void table_init(MPEG *m)
+{
+ int i, j;
+ int code;
+
+/*-- c_values (dequant) --*/
+ for (i = 1; i < 18; i++)
+ m->cup.look_c_value[i] = 2.0F / steps[i];
+
+/*-- scale factor table, scale by 32768 for 16 pcm output --*/
+ for (i = 0; i < 64; i++)
+ m->cup.sf_table[i] = (float) (32768.0 * 2.0 * pow(2.0, -i / 3.0));
+
+/*-- grouped 3 level lookup table 5 bit token --*/
+ for (i = 0; i < 32; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->cup.group3_table[i][j] = (char) ((code % 3) - 1);
+ code /= 3;
+ }
+ }
+/*-- grouped 5 level lookup table 7 bit token --*/
+ for (i = 0; i < 128; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->cup.group5_table[i][j] = (char) ((code % 5) - 2);
+ code /= 5;
+ }
+ }
+/*-- grouped 9 level lookup table 10 bit token --*/
+ for (i = 0; i < 1024; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->cup.group9_table[i][j] = (short) ((code % 9) - 4);
+ code /= 9;
+ }
+ }
+
+
+}
+/*---------------------------------------------------------*/
+int L1audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+int L3audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h frame bytes is without pad */
+int audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+{
+ int i, j, k;
+ int abcd_index;
+ long samprate;
+ int limit;
+ int bit_code;
+
+ if (m->cup.first_pass)
+ {
+ table_init(m);
+ m->cup.first_pass = 0;
+ }
+
+/* select decoder routine Layer I,II,III */
+ m->cup.audio_decode_routine = decode_routine_table[h->option & 3];
+
+
+ if (h->option == 3) /* layer I */
+ return L1audio_decode_init(m, h, framebytes_arg,
+ reduction_code, transform_code, convert_code, freq_limit);
+
+ if (h->option == 1) /* layer III */
+ return L3audio_decode_init(m, h, framebytes_arg,
+ reduction_code, transform_code, convert_code, freq_limit);
+
+
+
+ transform_code = transform_code; /* not used, asm compatability */
+ bit_code = 0;
+ if (convert_code & 8)
+ bit_code = 1;
+ convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
+ if (reduction_code < 0)
+ reduction_code = 0;
+ if (reduction_code > 2)
+ reduction_code = 2;
+ if (freq_limit < 1000)
+ freq_limit = 1000;
+
+
+ m->cup.framebytes = framebytes_arg;
+/* check if code handles */
+ if (h->option != 2)
+ return 0; /* layer II only */
+ if (h->sr_index == 3)
+ return 0; /* reserved */
+
+/* compute abcd index for bit allo table selection */
+ if (h->id) /* mpeg 1 */
+ abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
+ else
+ abcd_index = 4; /* mpeg 2 */
+
+ if (abcd_index < 0)
+ return 0; // fail invalid Layer II bit rate index
+
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 16; j++)
+ m->cup.bat[i][j] = look_bat[abcd_index][i][j];
+ for (i = 0; i < 4; i++)
+ m->cup.nbat[i] = look_nbat[abcd_index][i];
+ m->cup.max_sb = m->cup.nbat[0] + m->cup.nbat[1] + m->cup.nbat[2] + m->cup.nbat[3];
+/*----- compute nsb_limit --------*/
+ samprate = sr_table[4 * h->id + h->sr_index];
+ m->cup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code); ----*/
+ limit = (32 >> reduction_code);
+ if (limit > 8)
+ limit--;
+ if (m->cup.nsb_limit > limit)
+ m->cup.nsb_limit = limit;
+ if (m->cup.nsb_limit > m->cup.max_sb)
+ m->cup.nsb_limit = m->cup.max_sb;
+
+ m->cup.outvalues = 1152 >> reduction_code;
+ if (h->mode != 3)
+ { /* adjust for 2 channel modes */
+ for (i = 0; i < 4; i++)
+ m->cup.nbat[i] *= 2;
+ m->cup.max_sb *= 2;
+ m->cup.nsb_limit *= 2;
+ }
+
+/* set sbt function */
+ k = 1 + convert_code;
+ if (h->mode == 3)
+ {
+ k = 0;
+ }
+ m->cup.sbt = sbt_table[bit_code][reduction_code][k];
+ m->cup.outvalues *= out_chans[k];
+ if (bit_code)
+ m->cup.outbytes = m->cup.outvalues;
+ else
+ m->cup.outbytes = sizeof(short) * m->cup.outvalues;
+
+ m->cup.decinfo.channels = out_chans[k];
+ m->cup.decinfo.outvalues = m->cup.outvalues;
+ m->cup.decinfo.samprate = samprate >> reduction_code;
+ if (bit_code)
+ m->cup.decinfo.bits = 8;
+ else
+ m->cup.decinfo.bits = sizeof(short) * 8;
+
+ m->cup.decinfo.framebytes = m->cup.framebytes;
+ m->cup.decinfo.type = 0;
+
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+ for (i = 0; i < 2304; i++)
+ m->cup.sample[i] = 0.0F;
+
+
+/* init sub-band transform */
+ sbt_init();
+
+ return 1;
+}
+/*---------------------------------------------------------*/
+void audio_decode_info(MPEG *m, DEC_INFO * info)
+{
+ *info = m->cup.decinfo; /* info return, call after init */
+}
+/*---------------------------------------------------------*/
+void decode_table_init(MPEG *m)
+{
+/* dummy for asm version compatability */
+}
+/*---------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** cupL3.c ***************************************************
+unpack Layer III
+
+
+mod 8/18/97 bugfix crc problem
+
+mod 10/9/97 add band_limit12 for short blocks
+
+mod 10/22/97 zero buf_ptrs in init
+
+mod 5/15/98 mpeg 2.5
+
+mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+/*---------------------------------------
+TO DO: Test mixed blocks (mixed long/short)
+ No mixed blocks in mpeg-1 test stream being used for development
+
+-----------------------------------------*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <memory.h>
+#include <string.h>
+#include <assert.h>
+#include "L3.h"
+#include "mhead.h" /* mpeg header structure */
+#include "jdw.h"
+#include "protos.h"
+
+
+/*====================================================================*/
+static int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+static int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}, /* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+/*====================================================================*/
+
+/*-- global band tables */
+/*-- short portion is 3*x !! --*/
+
+/*====================================================================*/
+
+/*---------------------------------*/
+/*---------------------------------*/
+/*- sample union of int/float sample[ch][gr][576] */
+/* Sample is the same as cup.sample */
+
+void sbt_dual_L3(MPEG *m, float *sample, short *pcm, int n);
+
+IN_OUT L3audio_decode_MPEG1(void *mv, unsigned char *bs, unsigned char *pcm);
+IN_OUT L3audio_decode_MPEG2(void *mv, unsigned char *bs, unsigned char *pcm);
+/*
+static DECODE_FUNCTION decode_function = L3audio_decode_MPEG1;
+*/
+
+/*====================================================================*/
+/* get bits from bitstream in endian independent way */
+
+BITDAT bitdat; /* global for inline use by Huff */
+
+/*------------- initialize bit getter -------------*/
+static void bitget_init(unsigned char *buf)
+{
+ bitdat.bs_ptr0 = bitdat.bs_ptr = buf;
+ bitdat.bits = 0;
+ bitdat.bitbuf = 0;
+}
+/*------------- initialize bit getter -------------*/
+static void bitget_init_end(unsigned char *buf_end)
+{
+ bitdat.bs_ptr_end = buf_end;
+}
+/*------------- get n bits from bitstream -------------*/
+int bitget_bits_used()
+{
+ int n; /* compute bits used from last init call */
+
+ n = ((bitdat.bs_ptr - bitdat.bs_ptr0) << 3) - bitdat.bits;
+ return n;
+}
+/*------------- check for n bits in bitbuf -------------*/
+void bitget_check(int n)
+{
+ if (bitdat.bits < n)
+ {
+ while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+}
+/*------------- get n bits from bitstream -------------*/
+unsigned int bitget(int n)
+{
+ unsigned int x;
+
+ if (bitdat.bits < n)
+ { /* refill bit buf if necessary */
+ while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+ bitdat.bits -= n;
+ x = bitdat.bitbuf >> bitdat.bits;
+ bitdat.bitbuf -= x << bitdat.bits;
+ return x;
+}
+/*------------- get 1 bit from bitstream -------------*/
+unsigned int bitget_1bit()
+{
+ unsigned int x;
+
+ if (bitdat.bits <= 0)
+ { /* refill bit buf if necessary */
+ while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+ bitdat.bits--;
+ x = bitdat.bitbuf >> bitdat.bits;
+ bitdat.bitbuf -= x << bitdat.bits;
+ return x;
+}
+/*====================================================================*/
+static void Xform_mono(void *mv, void *pcm, int igr)
+{
+ MPEG *m = mv;
+ int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+ n1 = n2 = m->cupl.nsamp[igr][0]; /* total number bands */
+ if (m->cupl.side_info.gr[igr][0].block_type == 2)
+ { /* long bands */
+ n1 = 0;
+ if (m->cupl.side_info.gr[igr][0].mixed_block_flag)
+ n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
+ }
+ if (n1 > m->cupl.band_limit)
+ n1 = m->cupl.band_limit;
+ if (n2 > m->cupl.band_limit)
+ n2 = m->cupl.band_limit;
+ igr_prev = igr ^ 1;
+
+ m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
+ m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
+ FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][0]);
+ m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
+
+}
+
+/*--------------------------------------------------------------------*/
+static void Xform_dual_right(void *mv, void *pcm, int igr)
+{
+ MPEG *m = mv;
+ int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+ n1 = n2 = m->cupl.nsamp[igr][1]; /* total number bands */
+ if (m->cupl.side_info.gr[igr][1].block_type == 2)
+ { /* long bands */
+ n1 = 0;
+ if (m->cupl.side_info.gr[igr][1].mixed_block_flag)
+ n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
+ }
+ if (n1 > m->cupl.band_limit)
+ n1 = m->cupl.band_limit;
+ if (n2 > m->cupl.band_limit)
+ n2 = m->cupl.band_limit;
+ igr_prev = igr ^ 1;
+ m->cupl.nsamp[igr][1] = hybrid(m,m->cupl.sample[1][igr], m->cupl.sample[1][igr_prev],
+ m->cupl.yout, m->cupl.side_info.gr[igr][1].block_type, n1, n2, m->cupl.nsamp[igr_prev][1]);
+ FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][1]);
+ m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual(void *mv, void *pcm, int igr)
+{
+ MPEG *m = mv;
+ int ch;
+ int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+ igr_prev = igr ^ 1;
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ n1 = n2 = m->cupl.nsamp[igr][ch]; /* total number bands */
+ if (m->cupl.side_info.gr[igr][ch].block_type == 2)
+ { /* long bands */
+ n1 = 0;
+ if (m->cupl.side_info.gr[igr][ch].mixed_block_flag)
+ n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
+ }
+ if (n1 > m->cupl.band_limit)
+ n1 = m->cupl.band_limit;
+ if (n2 > m->cupl.band_limit)
+ n2 = m->cupl.band_limit;
+ m->cupl.nsamp[igr][ch] = hybrid(m,m->cupl.sample[ch][igr], m->cupl.sample[ch][igr_prev],
+ m->cupl.yout, m->cupl.side_info.gr[igr][ch].block_type, n1, n2, m->cupl.nsamp[igr_prev][ch]);
+ FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][ch]);
+ m->cupl.sbt_L3(m,m->cupl.yout, pcm, ch);
+ }
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual_mono(void *mv, void *pcm, int igr)
+{
+ MPEG *m = mv;
+ int igr_prev, n1, n2, n3;
+
+/*--- hybrid + sbt ---*/
+ igr_prev = igr ^ 1;
+ if ((m->cupl.side_info.gr[igr][0].block_type == m->cupl.side_info.gr[igr][1].block_type)
+ && (m->cupl.side_info.gr[igr][0].mixed_block_flag == 0)
+ && (m->cupl.side_info.gr[igr][1].mixed_block_flag == 0))
+ {
+
+ n2 = m->cupl.nsamp[igr][0]; /* total number bands max of L R */
+ if (n2 < m->cupl.nsamp[igr][1])
+ n2 = m->cupl.nsamp[igr][1];
+ if (n2 > m->cupl.band_limit)
+ n2 = m->cupl.band_limit;
+ n1 = n2; /* n1 = number long bands */
+ if (m->cupl.side_info.gr[igr][0].block_type == 2)
+ n1 = 0;
+ sum_f_bands(m->cupl.sample[0][igr], m->cupl.sample[1][igr], n2);
+ n3 = m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
+ m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
+ }
+ else
+ { /* transform and then sum (not tested - never happens in test) */
+/*-- left chan --*/
+ n1 = n2 = m->cupl.nsamp[igr][0]; /* total number bands */
+ if (m->cupl.side_info.gr[igr][0].block_type == 2)
+ {
+ n1 = 0; /* long bands */
+ if (m->cupl.side_info.gr[igr][0].mixed_block_flag)
+ n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
+ }
+ n3 = m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
+ m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
+/*-- right chan --*/
+ n1 = n2 = m->cupl.nsamp[igr][1]; /* total number bands */
+ if (m->cupl.side_info.gr[igr][1].block_type == 2)
+ {
+ n1 = 0; /* long bands */
+ if (m->cupl.side_info.gr[igr][1].mixed_block_flag)
+ n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
+ }
+ m->cupl.nsamp[igr][1] = hybrid_sum(m, m->cupl.sample[1][igr], m->cupl.sample[0][igr],
+ m->cupl.yout, m->cupl.side_info.gr[igr][1].block_type, n1, n2);
+ if (n3 < m->cupl.nsamp[igr][1])
+ n1 = m->cupl.nsamp[igr][1];
+ }
+
+/*--------*/
+ FreqInvert(m->cupl.yout, n3);
+ m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+/*====================================================================*/
+static int unpack_side_MPEG1(MPEG *m)
+{
+ int prot;
+ int br_index;
+ int igr, ch;
+ int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+ m->cupl.id = bitget(1); /* id */
+ bitget(2); /* skip layer */
+ prot = bitget(1); /* bitget prot bit */
+ br_index = bitget(4);
+ m->cupl.sr_index = bitget(2);
+ m->cupl.pad = bitget(1);
+ bitget(1); /* skip to mode */
+ m->cupl.side_info.mode = bitget(2); /* mode */
+ m->cupl.side_info.mode_ext = bitget(2); /* mode ext */
+
+ if (m->cupl.side_info.mode != 1)
+ m->cupl.side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+ m->cupl.ms_mode = m->cupl.side_info.mode_ext >> 1;
+ m->cupl.is_mode = m->cupl.side_info.mode_ext & 1;
+
+
+ m->cupl.crcbytes = 0;
+ if (prot)
+ bitget(4); /* skip to data */
+ else
+ {
+ bitget(20); /* skip crc */
+ m->cupl.crcbytes = 2;
+ }
+
+ if (br_index > 0) /* framebytes fixed for free format */
+ {
+ m->cupl.framebytes =
+ 2880 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
+ }
+
+ m->cupl.side_info.main_data_begin = bitget(9);
+ if (m->cupl.side_info.mode == 3)
+ {
+ m->cupl.side_info.private_bits = bitget(5);
+ m->cupl.nchan = 1;
+ m->cupl.stereo_flag = 0;
+ side_bytes = (4 + 17);
+/*-- with header --*/
+ }
+ else
+ {
+ m->cupl.side_info.private_bits = bitget(3);
+ m->cupl.nchan = 2;
+ m->cupl.stereo_flag = 1;
+ side_bytes = (4 + 32);
+/*-- with header --*/
+ }
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ m->cupl.side_info.scfsi[ch] = bitget(4);
+/* this always 0 (both igr) for short blocks */
+
+ for (igr = 0; igr < 2; igr++)
+ {
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ m->cupl.side_info.gr[igr][ch].part2_3_length = bitget(12);
+ m->cupl.side_info.gr[igr][ch].big_values = bitget(9);
+ m->cupl.side_info.gr[igr][ch].global_gain = bitget(8) + m->cupl.gain_adjust;
+ if (m->cupl.ms_mode)
+ m->cupl.side_info.gr[igr][ch].global_gain -= 2;
+ m->cupl.side_info.gr[igr][ch].scalefac_compress = bitget(4);
+ m->cupl.side_info.gr[igr][ch].window_switching_flag = bitget(1);
+ if (m->cupl.side_info.gr[igr][ch].window_switching_flag)
+ {
+ m->cupl.side_info.gr[igr][ch].block_type = bitget(2);
+ m->cupl.side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+ m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+ /* region count set in terms of long block cb's/bands */
+ /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+ /* if(window_switching_flag) always 36 samples in region0 */
+ m->cupl.side_info.gr[igr][ch].region0_count = (8 - 1); /* 36 samples */
+ m->cupl.side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+ }
+ else
+ {
+ m->cupl.side_info.gr[igr][ch].mixed_block_flag = 0;
+ m->cupl.side_info.gr[igr][ch].block_type = 0;
+ m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[2] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].region0_count = bitget(4);
+ m->cupl.side_info.gr[igr][ch].region1_count = bitget(3);
+ }
+ m->cupl.side_info.gr[igr][ch].preflag = bitget(1);
+ m->cupl.side_info.gr[igr][ch].scalefac_scale = bitget(1);
+ m->cupl.side_info.gr[igr][ch].count1table_select = bitget(1);
+ }
+ }
+
+
+
+/* return bytes in header + side info */
+ return side_bytes;
+}
+/*====================================================================*/
+static int unpack_side_MPEG2(MPEG *m, int igr)
+{
+ int prot;
+ int br_index;
+ int ch;
+ int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+ m->cupl.id = bitget(1); /* id */
+ bitget(2); /* skip layer */
+ prot = bitget(1); /* bitget prot bit */
+ br_index = bitget(4);
+ m->cupl.sr_index = bitget(2);
+ m->cupl.pad = bitget(1);
+ bitget(1); /* skip to mode */
+ m->cupl.side_info.mode = bitget(2); /* mode */
+ m->cupl.side_info.mode_ext = bitget(2); /* mode ext */
+
+ if (m->cupl.side_info.mode != 1)
+ m->cupl.side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+ m->cupl.ms_mode = m->cupl.side_info.mode_ext >> 1;
+ m->cupl.is_mode = m->cupl.side_info.mode_ext & 1;
+
+ m->cupl.crcbytes = 0;
+ if (prot)
+ bitget(4); /* skip to data */
+ else
+ {
+ bitget(20); /* skip crc */
+ m->cupl.crcbytes = 2;
+ }
+
+ if (br_index > 0)
+ { /* framebytes fixed for free format */
+ if (m->cupl.mpeg25_flag == 0)
+ {
+ m->cupl.framebytes =
+ 1440 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
+ }
+ else
+ {
+ m->cupl.framebytes =
+ 2880 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
+ //if( sr_index == 2 ) return 0; // fail mpeg25 8khz
+ }
+ }
+ m->cupl.side_info.main_data_begin = bitget(8);
+ if (m->cupl.side_info.mode == 3)
+ {
+ m->cupl.side_info.private_bits = bitget(1);
+ m->cupl.nchan = 1;
+ m->cupl.stereo_flag = 0;
+ side_bytes = (4 + 9);
+/*-- with header --*/
+ }
+ else
+ {
+ m->cupl.side_info.private_bits = bitget(2);
+ m->cupl.nchan = 2;
+ m->cupl.stereo_flag = 1;
+ side_bytes = (4 + 17);
+/*-- with header --*/
+ }
+ m->cupl.side_info.scfsi[1] = m->cupl.side_info.scfsi[0] = 0;
+
+
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ m->cupl.side_info.gr[igr][ch].part2_3_length = bitget(12);
+ m->cupl.side_info.gr[igr][ch].big_values = bitget(9);
+ m->cupl.side_info.gr[igr][ch].global_gain = bitget(8) + m->cupl.gain_adjust;
+ if (m->cupl.ms_mode)
+ m->cupl.side_info.gr[igr][ch].global_gain -= 2;
+ m->cupl.side_info.gr[igr][ch].scalefac_compress = bitget(9);
+ m->cupl.side_info.gr[igr][ch].window_switching_flag = bitget(1);
+ if (m->cupl.side_info.gr[igr][ch].window_switching_flag)
+ {
+ m->cupl.side_info.gr[igr][ch].block_type = bitget(2);
+ m->cupl.side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+ m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+ m->cupl.side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+ /* region count set in terms of long block cb's/bands */
+ /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+ /* bt=1 or 3 54 samples */
+ /* bt=2 mixed=0 36 samples */
+ /* bt=2 mixed=1 54 (8 long sf) samples? or maybe 36 */
+ /* region0 discussion says 54 but this would mix long */
+ /* and short in region0 if scale factors switch */
+ /* at band 36 (6 long scale factors) */
+ if ((m->cupl.side_info.gr[igr][ch].block_type == 2))
+ {
+ m->cupl.side_info.gr[igr][ch].region0_count = (6 - 1); /* 36 samples */
+ m->cupl.side_info.gr[igr][ch].region1_count = 20 - (6 - 1);
+ }
+ else
+ { /* long block type 1 or 3 */
+ m->cupl.side_info.gr[igr][ch].region0_count = (8 - 1); /* 54 samples */
+ m->cupl.side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+ }
+ }
+ else
+ {
+ m->cupl.side_info.gr[igr][ch].mixed_block_flag = 0;
+ m->cupl.side_info.gr[igr][ch].block_type = 0;
+ m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].table_select[2] = bitget(5);
+ m->cupl.side_info.gr[igr][ch].region0_count = bitget(4);
+ m->cupl.side_info.gr[igr][ch].region1_count = bitget(3);
+ }
+ m->cupl.side_info.gr[igr][ch].preflag = 0;
+ m->cupl.side_info.gr[igr][ch].scalefac_scale = bitget(1);
+ m->cupl.side_info.gr[igr][ch].count1table_select = bitget(1);
+ }
+
+/* return bytes in header + side info */
+ return side_bytes;
+}
+/*-----------------------------------------------------------------*/
+static void unpack_main(MPEG *m, unsigned char *pcm, int igr)
+{
+ int ch;
+ int bit0;
+ int n1, n2, n3, n4, nn2, nn3;
+ int nn4;
+ int qbits;
+ int m0;
+
+
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ bitget_init(m->cupl.buf + (m->cupl.main_pos_bit >> 3));
+ bit0 = (m->cupl.main_pos_bit & 7);
+ if (bit0)
+ bitget(bit0);
+ m->cupl.main_pos_bit += m->cupl.side_info.gr[igr][ch].part2_3_length;
+ bitget_init_end(m->cupl.buf + ((m->cupl.main_pos_bit + 39) >> 3));
+/*-- scale factors --*/
+ if (m->cupl.id)
+ unpack_sf_sub_MPEG1(&m->cupl.sf[igr][ch],
+ &m->cupl.side_info.gr[igr][ch], m->cupl.side_info.scfsi[ch], igr);
+ else
+ unpack_sf_sub_MPEG2(&m->cupl.sf[igr][ch],
+ &m->cupl.side_info.gr[igr][ch], m->cupl.is_mode & ch, &m->cupl.is_sf_info);
+/*--- huff data ---*/
+ n1 = m->cupl.sfBandIndex[0][m->cupl.side_info.gr[igr][ch].region0_count];
+ n2 = m->cupl.sfBandIndex[0][m->cupl.side_info.gr[igr][ch].region0_count
+ + m->cupl.side_info.gr[igr][ch].region1_count + 1];
+ n3 = m->cupl.side_info.gr[igr][ch].big_values;
+ n3 = n3 + n3;
+
+
+ if (n3 > m->cupl.band_limit)
+ n3 = m->cupl.band_limit;
+ if (n2 > n3)
+ n2 = n3;
+ if (n1 > n3)
+ n1 = n3;
+ nn3 = n3 - n2;
+ nn2 = n2 - n1;
+ unpack_huff(m->cupl.sample[ch][igr], n1, m->cupl.side_info.gr[igr][ch].table_select[0]);
+ unpack_huff(m->cupl.sample[ch][igr] + n1, nn2, m->cupl.side_info.gr[igr][ch].table_select[1]);
+ unpack_huff(m->cupl.sample[ch][igr] + n2, nn3, m->cupl.side_info.gr[igr][ch].table_select[2]);
+ qbits = m->cupl.side_info.gr[igr][ch].part2_3_length - (bitget_bits_used() - bit0);
+ nn4 = unpack_huff_quad(m->cupl.sample[ch][igr] + n3, m->cupl.band_limit - n3, qbits,
+ m->cupl.side_info.gr[igr][ch].count1table_select);
+ n4 = n3 + nn4;
+ m->cupl.nsamp[igr][ch] = n4;
+ //limit n4 or allow deqaunt to sf band 22
+ if (m->cupl.side_info.gr[igr][ch].block_type == 2)
+ n4 = min(n4, m->cupl.band_limit12);
+ else
+ n4 = min(n4, m->cupl.band_limit21);
+ if (n4 < 576)
+ memset(m->cupl.sample[ch][igr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ { // bad data overrun
+
+ memset(m->cupl.sample[ch][igr], 0, sizeof(SAMPLE) * (576));
+ }
+ }
+
+
+
+/*--- dequant ---*/
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ dequant(m,m->cupl.sample[ch][igr],
+ &m->cupl.nsamp[igr][ch], /* nsamp updated for shorts */
+ &m->cupl.sf[igr][ch], &m->cupl.side_info.gr[igr][ch],
+ &m->cupl.cb_info[igr][ch], m->cupl.ncbl_mixed);
+ }
+
+/*--- ms stereo processing ---*/
+ if (m->cupl.ms_mode)
+ {
+ if (m->cupl.is_mode == 0)
+ {
+ m0 = m->cupl.nsamp[igr][0]; /* process to longer of left/right */
+ if (m0 < m->cupl.nsamp[igr][1])
+ m0 = m->cupl.nsamp[igr][1];
+ }
+ else
+ { /* process to last cb in right */
+ m0 = m->cupl.sfBandIndex[m->cupl.cb_info[igr][1].cbtype][m->cupl.cb_info[igr][1].cbmax];
+ }
+ ms_process(m->cupl.sample[0][igr], m0);
+ }
+
+/*--- is stereo processing ---*/
+ if (m->cupl.is_mode)
+ {
+ if (m->cupl.id)
+ is_process_MPEG1(m, m->cupl.sample[0][igr], &m->cupl.sf[igr][1],
+ m->cupl.cb_info[igr], m->cupl.nsamp[igr][0], m->cupl.ms_mode);
+ else
+ is_process_MPEG2(m,m->cupl.sample[0][igr], &m->cupl.sf[igr][1],
+ m->cupl.cb_info[igr], &m->cupl.is_sf_info,
+ m->cupl.nsamp[igr][0], m->cupl.ms_mode);
+ }
+
+/*-- adjust ms and is modes to max of left/right */
+ if (m->cupl.side_info.mode_ext)
+ {
+ if (m->cupl.nsamp[igr][0] < m->cupl.nsamp[igr][1])
+ m->cupl.nsamp[igr][0] = m->cupl.nsamp[igr][1];
+ else
+ m->cupl.nsamp[igr][1] = m->cupl.nsamp[igr][0];
+ }
+
+/*--- antialias ---*/
+ for (ch = 0; ch < m->cupl.nchan; ch++)
+ {
+ if (m->cupl.cb_info[igr][ch].ncbl == 0)
+ continue; /* have no long blocks */
+ if (m->cupl.side_info.gr[igr][ch].mixed_block_flag)
+ n1 = 1; /* 1 -> 36 samples */
+ else
+ n1 = (m->cupl.nsamp[igr][ch] + 7) / 18;
+ if (n1 > 31)
+ n1 = 31;
+ antialias(m, m->cupl.sample[ch][igr], n1);
+ n1 = 18 * n1 + 8; /* update number of samples */
+ if (n1 > m->cupl.nsamp[igr][ch])
+ m->cupl.nsamp[igr][ch] = n1;
+ }
+
+
+
+/*--- hybrid + sbt ---*/
+ m->cupl.Xform(m, pcm, igr);
+
+
+/*-- done --*/
+}
+/*--------------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+IN_OUT L3audio_decode(void *mv, unsigned char *bs, unsigned char *pcm)
+{
+ MPEG *m = mv;
+ return m->cupl.decode_function((MPEG *)mv, bs, pcm);
+}
+
+/*--------------------------------------------------------------------*/
+IN_OUT L3audio_decode_MPEG1(void *mv, unsigned char *bs, unsigned char *pcm)
+{
+ MPEG *m = mv;
+ int sync;
+ IN_OUT in_out;
+ int side_bytes;
+ int nbytes;
+
+ m->cupl.iframe++;
+
+ bitget_init(bs); /* initialize bit getter */
+/* test sync */
+ in_out.in_bytes = 0; /* assume fail */
+ in_out.out_bytes = 0;
+ sync = bitget(12);
+
+ if (sync != 0xFFF)
+ return in_out; /* sync fail */
+/*-----------*/
+
+/*-- unpack side info --*/
+ side_bytes = unpack_side_MPEG1(m);
+ m->cupl.padframebytes = m->cupl.framebytes + m->cupl.pad;
+ in_out.in_bytes = m->cupl.padframebytes;
+
+/*-- load main data and update buf pointer --*/
+/*-------------------------------------------
+ if start point < 0, must just cycle decoder
+ if jumping into middle of stream,
+w---------------------------------------------*/
+ m->cupl.buf_ptr0 = m->cupl.buf_ptr1 - m->cupl.side_info.main_data_begin; /* decode start point */
+ if (m->cupl.buf_ptr1 > BUF_TRIGGER)
+ { /* shift buffer */
+ memmove(m->cupl.buf, m->cupl.buf + m->cupl.buf_ptr0, m->cupl.side_info.main_data_begin);
+ m->cupl.buf_ptr0 = 0;
+ m->cupl.buf_ptr1 = m->cupl.side_info.main_data_begin;
+ }
+ nbytes = m->cupl.padframebytes - side_bytes - m->cupl.crcbytes;
+
+ // RAK: This is no bueno. :-(
+ if (nbytes < 0 || nbytes > NBUF)
+ {
+ in_out.in_bytes = 0;
+ return in_out;
+ }
+
+ memmove(m->cupl.buf + m->cupl.buf_ptr1, bs + side_bytes + m->cupl.crcbytes, nbytes);
+ m->cupl.buf_ptr1 += nbytes;
+/*-----------------------*/
+
+ if (m->cupl.buf_ptr0 >= 0)
+ {
+// dump_frame(buf+buf_ptr0, 64);
+ m->cupl.main_pos_bit = m->cupl.buf_ptr0 << 3;
+ unpack_main(m,pcm, 0);
+ unpack_main(m,pcm + m->cupl.half_outbytes, 1);
+ in_out.out_bytes = m->cupl.outbytes;
+ }
+ else
+ {
+ memset(pcm, m->cupl.zero_level_pcm, m->cupl.outbytes); /* fill out skipped frames */
+ in_out.out_bytes = m->cupl.outbytes;
+/* iframe--; in_out.out_bytes = 0; // test test */
+ }
+
+ return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+IN_OUT L3audio_decode_MPEG2(void *mv, unsigned char *bs, unsigned char *pcm)
+{
+ MPEG *m = mv;
+ int sync;
+ IN_OUT in_out;
+ int side_bytes;
+ int nbytes;
+ static int igr = 0;
+
+ m->cupl.iframe++;
+
+
+ bitget_init(bs); /* initialize bit getter */
+/* test sync */
+ in_out.in_bytes = 0; /* assume fail */
+ in_out.out_bytes = 0;
+ sync = bitget(12);
+
+// if( sync != 0xFFF ) return in_out; /* sync fail */
+
+ m->cupl.mpeg25_flag = 0;
+ if (sync != 0xFFF)
+ {
+ m->cupl.mpeg25_flag = 1; /* mpeg 2.5 sync */
+ if (sync != 0xFFE)
+ return in_out; /* sync fail */
+ }
+/*-----------*/
+
+
+/*-- unpack side info --*/
+ side_bytes = unpack_side_MPEG2(m,igr);
+ m->cupl.padframebytes = m->cupl.framebytes + m->cupl.pad;
+ in_out.in_bytes = m->cupl.padframebytes;
+
+ m->cupl.buf_ptr0 = m->cupl.buf_ptr1 - m->cupl.side_info.main_data_begin; /* decode start point */
+ if (m->cupl.buf_ptr1 > BUF_TRIGGER)
+ { /* shift buffer */
+ memmove(m->cupl.buf, m->cupl.buf + m->cupl.buf_ptr0, m->cupl.side_info.main_data_begin);
+ m->cupl.buf_ptr0 = 0;
+ m->cupl.buf_ptr1 = m->cupl.side_info.main_data_begin;
+ }
+ nbytes = m->cupl.padframebytes - side_bytes - m->cupl.crcbytes;
+ // RAK: This is no bueno. :-(
+ if (nbytes < 0 || nbytes > NBUF)
+ {
+ in_out.in_bytes = 0;
+ return in_out;
+ }
+ memmove(m->cupl.buf + m->cupl.buf_ptr1, bs + side_bytes + m->cupl.crcbytes, nbytes);
+ m->cupl.buf_ptr1 += nbytes;
+/*-----------------------*/
+
+ if (m->cupl.buf_ptr0 >= 0)
+ {
+ m->cupl.main_pos_bit = m->cupl.buf_ptr0 << 3;
+ unpack_main(m,pcm, igr);
+ in_out.out_bytes = m->cupl.outbytes;
+ }
+ else
+ {
+ memset(pcm, m->cupl.zero_level_pcm, m->cupl.outbytes); /* fill out skipped frames */
+ in_out.out_bytes = m->cupl.outbytes;
+// iframe--; in_out.out_bytes = 0; return in_out;// test test */
+ }
+
+
+
+ igr = igr ^ 1;
+ return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+static int const sr_table[8] =
+{22050, 24000, 16000, 1,
+ 44100, 48000, 32000, 1};
+
+static const struct
+{
+ int l[23];
+ int s[14];
+}
+sfBandIndexTable[3][3] =
+{
+/* mpeg-2 */
+ {
+ {
+ {
+ 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192
+ }
+ }
+ ,
+ {
+ {
+ 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192
+ }
+ }
+ ,
+ {
+ {
+ 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+ }
+ }
+ ,
+ }
+ ,
+/* mpeg-1 */
+ {
+ {
+ {
+ 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192
+ }
+ }
+ ,
+ {
+ {
+ 0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192
+ }
+ }
+ ,
+ {
+ {
+ 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192
+ }
+ }
+ }
+ ,
+
+/* mpeg-2.5, 11 & 12 KHz seem ok, 8 ok */
+ {
+ {
+ {
+ 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+ }
+ }
+ ,
+ {
+ {
+ 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+ }
+ ,
+ {
+ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+ }
+ }
+ ,
+// this 8khz table, and only 8khz, from mpeg123)
+ {
+ {
+ 0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576
+ }
+ ,
+ {
+ 0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192
+ }
+ }
+ ,
+ }
+ ,
+};
+
+
+void sbt_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+void sbt_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+void sbt16_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+void sbt16_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+void sbt8_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+void sbt8_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
+
+void sbtB_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+void sbtB_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+void sbtB16_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+void sbtB16_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+void sbtB8_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+void sbtB8_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
+
+
+
+static SBT_FUNCTION_F sbt_table[2][3][2] =
+{
+{{ (SBT_FUNCTION_F) sbt_mono_L3,
+ (SBT_FUNCTION_F) sbt_dual_L3 } ,
+ { (SBT_FUNCTION_F) sbt16_mono_L3,
+ (SBT_FUNCTION_F) sbt16_dual_L3 } ,
+ { (SBT_FUNCTION_F) sbt8_mono_L3,
+ (SBT_FUNCTION_F) sbt8_dual_L3 }} ,
+/*-- 8 bit output -*/
+{{ (SBT_FUNCTION_F) sbtB_mono_L3,
+ (SBT_FUNCTION_F) sbtB_dual_L3 },
+ { (SBT_FUNCTION_F) sbtB16_mono_L3,
+ (SBT_FUNCTION_F) sbtB16_dual_L3 },
+ { (SBT_FUNCTION_F) sbtB8_mono_L3,
+ (SBT_FUNCTION_F) sbtB8_dual_L3 }}
+};
+
+
+void Xform_mono(void *mv, void *pcm, int igr);
+void Xform_dual(void *mv, void *pcm, int igr);
+void Xform_dual_mono(void *mv, void *pcm, int igr);
+void Xform_dual_right(void *mv, void *pcm, int igr);
+
+static XFORM_FUNCTION xform_table[5] =
+{
+ Xform_mono,
+ Xform_dual,
+ Xform_dual_mono,
+ Xform_mono, /* left */
+ Xform_dual_right,
+};
+int L3table_init(MPEG *m);
+void msis_init(MPEG *m);
+void sbt_init(MPEG *m);
+#if 0
+typedef int iARRAY22[22];
+#endif
+iARRAY22 *quant_init_band_addr();
+iARRAY22 *msis_init_band_addr();
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h frame bytes is without pad */
+int L3audio_decode_init(void *mv, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+{
+ MPEG *m = mv;
+ int i, j, k;
+ // static int first_pass = 1;
+ int samprate;
+ int limit;
+ int bit_code;
+ int out_chans;
+
+ m->cupl.buf_ptr0 = 0;
+ m->cupl.buf_ptr1 = 0;
+
+/* check if code handles */
+ if (h->option != 1)
+ return 0; /* layer III only */
+
+ if (h->id)
+ m->cupl.ncbl_mixed = 8; /* mpeg-1 */
+ else
+ m->cupl.ncbl_mixed = 6; /* mpeg-2 */
+
+ m->cupl.framebytes = framebytes_arg;
+
+ transform_code = transform_code; /* not used, asm compatability */
+ bit_code = 0;
+ if (convert_code & 8)
+ bit_code = 1;
+ convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
+ if (reduction_code < 0)
+ reduction_code = 0;
+ if (reduction_code > 2)
+ reduction_code = 2;
+ if (freq_limit < 1000)
+ freq_limit = 1000;
+
+
+ samprate = sr_table[4 * h->id + h->sr_index];
+ if ((h->sync & 1) == 0)
+ samprate = samprate / 2; // mpeg 2.5
+/*----- compute nsb_limit --------*/
+ m->cupl.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+ limit = (32 >> reduction_code);
+ if (limit > 8)
+ limit--;
+ if (m->cupl.nsb_limit > limit)
+ m->cupl.nsb_limit = limit;
+ limit = 18 * m->cupl.nsb_limit;
+
+ k = h->id;
+ if ((h->sync & 1) == 0)
+ k = 2; // mpeg 2.5
+
+ if (k == 1)
+ {
+ m->cupl.band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[13];
+ m->cupl.band_limit = m->cupl.band_limit21 = sfBandIndexTable[k][h->sr_index].l[22];
+ }
+ else
+ {
+ m->cupl.band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[12];
+ m->cupl.band_limit = m->cupl.band_limit21 = sfBandIndexTable[k][h->sr_index].l[21];
+ }
+ m->cupl.band_limit += 8; /* allow for antialias */
+ if (m->cupl.band_limit > limit)
+ m->cupl.band_limit = limit;
+
+ if (m->cupl.band_limit21 > m->cupl.band_limit)
+ m->cupl.band_limit21 = m->cupl.band_limit;
+ if (m->cupl.band_limit12 > m->cupl.band_limit)
+ m->cupl.band_limit12 = m->cupl.band_limit;
+
+
+ m->cupl.band_limit_nsb = (m->cupl.band_limit + 17) / 18; /* limit nsb's rounded up */
+/*----------------------------------------------*/
+ m->cupl.gain_adjust = 0; /* adjust gain e.g. cvt to mono sum channel */
+ if ((h->mode != 3) && (convert_code == 1))
+ m->cupl.gain_adjust = -4;
+
+ m->cupl.outvalues = 1152 >> reduction_code;
+ if (h->id == 0)
+ m->cupl.outvalues /= 2;
+
+ out_chans = 2;
+ if (h->mode == 3)
+ out_chans = 1;
+ if (convert_code)
+ out_chans = 1;
+
+ m->cupl.sbt_L3 = sbt_table[bit_code][reduction_code][out_chans - 1];
+ k = 1 + convert_code;
+ if (h->mode == 3)
+ k = 0;
+ m->cupl.Xform = xform_table[k];
+
+
+ m->cupl.outvalues *= out_chans;
+
+ if (bit_code)
+ m->cupl.outbytes = m->cupl.outvalues;
+ else
+ m->cupl.outbytes = sizeof(short) * m->cupl.outvalues;
+
+ if (bit_code)
+ m->cupl.zero_level_pcm = 128; /* 8 bit output */
+ else
+ m->cupl.zero_level_pcm = 0;
+
+
+ m->cup.decinfo.channels = out_chans;
+ m->cup.decinfo.outvalues = m->cupl.outvalues;
+ m->cup.decinfo.samprate = samprate >> reduction_code;
+ if (bit_code)
+ m->cup.decinfo.bits = 8;
+ else
+ m->cup.decinfo.bits = sizeof(short) * 8;
+
+ m->cup.decinfo.framebytes = m->cupl.framebytes;
+ m->cup.decinfo.type = 0;
+
+ m->cupl.half_outbytes = m->cupl.outbytes / 2;
+/*------------------------------------------*/
+
+/*- init band tables --*/
+
+
+ k = h->id;
+ if ((h->sync & 1) == 0)
+ k = 2; // mpeg 2.5
+
+ for (i = 0; i < 22; i++)
+ m->cupl.sfBandIndex[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1];
+ for (i = 0; i < 13; i++)
+ m->cupl.sfBandIndex[1][i] = 3 * sfBandIndexTable[k][h->sr_index].s[i + 1];
+ for (i = 0; i < 22; i++)
+ m->cupl.nBand[0][i] =
+ sfBandIndexTable[k][h->sr_index].l[i + 1]
+ - sfBandIndexTable[k][h->sr_index].l[i];
+ for (i = 0; i < 13; i++)
+ m->cupl.nBand[1][i] =
+ sfBandIndexTable[k][h->sr_index].s[i + 1]
+ - sfBandIndexTable[k][h->sr_index].s[i];
+
+
+/* init tables */
+ L3table_init(m);
+/* init ms and is stereo modes */
+ msis_init(m);
+
+/*----- init sbt ---*/
+ sbt_init(m);
+
+
+
+/*--- clear buffers --*/
+ for (i = 0; i < 576; i++)
+ m->cupl.yout[i] = 0.0f;
+ for (j = 0; j < 2; j++)
+ {
+ for (k = 0; k < 2; k++)
+ {
+ for (i = 0; i < 576; i++)
+ {
+ m->cupl.sample[j][k][i].x = 0.0f;
+ m->cupl.sample[j][k][i].s = 0;
+ }
+ }
+ }
+
+ if (h->id == 1)
+ m->cupl.decode_function = L3audio_decode_MPEG1;
+ else
+ m->cupl.decode_function = L3audio_decode_MPEG2;
+
+ return 1;
+}
+/*---------------------------------------------------------*/
+/*==========================================================*/
+void cup3_init(MPEG *m)
+{
+ m->cupl.sbt_L3 = sbt_dual_L3;
+ m->cupl.Xform = Xform_dual;
+ m->cupl.sbt_L3 = sbt_dual_L3;
+ m->cupl.decode_function = L3audio_decode_MPEG1;
+}
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** cwin.c ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines
+portable C
+
+******************************************************************/
+
+#ifdef ASM_X86
+extern void window_mpg_asm(float *a, int b, short *c);
+extern void window_dual_asm(float *a, int b, short *c);
+extern void window16_asm(float *a, int b, short *c);
+extern void window16_dual_asm(float *a, int b, short *c);
+extern void window8_asm(float *a, int b, short *c);
+extern void window8_dual_asm(float *a, int b, short *c);
+#endif /* ASM_X86 */
+
+/*-------------------------------------------------------------------------*/
+void window(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window_mpg_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 16;
+ bx = (si + 32) & 511;
+ coef = wincoef;
+
+/*-- first 16 --*/
+ for (i = 0; i < 16; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 64) & 511;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ si++;
+ bx--;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+/*-- last 15 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 15; i++)
+ {
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 64) & 511;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+#endif
+}
+
+
+
+/*------------------------------------------------------------*/
+#ifndef ASM_X86_OLD
+void window_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j; /* dual window interleaves output */
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 16;
+ bx = (si + 32) & 511;
+ coef = wincoef;
+
+/*-- first 16 --*/
+ for (i = 0; i < 16; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 64) & 511;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ si++;
+ bx--;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+/*-- last 15 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 15; i++)
+ {
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 64) & 511;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+#endif
+}
+#endif /* ndef ASM_X86_OLD */
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void window16(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window16_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ unsigned char si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 8;
+ bx = si + 16;
+ coef = wincoef;
+
+/*-- first 8 --*/
+ for (i = 0; i < 8; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si += 32;
+ sum -= (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ si++;
+ bx--;
+ coef += 16;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+/*-- last 7 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 7; i++)
+ {
+ coef -= 16;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si += 32;
+ sum += (*coef--) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+#endif
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void window16_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window16_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ unsigned char si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 8;
+ bx = si + 16;
+ coef = wincoef;
+
+/*-- first 8 --*/
+ for (i = 0; i < 8; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si += 32;
+ sum -= (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ si++;
+ bx--;
+ coef += 16;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+/*-- last 7 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 7; i++)
+ {
+ coef -= 16;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si += 32;
+ sum += (*coef--) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+#endif
+}
+/*------------------- 8 pt window ------------------------------*/
+void window8(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window8_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 4;
+ bx = (si + 8) & 127;
+ coef = wincoef;
+
+/*-- first 4 --*/
+ for (i = 0; i < 4; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 16) & 127;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ si++;
+ bx--;
+ coef += 48;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+/*-- last 3 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 3; i++)
+ {
+ coef -= 48;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 16) & 127;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = tmp;
+ }
+#endif
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void window8_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+#ifdef ASM_X86
+ window8_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 4;
+ bx = (si + 8) & 127;
+ coef = wincoef;
+
+/*-- first 4 --*/
+ for (i = 0; i < 4; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 16) & 127;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ si++;
+ bx--;
+ coef += 48;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+/*-- last 3 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 3; i++)
+ {
+ coef -= 48;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 16) & 127;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = tmp;
+ pcm += 2;
+ }
+#endif
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** cwin.c ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines - 8 bit output
+portable C
+
+******************************************************************/
+/*-------------------------------------------------------------------------*/
+
+
+#ifdef ASM_X86
+extern void windowB_asm(float *a, int b, unsigned char *c);
+extern void windowB_dual_asm(float *a, int b, unsigned char *c);
+extern void windowB16_asm(float *a, int b, unsigned char *c);
+extern void windowB16_dual_asm(float *a, int b, unsigned char *c);
+extern void windowB8_asm(float *a, int b, unsigned char *c);
+extern void windowB8_dual_asm(float *a, int b, unsigned char *c);
+#endif /* ASM_X86 */
+
+void windowB(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 16;
+ bx = (si + 32) & 511;
+ coef = wincoef;
+
+/*-- first 16 --*/
+ for (i = 0; i < 16; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 64) & 511;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ si++;
+ bx--;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 15 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 15; i++)
+ {
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 64) & 511;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+#endif
+}
+/*------------------------------------------------------------*/
+void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j; /* dual window interleaves output */
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 16;
+ bx = (si + 32) & 511;
+ coef = wincoef;
+
+/*-- first 16 --*/
+ for (i = 0; i < 16; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 64) & 511;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ si++;
+ bx--;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+/*-- last 15 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 15; i++)
+ {
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 64) & 511;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 64) & 511;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+#endif
+}
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB16_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ unsigned char si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 8;
+ bx = si + 16;
+ coef = wincoef;
+
+/*-- first 8 --*/
+ for (i = 0; i < 8; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si += 32;
+ sum -= (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ si++;
+ bx--;
+ coef += 16;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 7 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 7; i++)
+ {
+ coef -= 16;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si += 32;
+ sum += (*coef--) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+#endif
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB16_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ unsigned char si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 8;
+ bx = si + 16;
+ coef = wincoef;
+
+/*-- first 8 --*/
+ for (i = 0; i < 8; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si += 32;
+ sum -= (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ si++;
+ bx--;
+ coef += 16;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+/*-- last 7 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 7; i++)
+ {
+ coef -= 16;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si += 32;
+ sum += (*coef--) * vbuf[bx];
+ bx += 32;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+#endif
+}
+/*------------------- 8 pt window ------------------------------*/
+void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB8_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 4;
+ bx = (si + 8) & 127;
+ coef = wincoef;
+
+/*-- first 4 --*/
+ for (i = 0; i < 4; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 16) & 127;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ si++;
+ bx--;
+ coef += 48;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 3 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 3; i++)
+ {
+ coef -= 48;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 16) & 127;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ }
+#endif
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+#ifdef ASM_X86
+ windowB8_dual_asm(vbuf, vb_ptr, pcm);
+#else
+ int i, j;
+ int si, bx;
+ float *coef;
+ float sum;
+ long tmp;
+
+ si = vb_ptr + 4;
+ bx = (si + 8) & 127;
+ coef = wincoef;
+
+/*-- first 4 --*/
+ for (i = 0; i < 4; i++)
+ {
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[si];
+ si = (si + 16) & 127;
+ sum -= (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ si++;
+ bx--;
+ coef += 48;
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+/*-- special case --*/
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef++) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+/*-- last 3 --*/
+ coef = wincoef + 255; /* back pass through coefs */
+ for (i = 0; i < 3; i++)
+ {
+ coef -= 48;
+ si--;
+ bx++;
+ sum = 0.0F;
+ for (j = 0; j < 8; j++)
+ {
+ sum += (*coef--) * vbuf[si];
+ si = (si + 16) & 127;
+ sum += (*coef--) * vbuf[bx];
+ bx = (bx + 16) & 127;
+ }
+ tmp = (long) sum;
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+ pcm += 2;
+ }
+#endif
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** cwinm.c ***************************************************
+
+MPEG audio decoder, window master routine
+portable C
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+
+/* disable precision loss warning on type conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+float wincoef[264] =
+{ /* window coefs */
+#include "tableawd.h"
+};
+
+/*--------------------------------------------------------*/
+#ifdef QUICK_FLOAT
+#include "cwinq.c"
+#include "cwinbq.c"
+#else
+#include "cwin.c"
+#include "cwinb.c"
+#endif
+/*--------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** dec8.c ***************************************************
+
+
+ANSI C
+MPEG audio decoder Layer II only mpeg1 and mpeg2
+output sample type and sample rate conversion
+ decode mpeg to 8000Ks mono
+ output 16 bit linear, 8 bit linear, or u-law
+
+
+mod 6/29/95 bugfix in u-law table
+
+mod 11/15/95 for Layer I
+
+mod 1/7/97 minor mods for warnings
+
+******************************************************************/
+/*****************************************************************
+
+ MPEG audio software decoder portable ANSI c.
+ Decodes all Layer II to 8000Ks mono pcm.
+ Output selectable: 16 bit linear, 8 bit linear, u-law.
+
+-------------------------------------
+int audio_decode8_init(MPEG_HEAD *h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+
+initilize decoder:
+ return 0 = fail, not 0 = success
+
+MPEG_HEAD *h input, mpeg header info (returned by call to head_info)
+framebytes input, mpeg frame size (returned by call to head_info)
+reduction_code input, ignored
+transform_code input, ignored
+convert_code input, set convert_code = 4*bit_code + chan_code
+ bit_code: 1 = 16 bit linear pcm
+ 2 = 8 bit (unsigned) linear pcm
+ 3 = u-law (8 bits unsigned)
+ chan_code: 0 = convert two chan to mono
+ 1 = convert two chan to mono
+ 2 = convert two chan to left chan
+ 3 = convert two chan to right chan
+freq_limit input, ignored
+
+
+---------------------------------
+void audio_decode8_info( DEC_INFO *info)
+
+information return:
+ Call after audio_decode8_init. See mhead.h for
+ information returned in DEC_INFO structure.
+
+
+---------------------------------
+IN_OUT audio_decode8(unsigned char *bs, void *pcmbuf)
+
+decode one mpeg audio frame:
+bs input, mpeg bitstream, must start with
+ sync word. Caution: may read up to 3 bytes
+ beyond end of frame.
+pcmbuf output, pcm samples.
+
+IN_OUT structure returns:
+ Number bytes conceptually removed from mpeg bitstream.
+ Returns 0 if sync loss.
+ Number bytes of pcm output. This may vary from frame
+ to frame.
+
+*****************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h" /* mpeg header structure */
+
+
+
+
+
+/*------------------------------------------*/
+static int output_code;
+static int convert(void *mv, unsigned char *pcm);
+static int convert_8bit(void *mv, unsigned char *pcm);
+static int convert_u(void *mv, unsigned char *pcm);
+static CVT_FUNCTION_8 cvt_table[3] =
+{
+ convert,
+ convert_8bit,
+ convert_u,
+};
+
+void mpeg8_init(MPEG8 *m)
+{
+ memset(&m->dec, 0, sizeof(m->dec));
+ m->dec.ncnt = 8 * 288;
+ m->dec.ncnt1 = 8 * 287;
+ m->dec.nlast = 287;
+ m->dec.ndeci = 11;
+ m->dec.kdeci = 8 * 288;
+ m->dec.first_pass = 1;
+}
+
+/*====================================================================*/
+IN_OUT audio_decode8(MPEG8 *m, unsigned char *bs, signed short *pcmbuf)
+{
+ IN_OUT x;
+
+ x = audio_decode(&m->cupper, bs, m->dec.pcm);
+ if (x.in_bytes <= 0)
+ return x;
+ x.out_bytes = m->dec.convert_routine(m, (void *) pcmbuf);
+
+ return x;
+}
+/*--------------8Ks 16 bit pcm --------------------------------*/
+static int convert(void *mv, unsigned char y0[])
+{
+ MPEG8 *m = mv;
+ int i, k;
+ long alpha;
+ short *y;
+
+ y = (short *) y0;
+ k = 0;
+ if (m->dec.kdeci < m->dec.ncnt)
+ {
+ alpha = m->dec.kdeci & 7;
+ y[k++] = (short) (m->dec.xsave + ((alpha * (m->dec.pcm[0] - m->dec.xsave)) >> 3));
+ m->dec.kdeci += m->dec.ndeci;
+ }
+ m->dec.kdeci -= m->dec.ncnt;
+ for (; m->dec.kdeci < m->dec.ncnt1; m->dec.kdeci += m->dec.ndeci)
+ {
+ i = m->dec.kdeci >> 3;
+ alpha = m->dec.kdeci & 7;
+ y[k++] = (short) (m->dec.pcm[i] + ((alpha * (m->dec.pcm[i + 1] - m->dec.pcm[i])) >> 3));
+ }
+ m->dec.xsave = m->dec.pcm[m->dec.nlast];
+
+/* printf("\n k out = %4d", k); */
+
+ return sizeof(short) * k;
+}
+/*----------------8Ks 8 bit unsigned pcm ---------------------------*/
+static int convert_8bit(void *mv, unsigned char y[])
+{
+ MPEG8 *m = mv;
+ int i, k;
+ long alpha;
+
+ k = 0;
+ if (m->dec.kdeci < m->dec.ncnt)
+ {
+ alpha = m->dec.kdeci & 7;
+ y[k++] = (unsigned char) (((m->dec.xsave + ((alpha * (m->dec.pcm[0] - m->dec.xsave)) >> 3)) >> 8) + 128);
+ m->dec.kdeci += m->dec.ndeci;
+ }
+ m->dec.kdeci -= m->dec.ncnt;
+ for (; m->dec.kdeci < m->dec.ncnt1; m->dec.kdeci += m->dec.ndeci)
+ {
+ i = m->dec.kdeci >> 3;
+ alpha = m->dec.kdeci & 7;
+ y[k++] = (unsigned char) (((m->dec.pcm[i] + ((alpha * (m->dec.pcm[i + 1] - m->dec.pcm[i])) >> 3)) >> 8) + 128);
+ }
+ m->dec.xsave = m->dec.pcm[m->dec.nlast];
+
+/* printf("\n k out = %4d", k); */
+
+ return k;
+}
+/*--------------8Ks u-law --------------------------------*/
+static int convert_u(void *mv, unsigned char y[])
+{
+ MPEG8 *m = mv;
+ int i, k;
+ long alpha;
+ unsigned char *look;
+
+ look = m->dec.look_u + 4096;
+
+ k = 0;
+ if (m->dec.kdeci < m->dec.ncnt)
+ {
+ alpha = m->dec.kdeci & 7;
+ y[k++] = look[(m->dec.xsave + ((alpha * (m->dec.pcm[0] - m->dec.xsave)) >> 3)) >> 3];
+ m->dec.kdeci += m->dec.ndeci;
+ }
+ m->dec.kdeci -= m->dec.ncnt;
+ for (; m->dec.kdeci < m->dec.ncnt1; m->dec.kdeci += m->dec.ndeci)
+ {
+ i = m->dec.kdeci >> 3;
+ alpha = m->dec.kdeci & 7;
+ y[k++] = look[(m->dec.pcm[i] + ((alpha * (m->dec.pcm[i + 1] - m->dec.pcm[i])) >> 3)) >> 3];
+ }
+ m->dec.xsave = m->dec.pcm[m->dec.nlast];
+
+/* printf("\n k out = %4d", k); */
+
+ return k;
+}
+/*--------------------------------------------------------------------*/
+static int ucomp3(int x) /* re analog devices CCITT G.711 */
+{
+ int s, p, y, t, u, u0, sign;
+
+ sign = 0;
+ if (x < 0)
+ {
+ x = -x;
+ sign = 0x0080;
+ }
+ if (x > 8031)
+ x = 8031;
+ x += 33;
+ t = x;
+ for (s = 0; s < 15; s++)
+ {
+ if (t & 0x4000)
+ break;
+ t <<= 1;
+ }
+ y = x << s;
+ p = (y >> 10) & 0x0f; /* position */
+ s = 9 - s; /* segment */
+ u0 = (((s << 4) | p) & 0x7f) | sign;
+ u = u0 ^ 0xff;
+
+ return u;
+}
+/*------------------------------------------------------------------*/
+static void table_init(MPEG8 *m)
+{
+ int i;
+
+ for (i = -4096; i < 4096; i++)
+ m->dec.look_u[4096 + i] = (unsigned char) (ucomp3(2 * i));
+
+}
+/*-------------------------------------------------------------------*/
+int audio_decode8_init(MPEG8 *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+{
+ int istat;
+ int outvals;
+ static int sr_table[2][4] =
+ {{22, 24, 16, 0}, {44, 48, 32, 0}};
+
+ if (m->dec.first_pass)
+ {
+ table_init(m);
+ m->dec.first_pass = 0;
+ }
+
+ if ((h->sync & 1) == 0)
+ return 0; // fail mpeg 2.5
+
+ output_code = convert_code >> 2;
+ if (output_code < 1)
+ output_code = 1; /* 1= 16bit 2 = 8bit 3 = u */
+ if (output_code > 3)
+ output_code = 3; /* 1= 16bit 2 = 8bit 3 = u */
+
+ convert_code = convert_code & 3;
+ if (convert_code <= 0)
+ convert_code = 1; /* always cvt to mono */
+
+ reduction_code = 1;
+ if (h->id)
+ reduction_code = 2;
+
+/* select convert routine */
+ m->dec.convert_routine = cvt_table[output_code - 1];
+
+/* init decimation/convert routine */
+/*-- MPEG-2 layer III --*/
+ if ((h->option == 1) && h->id == 0)
+ outvals = 576 >> reduction_code;
+ else if (h->option == 3)
+ outvals = 384 >> reduction_code;
+/*-- layer I --*/
+ else
+ outvals = 1152 >> reduction_code;
+ m->dec.ncnt = 8 * outvals;
+ m->dec.ncnt1 = 8 * (outvals - 1);
+ m->dec.nlast = outvals - 1;
+ m->dec.ndeci = sr_table[h->id][h->sr_index] >> reduction_code;
+ m->dec.kdeci = 8 * outvals;
+/* printf("\n outvals %d", outvals); */
+
+ freq_limit = 3200;
+ istat = audio_decode_init(&m->cupper, h, framebytes_arg,
+ reduction_code, transform_code, convert_code,
+ freq_limit);
+
+
+ return istat;
+}
+/*-----------------------------------------------------------------*/
+void audio_decode8_info(MPEG8 *m, DEC_INFO * info)
+{
+
+ audio_decode_info(&m->cupper, info);
+ info->samprate = 8000;
+ if (output_code != 1)
+ info->bits = 8;
+ if (output_code == 3)
+ info->type = 10;
+}
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** hwin.c ***************************************************
+
+Layer III
+
+hybrid window/filter
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h"
+
+#ifdef ASM_X86
+extern int hybrid_asm(float xin[], float xprev[], float y[18][32],
+ int btype, int nlong, int ntot, int nprev);
+extern void FreqInvert_asm(float y[18][32], int n);
+#endif /* ASM_X86 */
+
+
+typedef float ARRAY36[36];
+
+/*====================================================================*/
+void imdct18(float f[]); /* 18 point */
+void imdct6_3(float f[]); /* 6 point */
+
+/*====================================================================*/
+ARRAY36 *hwin_init_addr(MPEG *m)
+{
+ return m->cupl.win;
+}
+
+#ifdef ASM_X86
+#ifdef _MSC_VER
+#pragma warning(disable: 4035)
+#endif /* _MSC_VER */
+#endif /* ASM_X86 */
+
+/*====================================================================*/
+int hybrid(MPEG *m, float xin[], float xprev[], float y[18][32],
+ int btype, int nlong, int ntot, int nprev)
+{
+#ifdef ASM_X86
+ hybrid_asm(xin, xprev, y, btype, nlong, ntot, nprev);
+#else
+ int i, j;
+ float *x, *x0;
+ float xa, xb;
+ int n;
+ int nout;
+
+
+
+ if (btype == 2)
+ btype = 0;
+ x = xin;
+ x0 = xprev;
+
+/*-- do long blocks (if any) --*/
+ n = (nlong + 17) / 18; /* number of dct's to do */
+ for (i = 0; i < n; i++)
+ {
+ imdct18(x);
+ for (j = 0; j < 9; j++)
+ {
+ y[j][i] = x0[j] + m->cupl.win[btype][j] * x[9 + j];
+ y[9 + j][i] = x0[9 + j] + m->cupl.win[btype][9 + j] * x[17 - j];
+ }
+ /* window x for next time x0 */
+ for (j = 0; j < 4; j++)
+ {
+ xa = x[j];
+ xb = x[8 - j];
+ x[j] = m->cupl.win[btype][18 + j] * xb;
+ x[8 - j] = m->cupl.win[btype][(18 + 8) - j] * xa;
+ x[9 + j] = m->cupl.win[btype][(18 + 9) + j] * xa;
+ x[17 - j] = m->cupl.win[btype][(18 + 17) - j] * xb;
+ }
+ xa = x[j];
+ x[j] = m->cupl.win[btype][18 + j] * xa;
+ x[9 + j] = m->cupl.win[btype][(18 + 9) + j] * xa;
+
+ x += 18;
+ x0 += 18;
+ }
+
+/*-- do short blocks (if any) --*/
+ n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
+ for (; i < n; i++)
+ {
+ imdct6_3(x);
+ for (j = 0; j < 3; j++)
+ {
+ y[j][i] = x0[j];
+ y[3 + j][i] = x0[3 + j];
+
+ y[6 + j][i] = x0[6 + j] + m->cupl.win[2][j] * x[3 + j];
+ y[9 + j][i] = x0[9 + j] + m->cupl.win[2][3 + j] * x[5 - j];
+
+ y[12 + j][i] = x0[12 + j] + m->cupl.win[2][6 + j] * x[2 - j] + m->cupl.win[2][j] * x[(6 + 3) + j];
+ y[15 + j][i] = x0[15 + j] + m->cupl.win[2][9 + j] * x[j] + m->cupl.win[2][3 + j] * x[(6 + 5) - j];
+ }
+ /* window x for next time x0 */
+ for (j = 0; j < 3; j++)
+ {
+ x[j] = m->cupl.win[2][6 + j] * x[(6 + 2) - j] + m->cupl.win[2][j] * x[(12 + 3) + j];
+ x[3 + j] = m->cupl.win[2][9 + j] * x[6 + j] + m->cupl.win[2][3 + j] * x[(12 + 5) - j];
+ }
+ for (j = 0; j < 3; j++)
+ {
+ x[6 + j] = m->cupl.win[2][6 + j] * x[(12 + 2) - j];
+ x[9 + j] = m->cupl.win[2][9 + j] * x[12 + j];
+ }
+ for (j = 0; j < 3; j++)
+ {
+ x[12 + j] = 0.0f;
+ x[15 + j] = 0.0f;
+ }
+ x += 18;
+ x0 += 18;
+ }
+
+/*--- overlap prev if prev longer that current --*/
+ n = (nprev + 17) / 18;
+ for (; i < n; i++)
+ {
+ for (j = 0; j < 18; j++)
+ y[j][i] = x0[j];
+ x0 += 18;
+ }
+ nout = 18 * i;
+
+/*--- clear remaining only to band limit --*/
+ for (; i < m->cupl.band_limit_nsb; i++)
+ {
+ for (j = 0; j < 18; j++)
+ y[j][i] = 0.0f;
+ }
+
+ return nout;
+#endif
+}
+
+#ifdef ASM_X86
+#ifdef _MSC_VER
+#pragma warning(default: 4035)
+#endif /* _MSC_VER */
+#endif /* ASM_X86 */
+
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*-- convert to mono, add curr result to y,
+ window and add next time to current left */
+int hybrid_sum(MPEG *m, float xin[], float xin_left[], float y[18][32],
+ int btype, int nlong, int ntot)
+{
+ int i, j;
+ float *x, *x0;
+ float xa, xb;
+ int n;
+ int nout;
+
+
+
+ if (btype == 2)
+ btype = 0;
+ x = xin;
+ x0 = xin_left;
+
+/*-- do long blocks (if any) --*/
+ n = (nlong + 17) / 18; /* number of dct's to do */
+ for (i = 0; i < n; i++)
+ {
+ imdct18(x);
+ for (j = 0; j < 9; j++)
+ {
+ y[j][i] += m->cupl.win[btype][j] * x[9 + j];
+ y[9 + j][i] += m->cupl.win[btype][9 + j] * x[17 - j];
+ }
+ /* window x for next time x0 */
+ for (j = 0; j < 4; j++)
+ {
+ xa = x[j];
+ xb = x[8 - j];
+ x0[j] += m->cupl.win[btype][18 + j] * xb;
+ x0[8 - j] += m->cupl.win[btype][(18 + 8) - j] * xa;
+ x0[9 + j] += m->cupl.win[btype][(18 + 9) + j] * xa;
+ x0[17 - j] += m->cupl.win[btype][(18 + 17) - j] * xb;
+ }
+ xa = x[j];
+ x0[j] += m->cupl.win[btype][18 + j] * xa;
+ x0[9 + j] += m->cupl.win[btype][(18 + 9) + j] * xa;
+
+ x += 18;
+ x0 += 18;
+ }
+
+/*-- do short blocks (if any) --*/
+ n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
+ for (; i < n; i++)
+ {
+ imdct6_3(x);
+ for (j = 0; j < 3; j++)
+ {
+ y[6 + j][i] += m->cupl.win[2][j] * x[3 + j];
+ y[9 + j][i] += m->cupl.win[2][3 + j] * x[5 - j];
+
+ y[12 + j][i] += m->cupl.win[2][6 + j] * x[2 - j] + m->cupl.win[2][j] * x[(6 + 3) + j];
+ y[15 + j][i] += m->cupl.win[2][9 + j] * x[j] + m->cupl.win[2][3 + j] * x[(6 + 5) - j];
+ }
+ /* window x for next time */
+ for (j = 0; j < 3; j++)
+ {
+ x0[j] += m->cupl.win[2][6 + j] * x[(6 + 2) - j] + m->cupl.win[2][j] * x[(12 + 3) + j];
+ x0[3 + j] += m->cupl.win[2][9 + j] * x[6 + j] + m->cupl.win[2][3 + j] * x[(12 + 5) - j];
+ }
+ for (j = 0; j < 3; j++)
+ {
+ x0[6 + j] += m->cupl.win[2][6 + j] * x[(12 + 2) - j];
+ x0[9 + j] += m->cupl.win[2][9 + j] * x[12 + j];
+ }
+ x += 18;
+ x0 += 18;
+ }
+
+ nout = 18 * i;
+
+ return nout;
+}
+/*--------------------------------------------------------------------*/
+void sum_f_bands(float a[], float b[], int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ a[i] += b[i];
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+void FreqInvert(float y[18][32], int n)
+{
+#ifdef ASM_X86
+ FreqInvert_asm(y, n);
+#else
+ int i, j;
+
+ n = (n + 17) / 18;
+ for (j = 0; j < 18; j += 2)
+ {
+ for (i = 0; i < n; i += 2)
+ {
+ y[1 + j][1 + i] = -y[1 + j][1 + i];
+ }
+ }
+#endif
+}
+/*--------------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** icdct.c ***************************************************
+
+
+MPEG audio decoder, dct
+portable C integer dct
+
+mod 1/8/97 warnings
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "itype.h"
+
+/*-------------------------------------------------------------------*/
+static DCTCOEF coef32[32]; /* 32 pt dct coefs */
+
+
+
+
+#define forward_bf idx_forward_bf
+/*--- #define forward_bf ptr_forward_bf ---*/
+/*------------------------------------------------------------*/
+DCTCOEF *i_dct_coef_addr()
+{
+ return coef32;
+}
+/*------------------------------------------------------------*/
+static void idx_forward_bf(int m, int n, INT32 x[], INT32 f[], DCTCOEF coef[])
+{
+ int i, j, n2;
+ int p, q, p0, k;
+
+ p0 = 0;
+ n2 = n >> 1;
+ for (i = 0; i < m; i++, p0 += n)
+ {
+ k = 0;
+ p = p0;
+ q = p + n - 1;
+ for (j = 0; j < n2; j++, p++, q--, k++)
+ {
+ f[p] = x[p] + x[q];
+ f[n2 + p] = ((x[p] - x[q]) * coef[k]) >> DCTBITS;
+ }
+ }
+}
+/*------------------------------------------------------------*/
+/*--
+static void ptr_forward_bf(int m, int n, INT32 x[], INT32 f[], DCTCOEF coef[])
+{
+int i, j, n2;
+DCTCOEF *c;
+INT32 *y;
+
+n2 = n >> 1;
+for(i=0; i<m; i++) {
+ c = coef;
+ y = x+n;
+ for(j=0; j<n2; j++) {
+ *f = *x + *--y;
+ *((f++)+n2) = ( (*x++ - *y) * (*c++) ) >> DCTBITS;
+ }
+ f+=n2;
+ x+=n2;
+}
+}
+---*/
+/*------------------------------------------------------------*/
+static void forward_bfm(int m, INT32 x[], INT32 f[])
+{
+ int i;
+ int p;
+
+/*--- special case last fwd stage ----*/
+ for (p = 0, i = 0; i < m; i++, p += 2)
+ {
+ f[p] = x[p] + x[p + 1];
+ f[p + 1] = ((x[p] - x[p + 1]) * coef32[30]) >> DCTBITS;
+ }
+}
+/*------------------------------------------------------------*/
+static void back_bf(int m, int n, INT32 x[], INT32 f[])
+{
+ int i, j, n2, n21;
+ int p, q, p0;
+
+ p0 = 0;
+ n2 = n >> 1;
+ n21 = n2 - 1;
+ for (i = 0; i < m; i++, p0 += n)
+ {
+ p = p0;
+ q = p0;
+ for (j = 0; j < n2; j++, p += 2, q++)
+ f[p] = x[q];
+ p = p0 + 1;
+ for (j = 0; j < n21; j++, p += 2, q++)
+ f[p] = x[q] + x[q + 1];
+ f[p] = x[q];
+ }
+}
+/*------------------------------------------------------------*/
+static void back_bf0(int n, INT32 x[], WININT f[])
+{
+ int p, q;
+
+ n--;
+#if DCTSATURATE
+ for (p = 0, q = 0; p < n; p += 2, q++)
+ {
+ tmp = x[q];
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ f[p] = tmp;
+ }
+ for (p = 1; q < n; p += 2, q++)
+ {
+ tmp = x[q] + x[q + 1];
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ f[p] = tmp;
+ }
+ tmp = x[q];
+ if (tmp > 32767)
+ tmp = 32767;
+ else if (tmp < -32768)
+ tmp = -32768;
+ f[p] = tmp;
+#else
+ for (p = 0, q = 0; p < n; p += 2, q++)
+ f[p] = x[q];
+ for (p = 1; q < n; p += 2, q++)
+ f[p] = x[q] + x[q + 1];
+ f[p] = x[q];
+#endif
+
+}
+/*------------------------------------------------------------*/
+void i_dct32(SAMPLEINT x[], WININT c[])
+{
+ INT32 a[32]; /* ping pong buffers */
+ INT32 b[32];
+ int p, q;
+
+/* special first stage */
+ for (p = 0, q = 31; p < 16; p++, q--)
+ {
+ a[p] = (INT32) x[p] + x[q];
+ a[16 + p] = (coef32[p] * ((INT32) x[p] - x[q])) >> DCTBITS;
+ }
+
+ forward_bf(2, 16, a, b, coef32 + 16);
+ forward_bf(4, 8, b, a, coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+ forward_bfm(16, b, a);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf0(32, b, c);
+}
+/*------------------------------------------------------------*/
+void i_dct32_dual(SAMPLEINT x[], WININT c[])
+{
+ INT32 a[32]; /* ping pong buffers */
+ INT32 b[32];
+ int p, pp, qq;
+
+/* special first stage for dual chan (interleaved x) */
+ pp = 0;
+ qq = 2 * 31;
+ for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+ {
+ a[p] = (INT32) x[pp] + x[qq];
+ a[16 + p] = (coef32[p] * ((INT32) x[pp] - x[qq])) >> DCTBITS;
+ }
+ forward_bf(2, 16, a, b, coef32 + 16);
+ forward_bf(4, 8, b, a, coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+ forward_bfm(16, b, a);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf0(32, b, c);
+}
+/*---------------convert dual to mono------------------------------*/
+void i_dct32_dual_mono(SAMPLEINT x[], WININT c[])
+{
+ INT32 a[32]; /* ping pong buffers */
+ INT32 b[32];
+ INT32 t1, t2;
+ int p, pp, qq;
+
+/* special first stage */
+ pp = 0;
+ qq = 2 * 31;
+ for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+ {
+ t1 = ((INT32) x[pp] + x[pp + 1]);
+ t2 = ((INT32) x[qq] + x[qq + 1]);
+ a[p] = (t1 + t2) >> 1;
+ a[16 + p] = coef32[p] * (t1 - t2) >> (DCTBITS + 1);
+ }
+ forward_bf(2, 16, a, b, coef32 + 16);
+ forward_bf(4, 8, b, a, coef32 + 16 + 8);
+ forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+ forward_bfm(16, b, a);
+ back_bf(8, 4, a, b);
+ back_bf(4, 8, b, a);
+ back_bf(2, 16, a, b);
+ back_bf0(32, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt dct -------------------------------*/
+void i_dct16(SAMPLEINT x[], WININT c[])
+{
+ INT32 a[16]; /* ping pong buffers */
+ INT32 b[16];
+ int p, q;
+
+/* special first stage (drop highest sb) */
+ a[0] = x[0];
+ a[8] = (a[0] * coef32[16]) >> DCTBITS;
+ for (p = 1, q = 14; p < 8; p++, q--)
+ {
+ a[p] = (INT32) x[p] + x[q];
+ a[8 + p] = (((INT32) x[p] - x[q]) * coef32[16 + p]) >> DCTBITS;
+ }
+ forward_bf(2, 8, a, b, coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(8, a, b);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf0(16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt dct dual chan---------------------*/
+void i_dct16_dual(SAMPLEINT x[], WININT c[])
+{
+ int p, pp, qq;
+ INT32 a[16]; /* ping pong buffers */
+ INT32 b[16];
+
+/* special first stage for interleaved input */
+ a[0] = x[0];
+ a[8] = (coef32[16] * a[0]) >> DCTBITS;
+ pp = 2;
+ qq = 2 * 14;
+ for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+ {
+ a[p] = (INT32) x[pp] + x[qq];
+ a[8 + p] = (coef32[16 + p] * ((INT32) x[pp] - x[qq])) >> DCTBITS;
+ }
+ forward_bf(2, 8, a, b, coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(8, a, b);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf0(16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt dct dual to mono-------------------*/
+void i_dct16_dual_mono(SAMPLEINT x[], WININT c[])
+{
+ INT32 a[16]; /* ping pong buffers */
+ INT32 b[16];
+ INT32 t1, t2;
+ int p, pp, qq;
+
+/* special first stage */
+ a[0] = ((INT32) x[0] + x[1]) >> 1;
+ a[8] = (coef32[16] * a[0]) >> DCTBITS;
+ pp = 2;
+ qq = 2 * 14;
+ for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+ {
+ t1 = (INT32) x[pp] + x[pp + 1];
+ t2 = (INT32) x[qq] + x[qq + 1];
+ a[p] = (t1 + t2) >> 1;
+ a[8 + p] = (coef32[16 + p] * (t1 - t2)) >> (DCTBITS + 1);
+ }
+ forward_bf(2, 8, a, b, coef32 + 16 + 8);
+ forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(8, a, b);
+ back_bf(4, 4, b, a);
+ back_bf(2, 8, a, b);
+ back_bf0(16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt dct -------------------------------*/
+void i_dct8(SAMPLEINT x[], WININT c[])
+{
+ int p, q;
+ INT32 a[8]; /* ping pong buffers */
+ INT32 b[8];
+
+/* special first stage */
+
+ for (p = 0, q = 7; p < 4; p++, q--)
+ {
+ b[p] = (INT32) x[p] + x[q];
+ b[4 + p] = (coef32[16 + 8 + p] * ((INT32) x[p] - x[q])) >> DCTBITS;
+ }
+
+ forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(4, a, b);
+ back_bf(2, 4, b, a);
+ back_bf0(8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt dct dual chan---------------------*/
+void i_dct8_dual(SAMPLEINT x[], WININT c[])
+{
+ int p, pp, qq;
+ INT32 a[8]; /* ping pong buffers */
+ INT32 b[8];
+
+/* special first stage for interleaved input */
+ for (p = 0, pp = 0, qq = 14; p < 4; p++, pp += 2, qq -= 2)
+ {
+ b[p] = (INT32) x[pp] + x[qq];
+ b[4 + p] = (coef32[16 + 8 + p] * ((INT32) x[pp] - x[qq])) >> DCTBITS;
+ }
+ forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(4, a, b);
+ back_bf(2, 4, b, a);
+ back_bf0(8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt dct dual to mono---------------------*/
+void i_dct8_dual_mono(SAMPLEINT x[], WININT c[])
+{
+ int p, pp, qq;
+ INT32 a[8]; /* ping pong buffers */
+ INT32 b[8];
+ INT32 t1, t2;
+
+/* special first stage */
+ for (p = 0, pp = 0, qq = 14; p < 4; p++, pp += 2, qq -= 2)
+ {
+ t1 = (INT32) x[pp] + x[pp + 1];
+ t2 = (INT32) x[qq] + x[qq + 1];
+ b[p] = (t1 + t2) >> 1;
+ b[4 + p] = (coef32[16 + 8 + p] * (t1 - t2)) >> (DCTBITS + 1);
+ }
+ forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+ forward_bfm(4, a, b);
+ back_bf(2, 4, b, a);
+ back_bf0(8, a, c);
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** isbt.c ***************************************************
+
+MPEG audio decoder, dct and window
+portable C integer version of csbt.c
+
+mods 11/15/95 for Layer I
+
+mods 1/7/97 warnings
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "itype.h"
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4244)
+#pragma warning(disable: 4056)
+#endif
+
+
+
+/* asm is quick only, c code does not need separate window for right */
+/* full is opposite of quick */
+#ifdef FULL_INTEGER
+#define i_window_dual_right i_window_dual
+#define i_window16_dual_right i_window16_dual
+#define i_window8_dual_right i_window8_dual
+#endif
+
+
+void i_dct32(SAMPLEINT * sample, WININT * vbuf);
+void i_dct32_dual(SAMPLEINT * sample, WININT * vbuf);
+void i_dct32_dual_mono(SAMPLEINT * sample, WININT * vbuf);
+
+void i_dct16(SAMPLEINT * sample, WININT * vbuf);
+void i_dct16_dual(SAMPLEINT * sample, WININT * vbuf);
+void i_dct16_dual_mono(SAMPLEINT * sample, WININT * vbuf);
+
+void i_dct8(SAMPLEINT * sample, WININT * vbuf);
+void i_dct8_dual(SAMPLEINT * sample, WININT * vbuf);
+void i_dct8_dual_mono(SAMPLEINT * sample, WININT * vbuf);
+
+
+void i_window(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window_dual(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
+
+void i_window16(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window16_dual(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window16_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
+
+void i_window8(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window8_dual(WININT * vbuf, int vb_ptr, short *pcm);
+void i_window8_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
+
+/*--------------------------------------------------------------------*/
+/*-- floating point window coefs ---*/
+/*-- for integer-quick window, table used to generate integer coefs --*/
+static float wincoef[264] =
+{
+#include "tableawd.h"
+};
+
+/* circular window buffers */
+/* extern windows because of asm */
+static signed int vb_ptr;
+
+// static WININT vbuf[512];
+//static WININT vbuf2[512];
+extern WININT vbuf[512];
+extern WININT vbuf2[512];
+
+DCTCOEF *i_dct_coef_addr();
+
+/*======================================================================*/
+static void gencoef() /* gen coef for N=32 */
+{
+ int p, n, i, k;
+ double t, pi;
+ DCTCOEF *coef32;
+
+ coef32 = i_dct_coef_addr();
+
+
+ pi = 4.0 * atan(1.0);
+ n = 16;
+ k = 0;
+ for (i = 0; i < 5; i++, n = n / 2)
+ {
+ for (p = 0; p < n; p++, k++)
+ {
+ t = (pi / (4 * n)) * (2 * p + 1);
+ coef32[k] = (1 << DCTBITS) * (0.50 / cos(t)) + 0.5;
+ }
+ }
+}
+/*------------------------------------------------------------*/
+WINCOEF *i_wincoef_addr();
+static void genwincoef_q() /* gen int window coefs from floating table */
+{
+ int i, j, k, m;
+ float x;
+ WINCOEF *iwincoef;
+
+ iwincoef = i_wincoef_addr();
+
+
+/*--- coefs generated inline for quick window ---*/
+/*-- quick uses only 116 coefs --*/
+
+ k = 0;
+ m = 0;
+ for (i = 0; i < 16; i++)
+ {
+ k += 5;
+ for (j = 0; j < 7; j++)
+ {
+ x = (1 << WINBITS) * wincoef[k++];
+ if (x > 0.0)
+ x += 0.5;
+ else
+ x -= 0.5;
+ iwincoef[m++] = x;
+ }
+ k += 4;
+ }
+ k++;
+ for (j = 0; j < 4; j++)
+ {
+ x = (1 << WINBITS) * wincoef[k++];
+ if (x > 0.0)
+ x += 0.5;
+ else
+ x -= 0.5;
+ iwincoef[m++] = x;
+ }
+}
+/*------------------------------------------------------------*/
+static void genwincoef() /* gen int window coefs from floating table */
+{
+ int i;
+ float x;
+ WINCOEF *iwincoef;
+ WINCOEF *i_wincoef_addr();
+
+ iwincoef = i_wincoef_addr();
+
+ for (i = 0; i < 264; i++)
+ {
+ x = (1 << WINBITS) * wincoef[i];
+ if (x > 0.0)
+ x += 0.5;
+ else
+ x -= 0.5;
+ iwincoef[i] = x;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt_init()
+{
+ int i;
+ static int first_pass = 1;
+
+#ifdef FULL_INTEGER
+ static int full_integer = 1;
+
+#else
+ static int full_integer = 0;
+
+#endif
+
+ if (first_pass)
+ {
+ gencoef();
+ if (full_integer)
+ genwincoef();
+ else
+ genwincoef_q();
+ first_pass = 0;
+ }
+
+/* clear window vbuf */
+ for (i = 0; i < 512; i++)
+ vbuf[i] = vbuf2[i] = 0;
+ vb_ptr = 0;
+
+}
+/*==============================================================*/
+/*==============================================================*/
+/*==============================================================*/
+void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32(sample, vbuf + vb_ptr);
+ i_window(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_dct32_dual(sample + 1, vbuf2 + vb_ptr);
+ i_window_dual(vbuf, vb_ptr, pcm);
+ i_window_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual_mono(sample, vbuf + vb_ptr);
+ i_window(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_window(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ sample++; /* point to right chan */
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_window(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16(sample, vbuf + vb_ptr);
+ i_window16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_dct16_dual(sample + 1, vbuf2 + vb_ptr);
+ i_window16_dual(vbuf, vb_ptr, pcm);
+ i_window16_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual_mono(sample, vbuf + vb_ptr);
+ i_window16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_window16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_window16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8(sample, vbuf + vb_ptr);
+ i_window8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
+ i_window8_dual(vbuf, vb_ptr, pcm);
+ i_window8_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual_mono(sample, vbuf + vb_ptr);
+ i_window8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_window8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_window8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+/*--- 8 bit output ----------------*/
+#include "isbtb.c"
+/*----------------------------------*/
+
+#ifdef _MSC_VER
+#pragma warning(default: 4244)
+#pragma warning(default: 4056)
+#endif
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** isbtb.c ***************************************************
+
+include to isbt.c
+
+
+MPEG audio decoder, integer dct and window, 8 bit output
+
+
+******************************************************************/
+/* asm is quick only, c code does not need separate window for right */
+/* full is opposite of quick */
+#ifdef FULL_INTEGER
+#define i_windowB_dual_right i_windowB_dual
+#define i_windowB16_dual_right i_windowB16_dual
+#define i_windowB8_dual_right i_windowB8_dual
+#endif
+
+void i_windowB(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB16(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB16_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB16_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB8(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB8_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+void i_windowB8_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
+
+
+
+/*==============================================================*/
+/*==============================================================*/
+/*==============================================================*/
+void i_sbtB_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32(sample, vbuf + vb_ptr);
+ i_windowB(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbtB_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_dct32_dual(sample + 1, vbuf2 + vb_ptr);
+ i_windowB_dual(vbuf, vb_ptr, pcm);
+ i_windowB_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 64;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void i_sbtB_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual_mono(sample, vbuf + vb_ptr);
+ i_windowB(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void i_sbtB_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_windowB(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void i_sbtB_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++; /* point to right chan */
+ for (i = 0; i < n; i++)
+ {
+ i_dct32_dual(sample, vbuf + vb_ptr);
+ i_windowB(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 32) & 511;
+ pcm += 32;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void i_sbtB16_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16(sample, vbuf + vb_ptr);
+ i_windowB16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbtB16_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_dct16_dual(sample + 1, vbuf2 + vb_ptr);
+ i_windowB16_dual(vbuf, vb_ptr, pcm);
+ i_windowB16_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 32;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbtB16_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual_mono(sample, vbuf + vb_ptr);
+ i_windowB16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbtB16_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_windowB16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbtB16_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ i_dct16_dual(sample, vbuf + vb_ptr);
+ i_windowB16(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 16) & 255;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's -------------------------------*/
+/*------------------------------------------------------------*/
+void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8(sample, vbuf + vb_ptr);
+ i_windowB8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+
+}
+/*------------------------------------------------------------*/
+void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
+ i_windowB8_dual(vbuf, vb_ptr, pcm);
+ i_windowB8_dual_right(vbuf2, vb_ptr, pcm + 1);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 16;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual_mono(sample, vbuf + vb_ptr);
+ i_windowB8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_windowB8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
+void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
+{
+ int i;
+
+ sample++;
+ for (i = 0; i < n; i++)
+ {
+ i_dct8_dual(sample, vbuf + vb_ptr);
+ i_windowB8(vbuf, vb_ptr, pcm);
+ sample += 64;
+ vb_ptr = (vb_ptr - 8) & 127;
+ pcm += 8;
+ }
+}
+/*------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** iup.c ***************************************************
+
+MPEG audio decoder Layer I/II, mpeg1 and mpeg2
+should be portable ANSI C, should be endian independent
+
+icup integer version of cup.c
+
+
+
+mod 10/18/95 mod grouped sample unpack for:
+ Overflow possible in grouped if native int is 16 bit.
+ Rare occurance. 16x16-->32 mult needed.
+
+mods 11/15/95 for Layer I
+
+
+1/5/95 Quick fix, cs_factor can overflow int16 (why?). Typed to int32.
+
+mods 1/7/97 warnings
+
+******************************************************************/
+/******************************************************************
+
+ MPEG audio software decoder portable ANSI c.
+ Decodes all Layer II to 16 bit linear pcm.
+ Optional stereo to mono conversion. Optional
+ output sample rate conversion to half or quarter of
+ native mpeg rate.
+
+-------------------------------------
+int i_audio_decode_init(MPEG *m, MPEG_HEAD *h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+
+initilize decoder:
+ return 0 = fail, not 0 = success
+
+MPEG_HEAD *h input, mpeg header info (returned by call to head_info)
+framebytes input, mpeg frame size (returned by call to head_info)
+reduction_code input, sample rate reduction code
+ 0 = full rate
+ 1 = half rate
+ 0 = quarter rate
+
+transform_code input, ignored
+convert_code input, channel conversion
+ convert_code: 0 = two chan output
+ 1 = convert two chan to mono
+ 2 = convert two chan to left chan
+ 3 = convert two chan to right chan
+freq_limit input, limits bandwidth of pcm output to specified
+ frequency. Special use. Set to 24000 for normal use.
+
+
+---------------------------------
+void i_audio_decode_info( MPEG *m, DEC_INFO *info)
+
+information return:
+ Call after audio_decode_init. See mhead.h for
+ information returned in DEC_INFO structure.
+
+
+---------------------------------
+IN_OUT i_audio_decode(MPEG *m, unsigned char *bs, void *pcmbuf)
+
+decode one mpeg audio frame:
+bs input, mpeg bitstream, must start with
+ sync word. Caution: may read up to 3 bytes
+ beyond end of frame.
+pcmbuf output, pcm samples.
+
+IN_OUT structure returns:
+ Number bytes conceptually removed from mpeg bitstream.
+ Returns 0 if sync loss.
+ Number bytes of pcm output.
+
+*******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h" /* mpeg header structure */
+#include "jdw.h"
+
+/*-------------------------------------------------------
+NOTE: Decoder may read up to three bytes beyond end of
+frame. Calling application must ensure that this does
+not cause a memory access violation (protection fault)
+---------------------------------------------------------*/
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4709)
+#endif
+
+
+/* Okay to be global -- is read/only */
+static int look_joint[16] =
+{ /* lookup stereo sb's by mode+ext */
+ 64, 64, 64, 64, /* stereo */
+ 2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
+ 64, 64, 64, 64, /* dual */
+ 32, 32, 32, 32, /* mono */
+};
+
+/* Okay to be global -- is read/only */
+static int bat_bit_master[] =
+{
+ 0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48};
+
+void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
+
+static void unpack();
+
+/*------------- initialize bit getter -------------*/
+static void load_init(MPEGI *m, unsigned char *buf)
+{
+ m->iup.bs_ptr = buf;
+ m->iup.bits = 0;
+ m->iup.bitbuf = 0;
+}
+/*------------- get n bits from bitstream -------------*/
+static INT32 load(MPEGI *m, int n)
+{
+ UINT32 x;
+
+ if (m->iup.bits < n)
+ { /* refill bit buf if necessary */
+ while (m->iup.bits <= 24)
+ {
+ m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++;
+ m->iup.bits += 8;
+ }
+ }
+ m->iup.bits -= n;
+ x = m->iup.bitbuf >> m->iup.bits;
+ m->iup.bitbuf -= x << m->iup.bits;
+ return x;
+}
+/*------------- skip over n bits in bitstream -------------*/
+static void skip(MPEGI *m, int n)
+{
+ int k;
+
+ if (m->iup.bits < n)
+ {
+ n -= m->iup.bits;
+ k = n >> 3;
+/*--- bytes = n/8 --*/
+ m->iup.bs_ptr += k;
+ n -= k << 3;
+ m->iup.bitbuf = *m->iup.bs_ptr++;
+ m->iup.bits = 8;
+ }
+ m->iup.bits -= n;
+ m->iup.bitbuf -= (m->iup.bitbuf >> m->iup.bits) << m->iup.bits;
+}
+/*--------------------------------------------------------------*/
+#define mac_load_check(n) \
+ if( m->iup.bits < (n) ) { \
+ while( m->iup.bits <= 24 ) { \
+ m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++; \
+ m->iup.bits += 8; \
+ } \
+ }
+/*--------------------------------------------------------------*/
+#define mac_load(n) \
+ ( m->iup.bits -= n, \
+ m->iup.bitval = m->iup.bitbuf >> m->iup.bits, \
+ m->iup.bitbuf -= m->iup.bitval << m->iup.bits, \
+ m->iup.bitval )
+/*======================================================================*/
+static void unpack_ba(MPEGI *m)
+{
+ int i, j, k;
+ static int nbit[4] =
+ {4, 4, 3, 2};
+ int nstereo;
+ int n;
+
+ m->iup.bit_skip = 0;
+ nstereo = m->iup.stereo_sb;
+ k = 0;
+ for (i = 0; i < 4; i++)
+ {
+ for (j = 0; j < m->iup.nbat[i]; j++, k++)
+ {
+ mac_load_check(4);
+ n = m->iup.ballo[k] = m->iup.samp_dispatch[k] = m->iup.bat[i][mac_load(nbit[i])];
+ if (k >= m->iup.nsb_limit)
+ m->iup.bit_skip += bat_bit_master[m->iup.samp_dispatch[k]];
+ m->iup.c_value[k] = m->iup.look_c_value[n];
+ m->iup.c_shift[k] = m->iup.look_c_shift[n];
+ if (--nstereo < 0)
+ {
+ m->iup.ballo[k + 1] = m->iup.ballo[k];
+ m->iup.samp_dispatch[k] += 18; /* flag as joint */
+ m->iup.samp_dispatch[k + 1] = m->iup.samp_dispatch[k]; /* flag for sf */
+ m->iup.c_value[k + 1] = m->iup.c_value[k];
+ m->iup.c_shift[k + 1] = m->iup.c_shift[k];
+ k++;
+ j++;
+ }
+ }
+ }
+ m->iup.samp_dispatch[m->iup.nsb_limit] = 37; /* terminate the dispatcher with skip */
+ m->iup.samp_dispatch[k] = 36; /* terminate the dispatcher */
+
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfs(MPEGI *m) /* unpack scale factor selectors */
+{
+ int i;
+
+ for (i = 0; i < m->iup.max_sb; i++)
+ {
+ mac_load_check(2);
+ if (m->iup.ballo[i])
+ m->iup.sf_dispatch[i] = mac_load(2);
+ else
+ m->iup.sf_dispatch[i] = 4; /* no allo */
+ }
+ m->iup.sf_dispatch[i] = 5; /* terminate dispatcher */
+}
+/*-------------------------------------------------------------------------*/
+/*--- multiply note -------------------------------------------------------*/
+/*--- 16bit x 16bit mult --> 32bit >> 15 --> 16 bit or better -----------*/
+static void unpack_sf(MPEGI *m) /* unpack scale factor */
+{ /* combine dequant and scale factors */
+ int i, n;
+ INT32 tmp; /* only reason tmp is 32 bit is to get 32 bit mult result */
+
+ i = -1;
+ dispatch:switch (m->iup.sf_dispatch[++i])
+ {
+ case 0: /* 3 factors 012 */
+ mac_load_check(18);
+ tmp = m->iup.c_value[i];
+ n = m->iup.c_shift[i];
+ m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ m->iup.cs_factor[1][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ goto dispatch;
+ case 1: /* 2 factors 002 */
+ mac_load_check(12);
+ tmp = m->iup.c_value[i];
+ n = m->iup.c_shift[i];
+ m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
+ (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ goto dispatch;
+ case 2: /* 1 factor 000 */
+ mac_load_check(6);
+ tmp = m->iup.c_value[i];
+ n = m->iup.c_shift[i];
+ m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
+ (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ goto dispatch;
+ case 3: /* 2 factors 022 */
+ mac_load_check(12);
+ tmp = m->iup.c_value[i];
+ n = m->iup.c_shift[i];
+ m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] =
+ (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ goto dispatch;
+ case 4: /* no allo */
+ goto dispatch;
+ case 5: /* all done */
+ ;
+ } /* end switch */
+}
+/*-------------------------------------------------------------------------*/
+/*-------------------------------------------------------------------------*/
+/*--- unpack multiply note ------------------------------------------------*/
+/*--- 16bit x 16bit mult --> 32bit or better required---------------------*/
+#define UNPACK_N(n) \
+ s[k] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
+ s[k+64] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
+ s[k+128] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
+ goto dispatch;
+#define UNPACK_N2(n) \
+ mac_load_check(3*n); \
+ s[k] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ s[k+64] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ s[k+128] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ goto dispatch;
+#define UNPACK_N3(n) \
+ mac_load_check(2*n); \
+ s[k] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ s[k+64] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ mac_load_check(n); \
+ s[k+128] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
+ goto dispatch;
+#define UNPACKJ_N(n) \
+ tmp = (load(m,n)-((1 << (n-1)) -1)); \
+ s[k] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
+ s[k+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
+ tmp = (load(m,n)-((1 << (n-1)) -1)); \
+ s[k+64] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
+ s[k+64+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
+ tmp = (load(m,n)-((1 << (n-1)) -1)); \
+ s[k+128] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
+ s[k+128+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
+ k++; /* skip right chan dispatch */ \
+ goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_samp(MPEGI *m) /* unpack samples */
+{
+ int i, j, k;
+ SAMPLEINT *s;
+ int n;
+ INT32 tmp;
+
+ s = m->iup.sample;
+ for (i = 0; i < 3; i++)
+ { /* 3 groups of scale factors */
+ for (j = 0; j < 4; j++)
+ {
+ k = -1;
+ dispatch:switch (m->iup.samp_dispatch[++k])
+ {
+ case 0:
+ s[k + 128] = s[k + 64] = s[k] = 0;
+ goto dispatch;
+ case 1: /* 3 levels grouped 5 bits */
+ mac_load_check(5);
+ n = mac_load(5);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
+ goto dispatch;
+ case 2: /* 5 levels grouped 7 bits */
+ mac_load_check(7);
+ n = mac_load(7);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
+ goto dispatch;
+ case 3:
+ UNPACK_N2(3) /* 7 levels */
+ case 4: /* 9 levels grouped 10 bits */
+ mac_load_check(10);
+ n = mac_load(10);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
+ goto dispatch;
+ case 5:
+ UNPACK_N2(4) /* 15 levels */
+ case 6:
+ UNPACK_N2(5) /* 31 levels */
+ case 7:
+ UNPACK_N2(6) /* 63 levels */
+ case 8:
+ UNPACK_N2(7) /* 127 levels */
+ case 9:
+ UNPACK_N2(8) /* 255 levels */
+ case 10:
+ UNPACK_N3(9) /* 511 levels */
+ case 11:
+ UNPACK_N3(10) /* 1023 levels */
+ case 12:
+ UNPACK_N3(11) /* 2047 levels */
+ case 13:
+ UNPACK_N3(12) /* 4095 levels */
+ case 14:
+ UNPACK_N(13) /* 8191 levels */
+ case 15:
+ UNPACK_N(14) /* 16383 levels */
+ case 16:
+ UNPACK_N(15) /* 32767 levels */
+ case 17:
+ UNPACK_N(16) /* 65535 levels */
+/* -- joint ---- */
+ case 18 + 0:
+ s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0;
+ k++; /* skip right chan dispatch */
+ goto dispatch;
+ case 18 + 1: /* 3 levels grouped 5 bits */
+ n = load(m,5);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
+ s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][0]) >> 1;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
+ s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][1]) >> 1;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
+ s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][2]) >> 1;
+ k++; /* skip right chan dispatch */
+ goto dispatch;
+ case 18 + 2: /* 5 levels grouped 7 bits */
+ n = load(m,7);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
+ s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][0]) >> 2;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
+ s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][1]) >> 2;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
+ s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][2]) >> 2;
+ k++; /* skip right chan dispatch */
+ goto dispatch;
+ case 18 + 3:
+ UNPACKJ_N(3) /* 7 levels */
+ case 18 + 4: /* 9 levels grouped 10 bits */
+ n = load(m,10);
+ s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
+ s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][0]) >> 3;
+ s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
+ s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][1]) >> 3;
+ s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
+ s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][2]) >> 3;
+ k++; /* skip right chan dispatch */
+ goto dispatch;
+ case 18 + 5:
+ UNPACKJ_N(4) /* 15 levels */
+ case 18 + 6:
+ UNPACKJ_N(5) /* 31 levels */
+ case 18 + 7:
+ UNPACKJ_N(6) /* 63 levels */
+ case 18 + 8:
+ UNPACKJ_N(7) /* 127 levels */
+ case 18 + 9:
+ UNPACKJ_N(8) /* 255 levels */
+ case 18 + 10:
+ UNPACKJ_N(9) /* 511 levels */
+ case 18 + 11:
+ UNPACKJ_N(10) /* 1023 levels */
+ case 18 + 12:
+ UNPACKJ_N(11) /* 2047 levels */
+ case 18 + 13:
+ UNPACKJ_N(12) /* 4095 levels */
+ case 18 + 14:
+ UNPACKJ_N(13) /* 8191 levels */
+ case 18 + 15:
+ UNPACKJ_N(14) /* 16383 levels */
+ case 18 + 16:
+ UNPACKJ_N(15) /* 32767 levels */
+ case 18 + 17:
+ UNPACKJ_N(16) /* 65535 levels */
+/* -- end of dispatch -- */
+ case 37:
+ skip(m, m->iup.bit_skip);
+ case 36:
+ s += 3 * 64;
+ } /* end switch */
+ } /* end j loop */
+ } /* end i loop */
+
+
+}
+/*-------------------------------------------------------------------------*/
+static void unpack(MPEGI *m)
+{
+ int prot;
+
+/* at entry bit getter points at id, sync skipped by caller */
+
+ load(m,3); /* skip id and option (checked by init) */
+ prot = load(m,1); /* load prot bit */
+ load(m,6); /* skip to pad */
+ m->iup.pad = load(m,1);
+ load(m,1); /* skip to mode */
+ m->iup.stereo_sb = look_joint[load(m,4)];
+ if (prot)
+ load(m,4); /* skip to data */
+ else
+ load(m,20); /* skip crc */
+
+ unpack_ba(m); /* unpack bit allocation */
+ unpack_sfs(m); /* unpack scale factor selectors */
+ unpack_sf(m); /* unpack scale factor */
+ unpack_samp(m); /* unpack samples */
+
+
+}
+/*-------------------------------------------------------------------------*/
+IN_OUT i_audio_decode(MPEGI *m, unsigned char *bs, signed short *pcm)
+{
+ int sync;
+ IN_OUT in_out;
+
+ load_init(m,bs); /* initialize bit getter */
+/* test sync */
+ in_out.in_bytes = 0; /* assume fail */
+ in_out.out_bytes = 0;
+ sync = load(m,12);
+
+ if (sync != 0xFFF)
+ return in_out; /* sync fail */
+/*-----------*/
+ m->iup.unpack_routine();
+
+
+ m->iup.sbt(m->iup.sample, pcm, m->iup.nsbt);
+/*-----------*/
+ in_out.in_bytes = m->iup.framebytes + m->iup.pad;
+ in_out.out_bytes = m->iup.outbytes;
+ return in_out;
+}
+/*-------------------------------------------------------------------------*/
+#include "iupini.c" /* initialization */
+#include "iupL1.c" /* Layer 1 */
+/*-------------------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** iupL1.c ***************************************************
+
+MPEG audio decoder Layer I mpeg1 and mpeg2
+should be portable ANSI C, should be endian independent
+
+icupL1 integer version of cupL1.c
+
+******************************************************************/
+/*======================================================================*/
+/* Read Only */
+static int bat_bit_masterL1[] =
+{
+ 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+
+/*======================================================================*/
+static void unpack_baL1(MPEGI *m)
+{
+ int k;
+ int nstereo;
+ int n;
+
+ m->iup.bit_skip = 0;
+ nstereo = m->iup.stereo_sb;
+ for (k = 0; k < m->iup.nbatL1; k++)
+ {
+ mac_load_check(4);
+ n = m->iup.ballo[k] = m->iup.samp_dispatch[k] = mac_load(4);
+ if (k >= m->iup.nsb_limit)
+ m->iup.bit_skip += bat_bit_masterL1[m->iup.samp_dispatch[k]];
+ m->iup.c_value[k] = m->iup.look_c_valueL1[n];
+ m->iup.c_shift[k] = m->iup.look_c_shiftL1[n];
+ if (--nstereo < 0)
+ {
+ m->iup.ballo[k + 1] = m->iup.ballo[k];
+ m->iup.samp_dispatch[k] += 15; /* flag as joint */
+ m->iup.samp_dispatch[k + 1] = m->iup.samp_dispatch[k]; /* flag for sf */
+ m->iup.c_value[k + 1] = m->iup.c_value[k];
+ m->iup.c_shift[k + 1] = m->iup.c_shift[k];
+ k++;
+ }
+ }
+ m->iup.samp_dispatch[m->iup.nsb_limit] = 31; /* terminate the dispatcher with skip */
+ m->iup.samp_dispatch[k] = 30; /* terminate the dispatcher */
+
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfL1(MPEGI *m) /* unpack scale factor */
+{ /* combine dequant and scale factors */
+ int i, n;
+ INT32 tmp; /* only reason tmp is 32 bit is to get 32 bit mult result */
+
+ for (i = 0; i < m->iup.nbatL1; i++)
+ {
+ if (m->iup.ballo[i])
+ {
+ mac_load_check(6);
+ tmp = m->iup.c_value[i];
+ n = m->iup.c_shift[i];
+ m->iup.cs_factorL1[i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
+ }
+ }
+
+/*-- done --*/
+}
+/*-------------------------------------------------------------------------*/
+#define UNPACKL1_N(n) s[k] = (m->iup.cs_factorL1[k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1); \
+ goto dispatch;
+#define UNPACKL1J_N(n) tmp = (load(m,n)-((1 << (n-1)) -1)); \
+ s[k] = (m->iup.cs_factorL1[k]*tmp)>>(n-1); \
+ s[k+1] = (m->iup.cs_factorL1[k+1]*tmp)>>(n-1); \
+ k++; /* skip right chan dispatch */ \
+ goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_sampL1(MPEGI *m) /* unpack samples */
+{
+ int j, k;
+ SAMPLEINT *s;
+ INT32 tmp;
+
+ s = m->iup.sample;
+ for (j = 0; j < 12; j++)
+ {
+ k = -1;
+ dispatch:switch (m->iup.samp_dispatch[++k])
+ {
+ case 0:
+ s[k] = 0;
+ goto dispatch;
+ case 1:
+ UNPACKL1_N(2) /* 3 levels */
+ case 2:
+ UNPACKL1_N(3) /* 7 levels */
+ case 3:
+ UNPACKL1_N(4) /* 15 levels */
+ case 4:
+ UNPACKL1_N(5) /* 31 levels */
+ case 5:
+ UNPACKL1_N(6) /* 63 levels */
+ case 6:
+ UNPACKL1_N(7) /* 127 levels */
+ case 7:
+ UNPACKL1_N(8) /* 255 levels */
+ case 8:
+ UNPACKL1_N(9) /* 511 levels */
+ case 9:
+ UNPACKL1_N(10) /* 1023 levels */
+ case 10:
+ UNPACKL1_N(11) /* 2047 levels */
+ case 11:
+ UNPACKL1_N(12) /* 4095 levels */
+ case 12:
+ UNPACKL1_N(13) /* 8191 levels */
+ case 13:
+ UNPACKL1_N(14) /* 16383 levels */
+ case 14:
+ UNPACKL1_N(15) /* 32767 levels */
+/* -- joint ---- */
+ case 15 + 0:
+ s[k + 1] = s[k] = 0;
+ k++; /* skip right chan dispatch */
+ goto dispatch;
+/* -- joint ---- */
+ case 15 + 1:
+ UNPACKL1J_N(2) /* 3 levels */
+ case 15 + 2:
+ UNPACKL1J_N(3) /* 7 levels */
+ case 15 + 3:
+ UNPACKL1J_N(4) /* 15 levels */
+ case 15 + 4:
+ UNPACKL1J_N(5) /* 31 levels */
+ case 15 + 5:
+ UNPACKL1J_N(6) /* 63 levels */
+ case 15 + 6:
+ UNPACKL1J_N(7) /* 127 levels */
+ case 15 + 7:
+ UNPACKL1J_N(8) /* 255 levels */
+ case 15 + 8:
+ UNPACKL1J_N(9) /* 511 levels */
+ case 15 + 9:
+ UNPACKL1J_N(10) /* 1023 levels */
+ case 15 + 10:
+ UNPACKL1J_N(11) /* 2047 levels */
+ case 15 + 11:
+ UNPACKL1J_N(12) /* 4095 levels */
+ case 15 + 12:
+ UNPACKL1J_N(13) /* 8191 levels */
+ case 15 + 13:
+ UNPACKL1J_N(14) /* 16383 levels */
+ case 15 + 14:
+ UNPACKL1J_N(15) /* 32767 levels */
+
+/* -- end of dispatch -- */
+ case 31:
+ skip(m, m->iup.bit_skip);
+ case 30:
+ s += 64;
+ } /* end switch */
+ } /* end j loop */
+
+/*-- done --*/
+}
+/*-------------------------------------------------------------------------*/
+static void unpackL1(MPEGI *m)
+{
+ int prot;
+
+/* at entry bit getter points at id, sync skipped by caller */
+
+ load(m,3); /* skip id and option (checked by init) */
+ prot = load(m,1); /* load prot bit */
+ load(m,6); /* skip to pad */
+ m->iup.pad = load(m,1) << 2;
+ load(m,1); /* skip to mode */
+ m->iup.stereo_sb = look_joint[load(m,4)];
+ if (prot)
+ load(m,4); /* skip to data */
+ else
+ load(m,20); /* skip crc */
+
+ unpack_baL1(m); /* unpack bit allocation */
+ unpack_sfL1(m); /* unpack scale factor */
+ unpack_sampL1(m); /* unpack samples */
+
+
+}
+/*-------------------------------------------------------------------------*/
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4056)
+#endif
+
+int i_audio_decode_initL1(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+{
+ int i, k;
+ long samprate;
+ int limit;
+ int stepbit;
+ long step;
+ int bit_code;
+
+/*--- sf table built by Layer II init ---*/
+
+ if (m->iup.first_pass_L1)
+ {
+ stepbit = 2;
+ step = 4;
+ for (i = 1; i < 16; i++)
+ {
+ m->iup.look_c_valueL1[i] = (int) (32768.0 * 2.0 / (step - 1));
+ m->iup.look_c_shiftL1[i] = 16 - stepbit;
+ stepbit++;
+ step <<= 1;
+ }
+ m->iup.first_pass_L1 = 0;
+ }
+
+ m->iup.unpack_routine = unpackL1;
+
+
+ transform_code = transform_code; /* not used, asm compatability */
+ bit_code = 0;
+ if (convert_code & 8)
+ bit_code = 1;
+ convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
+ if (reduction_code < 0)
+ reduction_code = 0;
+ if (reduction_code > 2)
+ reduction_code = 2;
+ if (freq_limit < 1000)
+ freq_limit = 1000;
+
+
+ m->iup.framebytes = framebytes_arg;
+/* check if code handles */
+ if (h->option != 3)
+ return 0; /* layer I only */
+
+ m->iup.nbatL1 = 32;
+ m->iup.max_sb = m->iup.nbatL1;
+/*----- compute nsb_limit --------*/
+ samprate = sr_table[4 * h->id + h->sr_index];
+ m->iup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code); ----*/
+ limit = (32 >> reduction_code);
+ if (limit > 8)
+ limit--;
+ if (m->iup.nsb_limit > limit)
+ m->iup.nsb_limit = limit;
+ if (m->iup.nsb_limit > m->iup.max_sb)
+ m->iup.nsb_limit = m->iup.max_sb;
+
+ m->iup.outvalues = 384 >> reduction_code;
+ if (h->mode != 3)
+ { /* adjust for 2 channel modes */
+ m->iup.nbatL1 *= 2;
+ m->iup.max_sb *= 2;
+ m->iup.nsb_limit *= 2;
+ }
+
+/* set sbt function */
+ m->iup.nsbt = 12;
+ k = 1 + convert_code;
+ if (h->mode == 3)
+ {
+ k = 0;
+ }
+ m->iup.sbt = sbt_table[bit_code][reduction_code][k];
+ m->iup.outvalues *= out_chans[k];
+ if (bit_code != 0)
+ m->iup.outbytes = m->iup.outvalues;
+ else
+ m->iup.outbytes = sizeof(short) * m->iup.outvalues;
+
+ m->iup.decinfo.channels = out_chans[k];
+ m->iup.decinfo.outvalues = m->iup.outvalues;
+ m->iup.decinfo.samprate = samprate >> reduction_code;
+ if (bit_code != 0)
+ m->iup.decinfo.bits = 8;
+ else
+ m->iup.decinfo.bits = sizeof(short) * 8;
+
+ m->iup.decinfo.framebytes = m->iup.framebytes;
+ m->iup.decinfo.type = 0;
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+ for (i = 0; i < 768; i++)
+ m->iup.sample[i] = 0;
+
+
+/* init sub-band transform */
+ i_sbt_init();
+
+ return 1;
+}
+
+#ifdef _MSC_VER
+#pragma warning(default: 4056)
+#endif
+
+/*---------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*=========================================================
+ initialization for iup.c - include to iup.c
+ mpeg audio decoder portable "c" integer
+
+
+mods 11/15/95 for Layer I
+
+mods 1/8/97 warnings
+
+=========================================================*/
+#include <limits.h>
+
+/* Read only */
+static long steps[18] =
+{
+ 0, 3, 5, 7, 9, 15, 31, 63, 127,
+ 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
+
+/* Read only */
+static int stepbits[18] =
+{
+ 0, 2, 3, 3, 4, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, 15, 16};
+
+/* ABCD_INDEX = lookqt[mode][sr_index][br_index] */
+/* -1 = invalid */
+/* Read only */
+static signed char lookqt[4][3][16] =
+{
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks stereo */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks joint stereo */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks dual chan */
+ {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
+ {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
+ {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}, /* 44ks single chan */
+ {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1}, /* 48ks */
+ {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}}, /* 32ks */
+};
+
+/* Read only */
+static long sr_table[8] =
+{22050L, 24000L, 16000L, 1L,
+ 44100L, 48000L, 32000L, 1L};
+
+/* bit allocation table look up */
+/* table per mpeg spec tables 3b2a/b/c/d /e is mpeg2 */
+/* look_bat[abcd_index][4][16] */
+/* Read only */
+static unsigned char look_bat[5][4][16] =
+{
+/* LOOK_BATA */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+ {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATB */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+ {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATC */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATD */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATE */
+ {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+};
+
+/* look_nbat[abcd_index]][4] */
+/* Read only */
+static unsigned char look_nbat[5][4] =
+{
+ {3, 8, 12, 4},
+ {3, 8, 12, 7},
+ {2, 0, 6, 0},
+ {2, 0, 10, 0},
+ {4, 0, 7, 19},
+};
+
+
+void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n);
+void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n);
+
+/*--- 8 bit output ---*/
+void i_sbtB_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB16_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB16_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB16_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB16_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB16_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
+void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
+
+
+/* Read Only */
+static SBT_FUNCTION sbt_table[2][3][5] =
+{
+ {{i_sbt_mono, i_sbt_dual, i_sbt_dual_mono, i_sbt_dual_left, i_sbt_dual_right},
+ {i_sbt16_mono, i_sbt16_dual, i_sbt16_dual_mono, i_sbt16_dual_left, i_sbt16_dual_right},
+ {i_sbt8_mono, i_sbt8_dual, i_sbt8_dual_mono, i_sbt8_dual_left, i_sbt8_dual_right}},
+
+ {{(SBT_FUNCTION) i_sbtB_mono,
+ (SBT_FUNCTION) i_sbtB_dual,
+ (SBT_FUNCTION) i_sbtB_dual_mono,
+ (SBT_FUNCTION) i_sbtB_dual_left,
+ (SBT_FUNCTION) i_sbtB_dual_right},
+ {(SBT_FUNCTION) i_sbtB16_mono,
+ (SBT_FUNCTION) i_sbtB16_dual,
+ (SBT_FUNCTION) i_sbtB16_dual_mono,
+ (SBT_FUNCTION) i_sbtB16_dual_left,
+ (SBT_FUNCTION) i_sbtB16_dual_right},
+ {(SBT_FUNCTION) i_sbtB8_mono,
+ (SBT_FUNCTION) i_sbtB8_dual,
+ (SBT_FUNCTION) i_sbtB8_dual_mono,
+ (SBT_FUNCTION) i_sbtB8_dual_left,
+ (SBT_FUNCTION) i_sbtB8_dual_right}},
+};
+/* Read Only */
+static int out_chans[5] =
+{1, 2, 1, 1, 1};
+
+/*---------------------------------------------------------*/
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4056)
+#endif
+
+void i_mpeg_init(MPEGI *m)
+{
+ memset(&m->iup, 0, sizeof(m->iup));
+ m->iup.nsb_limit = 6;
+ m->iup.nbat[0] = 3;
+ m->iup.nbat[1] = 8;
+ m->iup.nbat[3] = 12;
+ m->iup.nbat[4] = 7;
+ m->iup.nsbt = 36;
+ m->iup.sbt = i_sbt_mono;
+ m->iup.unpack_routine = unpack;
+ m->iup.first_pass = 1;
+ m->iup.first_pass_L1 = 1;
+ m->iup.nbatL1 = 32;
+ m->iup.cs_factorL1 = m->iup.cs_factor[0];
+}
+
+static void table_init(MPEGI *m)
+{
+ int i, j;
+ int code;
+ int bits;
+ long tmp, sfmax;
+
+/*-- c_values (dequant) --*/
+ for (i = 1; i < 18; i++)
+ m->iup.look_c_value[i] = (int) (32768.0 * 2.0 / steps[i]);
+ for (i = 1; i < 18; i++)
+ m->iup.look_c_shift[i] = 16 - stepbits[i];
+
+/*-- scale factor table, scale by 32768 for 16 pcm output --*/
+ bits = min(8 * sizeof(SAMPLEINT), 8 * sizeof(m->iup.sf_table[0]));
+ tmp = 1L << (bits - 2);
+ sfmax = tmp + (tmp - 1);
+ for (i = 0; i < 64; i++)
+ {
+ tmp = (long) (32768.0 * 2.0 * pow(2.0, -i / 3.0));
+ if (tmp > sfmax)
+ tmp = sfmax;
+ m->iup.sf_table[i] = tmp;
+ }
+/*-- grouped 3 level lookup table 5 bit token --*/
+ for (i = 0; i < 32; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->iup.group3_table[i][j] = (char) ((code % 3) - 1);
+ code /= 3;
+ }
+ }
+/*-- grouped 5 level lookup table 7 bit token --*/
+ for (i = 0; i < 128; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->iup.group5_table[i][j] = (char) ((code % 5) - 2);
+ code /= 5;
+ }
+ }
+/*-- grouped 9 level lookup table 10 bit token --*/
+ for (i = 0; i < 1024; i++)
+ {
+ code = i;
+ for (j = 0; j < 3; j++)
+ {
+ m->iup.group9_table[i][j] = (short) ((code % 9) - 4);
+ code /= 9;
+ }
+ }
+
+
+}
+
+#ifdef _MSC_VER
+#pragma warning(default: 4056)
+#endif
+
+/*---------------------------------------------------------*/
+int i_audio_decode_initL1(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit);
+void i_sbt_init();
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h frame bytes is without pad */
+int i_audio_decode_init(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
+ int reduction_code, int transform_code, int convert_code,
+ int freq_limit)
+{
+ int i, j, k;
+ int abcd_index;
+ long samprate;
+ int limit;
+ int bit_code;
+
+ if (m->iup.first_pass)
+ {
+ table_init(m);
+ m->iup.first_pass = 0;
+ }
+
+/* check if code handles */
+ if (h->option == 3) /* layer I */
+ return i_audio_decode_initL1(m, h, framebytes_arg,
+ reduction_code, transform_code, convert_code, freq_limit);
+ if (h->option != 2)
+ return 0; /* layer II only */
+
+
+ m->iup.unpack_routine = unpack;
+
+ transform_code = transform_code; /* not used, asm compatability */
+ bit_code = 0;
+ if (convert_code & 8)
+ bit_code = 1;
+ convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
+ if (reduction_code < 0)
+ reduction_code = 0;
+ if (reduction_code > 2)
+ reduction_code = 2;
+ if (freq_limit < 1000)
+ freq_limit = 1000;
+
+
+ m->iup.framebytes = framebytes_arg;
+
+/* compute abcd index for bit allo table selection */
+ if (h->id) /* mpeg 1 */
+ abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
+ else
+ abcd_index = 4; /* mpeg 2 */
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 16; j++)
+ m->iup.bat[i][j] = look_bat[abcd_index][i][j];
+ for (i = 0; i < 4; i++)
+ m->iup.nbat[i] = look_nbat[abcd_index][i];
+ m->iup.max_sb = m->iup.nbat[0] + m->iup.nbat[1] + m->iup.nbat[2] + m->iup.nbat[3];
+/*----- compute nsb_limit --------*/
+ samprate = sr_table[4 * h->id + h->sr_index];
+ m->iup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code); ----*/
+ limit = (32 >> reduction_code);
+ if (limit > 8)
+ limit--;
+ if (m->iup.nsb_limit > limit)
+ m->iup.nsb_limit = limit;
+ if (m->iup.nsb_limit > m->iup.max_sb)
+ m->iup.nsb_limit = m->iup.max_sb;
+
+ m->iup.outvalues = 1152 >> reduction_code;
+ if (h->mode != 3)
+ { /* adjust for 2 channel modes */
+ for (i = 0; i < 4; i++)
+ m->iup.nbat[i] *= 2;
+ m->iup.max_sb *= 2;
+ m->iup.nsb_limit *= 2;
+ }
+
+/* set sbt function */
+ m->iup.nsbt = 36;
+ k = 1 + convert_code;
+ if (h->mode == 3)
+ {
+ k = 0;
+ }
+ m->iup.sbt = sbt_table[bit_code][reduction_code][k];
+ m->iup.outvalues *= out_chans[k];
+ if (bit_code != 0)
+ m->iup.outbytes = m->iup.outvalues;
+ else
+ m->iup.outbytes = sizeof(short) * m->iup.outvalues;
+
+ m->iup.decinfo.channels = out_chans[k];
+ m->iup.decinfo.outvalues = m->iup.outvalues;
+ m->iup.decinfo.samprate = samprate >> reduction_code;
+ if (bit_code != 0)
+ m->iup.decinfo.bits = 8;
+ else
+ m->iup.decinfo.bits = sizeof(short) * 8;
+
+ m->iup.decinfo.framebytes = m->iup.framebytes;
+ m->iup.decinfo.type = 0;
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+ for (i = 0; i < 2304; i++)
+ m->iup.sample[i] = 0;
+
+
+/* init sub-band transform */
+ i_sbt_init();
+
+ return 1;
+}
+/*---------------------------------------------------------*/
+void i_audio_decode_info(MPEGI *m, DEC_INFO * info)
+{
+ *info = m->iup.decinfo; /* info return, call after init */
+}
+/*---------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 Emusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*----- iwinq.c ---------------------------------------------------
+
+portable c
+mpeg1/2 Layer II audio decode
+
+conditional include to iwinm.c
+
+quick integer window
+
+mods 1/8/97 warnings
+
+--------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+void i_window(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+}
+/*------------------------------------------------------------*/
+void i_window_dual(WININT * vbuf, int vb_ptr, short *pcm)
+{
+/* dual window interleaves output */
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+void i_window_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
+{
+/* right identical to dual, for asm */
+/* dual window interleaves output */
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void i_window16(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void i_window16_dual(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void i_window16_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
+{
+/* right identical to dual, for asm */
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*------------------- 8 pt window ------------------------------*/
+void i_window8(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (short) sum;
+ }
+}
+/*--------------- 8 pt dual window (interleaved output) --------------*/
+void i_window8_dual(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*--------------- 8 pt dual window (interleaved output) --------------*/
+void i_window8_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/* right identical to dual, for asm */
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (short) sum;
+ pcm += 2;
+ }
+}
+/*--------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*----- iwinbq.c ---------------------------------------------------
+
+portable c
+mpeg1/2 Layer I/II audio decode
+
+conditional include to iwinm.c
+
+quick integer window - 8 bit output
+
+mods 1/8/97 warnings
+
+--------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+void i_windowB(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+}
+/*------------------------------------------------------------*/
+void i_windowB_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+/* dual window interleaves output */
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+void i_windowB_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+/* right identical to dual, for asm */
+/* dual window interleaves output */
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 16 --*/
+ si = (vb_ptr + (16 + 3 * 64)) & 511;
+ bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
+ coef = iwincoef;
+ for (i = 0; i < 16; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 64) & 511;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 64 + 1)) & 511;
+ bx = (bx + (64 + 4 * 64 - 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (512 - 64)) & 511;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 15 --*/
+ coef = iwincoef + 111; /* back pass through coefs */
+ si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
+ bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
+ for (i = 0; i < 15; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 64) & 511;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 64) & 511;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (64 - 1 + 4 * 64)) & 511;
+ bx = (bx + (5 * 64 + 1)) & 511;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void i_windowB16(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void i_windowB16_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void i_windowB16_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+/* right identical to dual, for asm */
+ int i, j;
+ unsigned char si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+
+/*-- first 8 --*/
+ si = (unsigned char) (vb_ptr + 8 + 3 * 32);
+ bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
+ coef = iwincoef;
+ for (i = 0; i < 8; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si += 32;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si += (5 * 32 + 1);
+ bx += (32 + 4 * 32 - 1);
+ coef += 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx += (256 - 32);
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx += 32;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 7 --*/
+ coef = iwincoef + (111 - 7); /* back pass through coefs */
+ si += (256 + -3 * 32 + 2 * 32 - 1);
+ bx += (32 + 3 * 32 + 2 * 32 + 1);
+ for (i = 0; i < 7; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si += 32;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx += 32;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si += (32 - 1 + 4 * 32);
+ bx += (5 * 32 + 1);
+ coef -= 7;
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*------------------- 8 pt window ------------------------------*/
+void i_windowB8(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
+ }
+}
+/*--------------- 8 pt dual window (interleaved output) --------------*/
+void i_windowB8_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*------------------------------------------------------------*/
+/*--------------- 8 pt dual window (interleaved output) --------------*/
+void i_windowB8_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
+{
+ int i, j;
+ unsigned int si, bx;
+ WINCOEF *coef;
+ INT32 sum;
+
+/* right identical to dual, for asm */
+
+/*-- first 4 --*/
+ si = (vb_ptr + (4 + 3 * 16)) & 127;
+ bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
+ coef = iwincoef;
+ for (i = 0; i < 4; i++)
+ {
+ sum = -WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef++));
+ si = (si + 16) & 127;
+ sum -= WINMULT(vbuf[bx], (*coef++));
+ }
+ si = (si + (5 * 16 + 1)) & 127;
+ bx = (bx + (16 + 4 * 16 - 1)) & 127;
+ coef += (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+/*-- special case --*/
+ bx = (bx + (128 - 16)) & 127;
+ sum = WINMULT(vbuf[bx], (*coef++));
+ for (j = 0; j < 3; j++)
+ {
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef++));
+ }
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+
+/*-- last 3 --*/
+ coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
+ si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
+ bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
+ for (i = 0; i < 3; i++)
+ {
+ sum = WINMULT(vbuf[si], (*coef--));
+ for (j = 0; j < 3; j++)
+ {
+ si = (si + 16) & 127;
+ sum += WINMULT(vbuf[bx], (*coef--));
+ bx = (bx + 16) & 127;
+ sum += WINMULT(vbuf[si], (*coef--));
+ }
+ si = (si + (16 - 1 + 4 * 16)) & 127;
+ bx = (bx + (5 * 16 + 1)) & 127;
+ coef -= (3 * 7);
+ sum >>= WINBITS;
+ if (sum > 32767)
+ sum = 32767;
+ else if (sum < -32768)
+ sum = -32768;
+ *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
+ pcm += 2;
+ }
+}
+/*--------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** iwinm.c ***************************************************
+
+MPEG audio decoder, window master
+portable C integer version of cwinm.c
+
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "itype.h"
+
+/*-------------------------------------------------------------------------*/
+/* public vbuf's */
+WININT vbuf[512];
+WININT vbuf2[512];
+
+/*-- integer point window coefs ---*/
+/*-- quick uses only first 116 ----*/
+static WINCOEF iwincoef[264];
+
+/*==================================================================*/
+WINCOEF *i_wincoef_addr()
+{
+ return iwincoef;
+}
+/*-------------------------------------------------------------------*/
+#ifdef FULL_INTEGER
+#include "iwin.c"
+#include "iwinb.c"
+#else
+#include "iwinQ.c"
+#include "iwinbQ.c"
+#endif
+/*-------------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** quant.c ***************************************************
+ Layer III dequant
+
+ does reordering of short blocks
+
+ mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+#include "L3.h"
+#include "mhead.h"
+#include "protos.h"
+
+
+/*----------
+static struct {
+int l[23];
+int s[14];} sfBandTable[3] =
+{{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
+ {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
+{{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
+ {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
+{{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
+ {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
+----------*/
+
+/*--------------------------------*/
+static int 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},
+};
+
+
+/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+/* two extra slots to do 1/sqrt(2) scaling for ms */
+/* 4 extra slots to do 1/2 scaling for cvt to mono */
+
+/*-------- scaling lookup
+x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
+look_scale[scalefact_scale][preemp][scalefac]
+-----------------------*/
+#if 0
+typedef float LS[4][32];
+#endif
+
+/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+
+/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
+
+/*-- reorder buffer ---*/
+typedef float ARRAY3[3];
+
+
+/*=============================================================*/
+float *quant_init_global_addr(MPEG *m)
+{
+ return m->cupl.look_global;
+}
+/*-------------------------------------------------------------*/
+LS *quant_init_scale_addr(MPEG *m)
+{
+ return m->cupl.look_scale;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_pow_addr(MPEG *m)
+{
+ return m->cupl.look_pow;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_subblock_addr(MPEG *m)
+{
+ return m->cupl.look_subblock;
+}
+/*=============================================================*/
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4056)
+#endif
+
+void dequant(MPEG *m, SAMPLE Sample[], int *nsamp,
+ SCALEFACT * sf,
+ GR * gr,
+ CB_INFO * cb_info, int ncbl_mixed)
+{
+ int i, j;
+ int cb, n, w;
+ float x0, xs;
+ float xsb[3];
+ double tmp;
+ int ncbl;
+ int cbs0;
+ ARRAY3 *buf; /* short block reorder */
+ int nbands;
+ int i0;
+ int non_zero;
+ int cbmax[3];
+
+ nbands = *nsamp;
+
+
+ ncbl = 22; /* long block cb end */
+ cbs0 = 12; /* short block cb start */
+/* ncbl_mixed = 8 or 6 mpeg1 or 2 */
+ if (gr->block_type == 2)
+ {
+ ncbl = 0;
+ cbs0 = 0;
+ if (gr->mixed_block_flag)
+ {
+ ncbl = ncbl_mixed;
+ cbs0 = 3;
+ }
+ }
+/* fill in cb_info -- */
+ /* This doesn't seem used anywhere...
+ cb_info->lb_type = gr->block_type;
+ if (gr->block_type == 2)
+ cb_info->lb_type;
+ */
+ cb_info->cbs0 = cbs0;
+ cb_info->ncbl = ncbl;
+
+ cbmax[2] = cbmax[1] = cbmax[0] = 0;
+/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
+ x0 = m->cupl.look_global[(2 + 4) + gr->global_gain];
+ i = 0;
+/*----- long blocks ---*/
+ for (cb = 0; cb < ncbl; cb++)
+ {
+ non_zero = 0;
+ xs = x0 * m->cupl.look_scale[gr->scalefac_scale][pretab[gr->preflag][cb]][sf->l[cb]];
+ n = m->cupl.nBand[0][cb];
+ for (j = 0; j < n; j++, i++)
+ {
+ if (Sample[i].s == 0)
+ Sample[i].x = 0.0F;
+ else
+ {
+ non_zero = 1;
+ if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+ Sample[i].x = xs * m->cupl.look_pow[ISMAX + Sample[i].s];
+ else
+ {
+ float tmpConst = (float)(1.0/3.0);
+ tmp = (double) Sample[i].s;
+ Sample[i].x = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+ }
+ }
+ }
+ if (non_zero)
+ cbmax[0] = cb;
+ if (i >= nbands)
+ break;
+ }
+
+ cb_info->cbmax = cbmax[0];
+ cb_info->cbtype = 0; // type = long
+
+ if (cbs0 >= 12)
+ return;
+/*---------------------------
+block type = 2 short blocks
+----------------------------*/
+ cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
+ i0 = i; /* save for reorder */
+ buf = m->cupl.re_buf;
+ for (w = 0; w < 3; w++)
+ xsb[w] = x0 * m->cupl.look_subblock[gr->subblock_gain[w]];
+ for (cb = cbs0; cb < 13; cb++)
+ {
+ n = m->cupl.nBand[1][cb];
+ for (w = 0; w < 3; w++)
+ {
+ non_zero = 0;
+ xs = xsb[w] * m->cupl.look_scale[gr->scalefac_scale][0][sf->s[w][cb]];
+ for (j = 0; j < n; j++, i++)
+ {
+ if (Sample[i].s == 0)
+ buf[j][w] = 0.0F;
+ else
+ {
+ non_zero = 1;
+ if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+ buf[j][w] = xs * m->cupl.look_pow[ISMAX + Sample[i].s];
+ else
+ {
+ float tmpConst = (float)(1.0/3.0);
+ tmp = (double) Sample[i].s;
+ buf[j][w] = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+ }
+ }
+ }
+ if (non_zero)
+ cbmax[w] = cb;
+ }
+ if (i >= nbands)
+ break;
+ buf += n;
+ }
+
+
+ memmove(&Sample[i0].x, &m->cupl.re_buf[0][0], sizeof(float) * (i - i0));
+
+ *nsamp = i; /* update nsamp */
+ cb_info->cbmax_s[0] = cbmax[0];
+ cb_info->cbmax_s[1] = cbmax[1];
+ cb_info->cbmax_s[2] = cbmax[2];
+ if (cbmax[1] > cbmax[0])
+ cbmax[0] = cbmax[1];
+ if (cbmax[2] > cbmax[0])
+ cbmax[0] = cbmax[2];
+
+ cb_info->cbmax = cbmax[0];
+ cb_info->cbtype = 1; /* type = short */
+
+
+ return;
+}
+
+#ifdef _MSC_VER
+#pragma warning(default: 4056)
+#endif
+
+/*-------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** tinit.c ***************************************************
+ Layer III init tables
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h"
+#include "protos.h"
+
+/* get rid of precision loss warnings on conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+
+
+static const float Ci[8] =
+{
+ -0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f};
+
+
+void hwin_init(MPEG *m); /* hybrid windows -- */
+void imdct_init(MPEG *m);
+typedef struct
+{
+ float *w;
+ float *w2;
+ void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+void msis_init(MPEG *m);
+void msis_init_MPEG2(MPEG *m);
+
+/*=============================================================*/
+int L3table_init(MPEG *m)
+{
+ int i;
+ float *x;
+ LS *ls;
+ int scalefact_scale, preemp, scalefac;
+ double tmp;
+ PAIR *csa;
+
+/*================ quant ===============================*/
+
+/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+/* extra 2 for ms scaling by 1/sqrt(2) */
+/* extra 4 for cvt to mono scaling by 1/2 */
+ x = quant_init_global_addr(m);
+ for (i = 0; i < 256 + 2 + 4; i++)
+ x[i] = (float) pow(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
+
+
+/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+ ls = quant_init_scale_addr(m);
+ for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
+ {
+ for (preemp = 0; preemp < 4; preemp++)
+ {
+ for (scalefac = 0; scalefac < 32; scalefac++)
+ {
+ ls[scalefact_scale][preemp][scalefac] =
+ (float) pow(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
+ }
+ }
+ }
+
+/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+ x = quant_init_pow_addr(m);
+ for (i = 0; i < 64; i++)
+ {
+ tmp = i - 32;
+ x[i] = (float) (tmp * pow(fabs(tmp), (1.0 / 3.0)));
+ }
+
+
+/*-- pow(2.0, -0.25*8.0*subblock_gain) 3 bits --*/
+ x = quant_init_subblock_addr(m);
+ for (i = 0; i < 8; i++)
+ {
+ x[i] = (float) pow(2.0, 0.25 * -8.0 * i);
+ }
+
+/*-------------------------*/
+// quant_init_sf_band(sr_index); replaced by code in sup.c
+
+
+/*================ antialias ===============================*/
+ csa = alias_init_addr(m);
+ for (i = 0; i < 8; i++)
+ {
+ csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
+ csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
+ }
+
+
+/*================ msis ===============================*/
+ msis_init(m);
+ msis_init_MPEG2(m);
+
+/*================ imdct ===============================*/
+ imdct_init(m);
+
+/*--- hybrid windows ------------*/
+ hwin_init(m);
+
+ return 0;
+}
+/*====================================================================*/
+typedef float ARRAY36[36];
+ARRAY36 *hwin_init_addr();
+
+/*--------------------------------------------------------------------*/
+void hwin_init(MPEG *m)
+{
+ int i, j;
+ double pi;
+ ARRAY36 *win;
+
+ win = hwin_init_addr(m);
+
+ pi = 4.0 * atan(1.0);
+
+/* type 0 */
+ for (i = 0; i < 36; i++)
+ win[0][i] = (float) sin(pi / 36 * (i + 0.5));
+
+/* type 1 */
+ for (i = 0; i < 18; i++)
+ win[1][i] = (float) sin(pi / 36 * (i + 0.5));
+ for (i = 18; i < 24; i++)
+ win[1][i] = 1.0F;
+ for (i = 24; i < 30; i++)
+ win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
+ for (i = 30; i < 36; i++)
+ win[1][i] = 0.0F;
+
+/* type 3 */
+ for (i = 0; i < 6; i++)
+ win[3][i] = 0.0F;
+ for (i = 6; i < 12; i++)
+ win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
+ for (i = 12; i < 18; i++)
+ win[3][i] = 1.0F;
+ for (i = 18; i < 36; i++)
+ win[3][i] = (float) sin(pi / 36 * (i + 0.5));
+
+/* type 2 */
+ for (i = 0; i < 12; i++)
+ win[2][i] = (float) sin(pi / 12 * (i + 0.5));
+ for (i = 12; i < 36; i++)
+ win[2][i] = 0.0F;
+
+/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
+ for (j = 0; j < 4; j++)
+ {
+ if (j == 2)
+ continue;
+ for (i = 9; i < 36; i++)
+ win[j][i] = -win[j][i];
+ }
+
+/*-- invert signs for short blocks --*/
+ for (i = 3; i < 12; i++)
+ win[2][i] = -win[2][i];
+
+ return;
+}
+/*=============================================================*/
+typedef float ARRAY4[4];
+IMDCT_INIT_BLOCK *imdct_init_addr_18();
+IMDCT_INIT_BLOCK *imdct_init_addr_6();
+
+/*-------------------------------------------------------------*/
+void imdct_init(MPEG *m)
+{
+ int k, p, n;
+ double t, pi;
+ IMDCT_INIT_BLOCK *addr;
+ float *w, *w2;
+ float *v, *v2, *coef87;
+ ARRAY4 *coef;
+
+/*--- 18 point --*/
+ addr = imdct_init_addr_18();
+ w = addr->w;
+ w2 = addr->w2;
+ coef = addr->coef;
+/*----*/
+ n = 18;
+ pi = 4.0 * atan(1.0);
+ t = pi / (4 * n);
+ for (p = 0; p < n; p++)
+ w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
+ for (p = 0; p < 9; p++)
+ w2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+ t = pi / (2 * n);
+ for (k = 0; k < 9; k++)
+ {
+ for (p = 0; p < 4; p++)
+ coef[k][p] = (float) cos(t * (2 * k) * (2 * p + 1));
+ }
+
+/*--- 6 point */
+ addr = imdct_init_addr_6();
+ v = addr->w;
+ v2 = addr->w2;
+ coef87 = addr->coef;
+/*----*/
+ n = 6;
+ pi = 4.0 * atan(1.0);
+ t = pi / (4 * n);
+ for (p = 0; p < n; p++)
+ v[p] = (float) 2.0 *cos(t * (2 * p + 1));
+
+ for (p = 0; p < 3; p++)
+ v2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+ t = pi / (2 * n);
+ k = 1;
+ p = 0;
+ *coef87 = (float) cos(t * (2 * k) * (2 * p + 1));
+/* adjust scaling to save a few mults */
+ for (p = 0; p < 6; p++)
+ v[p] = v[p] / 2.0f;
+ *coef87 = (float) 2.0 *(*coef87);
+
+
+ return;
+}
+/*===============================================================*/
+typedef float ARRAY8_2[8][2];
+ARRAY8_2 *msis_init_addr(MPEG *m);
+
+/*-------------------------------------------------------------*/
+void msis_init(MPEG *m)
+{
+ int i;
+ double s, c;
+ double pi;
+ double t;
+ ARRAY8_2 *lr;
+
+ lr = msis_init_addr(m);
+
+
+ pi = 4.0 * atan(1.0);
+ t = pi / 12.0;
+ for (i = 0; i < 7; i++)
+ {
+ s = sin(i * t);
+ c = cos(i * t);
+ /* ms_mode = 0 */
+ lr[0][i][0] = (float) (s / (s + c));
+ lr[0][i][1] = (float) (c / (s + c));
+ /* ms_mode = 1 */
+ lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
+ lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
+ }
+/* sf = 7 */
+/* ms_mode = 0 */
+ lr[0][i][0] = 1.0f;
+ lr[0][i][1] = 0.0f;
+/* ms_mode = 1, in is bands is routine does ms processing */
+ lr[1][i][0] = 1.0f;
+ lr[1][i][1] = 1.0f;
+
+
+/*-------
+for(i=0;i<21;i++) nBand[0][i] =
+ sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
+for(i=0;i<12;i++) nBand[1][i] =
+ sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
+-------------*/
+
+}
+/*-------------------------------------------------------------*/
+/*===============================================================*/
+typedef float ARRAY2_64_2[2][64][2];
+ARRAY2_64_2 *msis_init_addr_MPEG2(MPEG *m);
+
+/*-------------------------------------------------------------*/
+void msis_init_MPEG2(MPEG *m)
+{
+ int k, n;
+ double t;
+ ARRAY2_64_2 *lr;
+ int intensity_scale, ms_mode, sf, sflen;
+ float ms_factor[2];
+
+
+ ms_factor[0] = 1.0;
+ ms_factor[1] = (float) sqrt(2.0);
+
+ lr = msis_init_addr_MPEG2(m);
+
+/* intensity stereo MPEG2 */
+/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+
+ for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
+ {
+ t = pow(2.0, -0.25 * (1 + intensity_scale));
+ for (ms_mode = 0; ms_mode < 2; ms_mode++)
+ {
+
+ n = 1;
+ k = 0;
+ for (sflen = 0; sflen < 6; sflen++)
+ {
+ for (sf = 0; sf < (n - 1); sf++, k++)
+ {
+ if (sf == 0)
+ {
+ lr[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+ lr[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+ }
+ else if ((sf & 1))
+ {
+ lr[intensity_scale][ms_mode][k][0] =
+ (float) (ms_factor[ms_mode] * pow(t, (sf + 1) / 2));
+ lr[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+ }
+ else
+ {
+ lr[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+ lr[intensity_scale][ms_mode][k][1] =
+ (float) (ms_factor[ms_mode] * pow(t, sf / 2));
+ }
+ }
+
+ /* illegal is_pos used to do ms processing */
+ if (ms_mode == 0)
+ { /* ms_mode = 0 */
+ lr[intensity_scale][ms_mode][k][0] = 1.0f;
+ lr[intensity_scale][ms_mode][k][1] = 0.0f;
+ }
+ else
+ {
+ /* ms_mode = 1, in is bands is routine does ms processing */
+ lr[intensity_scale][ms_mode][k][0] = 1.0f;
+ lr[intensity_scale][ms_mode][k][1] = 1.0f;
+ }
+ k++;
+ n = n + n;
+ }
+ }
+ }
+
+}
+/*-------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** mdct.c ***************************************************
+
+Layer III
+
+ cos transform for n=18, n=6
+
+computes c[k] = Sum( cos((pi/4*n)*(2*k+1)*(2*p+1))*f[p] )
+ k = 0, ...n-1, p = 0...n-1
+
+
+inplace ok.
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#ifdef ASM_X86
+extern void imdct18_asm(float f[18]);
+extern void imdct6_3_asm(float f[]);
+#endif /* ASM_X86 */
+
+/*------ 18 point xform -------*/
+float mdct18w[18];
+float mdct18w2[9];
+float coef[9][4];
+
+float mdct6_3v[6];
+float mdct6_3v2[3];
+float coef87;
+
+typedef struct
+{
+ float *w;
+ float *w2;
+ void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+static IMDCT_INIT_BLOCK imdct_info_18 =
+{mdct18w, mdct18w2, coef};
+static IMDCT_INIT_BLOCK imdct_info_6 =
+{mdct6_3v, mdct6_3v2, &coef87};
+
+/*====================================================================*/
+IMDCT_INIT_BLOCK *imdct_init_addr_18()
+{
+ return &imdct_info_18;
+}
+IMDCT_INIT_BLOCK *imdct_init_addr_6()
+{
+ return &imdct_info_6;
+}
+/*--------------------------------------------------------------------*/
+void imdct18(float f[18]) /* 18 point */
+{
+#ifdef ASM_X86
+ imdct18_asm(f);
+#else
+ int p;
+ float a[9], b[9];
+ float ap, bp, a8p, b8p;
+ float g1, g2;
+
+
+ for (p = 0; p < 4; p++)
+ {
+ g1 = mdct18w[p] * f[p];
+ g2 = mdct18w[17 - p] * f[17 - p];
+ ap = g1 + g2; // a[p]
+
+ bp = mdct18w2[p] * (g1 - g2); // b[p]
+
+ g1 = mdct18w[8 - p] * f[8 - p];
+ g2 = mdct18w[9 + p] * f[9 + p];
+ a8p = g1 + g2; // a[8-p]
+
+ b8p = mdct18w2[8 - p] * (g1 - g2); // b[8-p]
+
+ a[p] = ap + a8p;
+ a[5 + p] = ap - a8p;
+ b[p] = bp + b8p;
+ b[5 + p] = bp - b8p;
+ }
+ g1 = mdct18w[p] * f[p];
+ g2 = mdct18w[17 - p] * f[17 - p];
+ a[p] = g1 + g2;
+ b[p] = mdct18w2[p] * (g1 - g2);
+
+
+ f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
+ f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
+
+ f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
+ + coef[1][3] * a[8];
+ f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
+ + coef[1][3] * b[8] - f[1];
+ f[1] = f[1] - f[0];
+ f[2] = f[2] - f[1];
+
+ f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
+ + coef[2][3] * a[3] - a[4];
+ f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
+ + coef[2][3] * b[3] - b[4] - f[3];
+ f[3] = f[3] - f[2];
+ f[4] = f[4] - f[3];
+
+ f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
+ f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
+ f[5] = f[5] - f[4];
+ f[6] = f[6] - f[5];
+
+ f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
+ + coef[4][3] * a[3] + a[4];
+ f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
+ + coef[4][3] * b[3] + b[4] - f[7];
+ f[7] = f[7] - f[6];
+ f[8] = f[8] - f[7];
+
+ f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
+ + coef[5][3] * a[8];
+ f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
+ + coef[5][3] * b[8] - f[9];
+ f[9] = f[9] - f[8];
+ f[10] = f[10] - f[9];
+
+ f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
+ f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
+ f[11] = f[11] - f[10];
+ f[12] = f[12] - f[11];
+
+ f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
+ + coef[7][3] * a[8];
+ f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
+ + coef[7][3] * b[8] - f[13];
+ f[13] = f[13] - f[12];
+ f[14] = f[14] - f[13];
+
+ f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
+ + coef[8][3] * a[3] + a[4];
+ f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
+ + coef[8][3] * b[3] + b[4] - f[15];
+ f[15] = f[15] - f[14];
+ f[16] = f[16] - f[15];
+ f[17] = f[17] - f[16];
+
+
+ return;
+#endif
+}
+/*--------------------------------------------------------------------*/
+/* does 3, 6 pt dct. changes order from f[i][window] c[window][i] */
+void imdct6_3(float f[]) /* 6 point */
+{
+#ifdef ASM_X86
+ imdct6_3_asm(f);
+#else
+ int w;
+ float buf[18];
+ float *a, *c; // b[i] = a[3+i]
+
+ float g1, g2;
+ float a02, b02;
+
+ c = f;
+ a = buf;
+ for (w = 0; w < 3; w++)
+ {
+ g1 = mdct6_3v[0] * f[3 * 0];
+ g2 = mdct6_3v[5] * f[3 * 5];
+ a[0] = g1 + g2;
+ a[3 + 0] = mdct6_3v2[0] * (g1 - g2);
+
+ g1 = mdct6_3v[1] * f[3 * 1];
+ g2 = mdct6_3v[4] * f[3 * 4];
+ a[1] = g1 + g2;
+ a[3 + 1] = mdct6_3v2[1] * (g1 - g2);
+
+ g1 = mdct6_3v[2] * f[3 * 2];
+ g2 = mdct6_3v[3] * f[3 * 3];
+ a[2] = g1 + g2;
+ a[3 + 2] = mdct6_3v2[2] * (g1 - g2);
+
+ a += 6;
+ f++;
+ }
+
+ a = buf;
+ for (w = 0; w < 3; w++)
+ {
+ a02 = (a[0] + a[2]);
+ b02 = (a[3 + 0] + a[3 + 2]);
+ c[0] = a02 + a[1];
+ c[1] = b02 + a[3 + 1];
+ c[2] = coef87 * (a[0] - a[2]);
+ c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
+ c[1] = c[1] - c[0];
+ c[2] = c[2] - c[1];
+ c[4] = a02 - a[1] - a[1];
+ c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
+ c[3] = c[3] - c[2];
+ c[4] = c[4] - c[3];
+ c[5] = c[5] - c[4];
+ a += 6;
+ c += 6;
+ }
+
+ return;
+#endif
+}
+/*--------------------------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*------------ mhead.c ----------------------------------------------
+ mpeg audio
+ extract info from mpeg header
+ portable version (adapted from c:\eco\mhead.c
+
+ add Layer III
+
+ mods 6/18/97 re mux restart, 32 bit ints
+
+ mod 5/7/98 parse mpeg 2.5
+
+---------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h" /* mpeg header structure */
+
+static int mp_br_table[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}};
+static int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+
+static int mp_br_tableL1[2][16] =
+{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},/* mpeg2 */
+ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0}};
+
+static int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}, /* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+
+
+static int find_sync(unsigned char *buf, int n);
+static int sync_scan(unsigned char *buf, int n, int i0);
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes);
+
+// jdw
+extern unsigned int g_jdw_additional;
+
+/*--------------------------------------------------------------*/
+int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h)
+{
+ int framebytes;
+ int mpeg25_flag;
+
+ if (n > 10000)
+ n = 10000; /* limit scan for free format */
+
+
+
+ h->sync = 0;
+ //if ((buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xF0))
+ if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xF0))
+ {
+ mpeg25_flag = 0; // mpeg 1 & 2
+
+ }
+ else if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xE0))
+ {
+ mpeg25_flag = 1; // mpeg 2.5
+
+ }
+ else
+ return 0; // sync fail
+
+ h->sync = 1;
+ if (mpeg25_flag)
+ h->sync = 2; //low bit clear signals mpeg25 (as in 0xFFE)
+
+ h->id = (buf[0+1] & 0x08) >> 3;
+ h->option = (buf[0+1] & 0x06) >> 1;
+ h->prot = (buf[0+1] & 0x01);
+
+ h->br_index = (buf[0+2] & 0xf0) >> 4;
+ h->sr_index = (buf[0+2] & 0x0c) >> 2;
+ h->pad = (buf[0+2] & 0x02) >> 1;
+ h->private_bit = (buf[0+2] & 0x01);
+ h->mode = (buf[0+3] & 0xc0) >> 6;
+ h->mode_ext = (buf[0+3] & 0x30) >> 4;
+ h->cr = (buf[0+3] & 0x08) >> 3;
+ h->original = (buf[0+3] & 0x04) >> 2;
+ h->emphasis = (buf[0+3] & 0x03);
+
+
+// if( mpeg25_flag ) {
+ // if( h->sr_index == 2 ) return 0; // fail 8khz
+ //}
+
+
+/* compute framebytes for Layer I, II, III */
+ if (h->option < 1)
+ return 0;
+ if (h->option > 3)
+ return 0;
+
+ framebytes = 0;
+
+ if (h->br_index > 0)
+ {
+ if (h->option == 3)
+ { /* layer I */
+ framebytes =
+ 240 * mp_br_tableL1[h->id][h->br_index]
+ / mp_sr20_table[h->id][h->sr_index];
+ framebytes = 4 * framebytes;
+ }
+ else if (h->option == 2)
+ { /* layer II */
+ framebytes =
+ 2880 * mp_br_table[h->id][h->br_index]
+ / mp_sr20_table[h->id][h->sr_index];
+ }
+ else if (h->option == 1)
+ { /* layer III */
+ if (h->id)
+ { // mpeg1
+
+ framebytes =
+ 2880 * mp_br_tableL3[h->id][h->br_index]
+ / mp_sr20_table[h->id][h->sr_index];
+ }
+ else
+ { // mpeg2
+
+ if (mpeg25_flag)
+ { // mpeg2.2
+
+ framebytes =
+ 2880 * mp_br_tableL3[h->id][h->br_index]
+ / mp_sr20_table[h->id][h->sr_index];
+ }
+ else
+ {
+ framebytes =
+ 1440 * mp_br_tableL3[h->id][h->br_index]
+ / mp_sr20_table[h->id][h->sr_index];
+ }
+ }
+ }
+ }
+ else
+ framebytes = find_sync(buf, n); /* free format */
+
+ return framebytes;
+}
+
+int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int *br, unsigned int *searchForward) {
+ unsigned int pBuf = 0;
+ // jdw insertion...
+ while ((pBuf < n) && !((buf[pBuf] == 0xFF) &&
+ ((buf[pBuf+1] & 0xF0) == 0xF0 || (buf[pBuf+1] & 0xF0) == 0xE0)))
+ {
+ pBuf++;
+ }
+
+ if (pBuf == n) return 0;
+
+ *searchForward = pBuf;
+ return head_info2(&(buf[pBuf]),n,h,br);
+
+}
+
+/*--------------------------------------------------------------*/
+int head_info2(unsigned char *buf, unsigned int n, MPEG_HEAD * h, int *br)
+{
+ int framebytes;
+
+/*--- return br (in bits/sec) in addition to frame bytes ---*/
+
+ *br = 0;
+/*-- assume fail --*/
+ framebytes = head_info(buf, n, h);
+
+ if (framebytes == 0)
+ return 0;
+
+ if (h->option == 1)
+ { /* layer III */
+ if (h->br_index > 0)
+ *br = 1000 * mp_br_tableL3[h->id][h->br_index];
+ else
+ {
+ if (h->id) // mpeg1
+
+ *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (144 * 20);
+ else
+ { // mpeg2
+
+ if ((h->sync & 1) == 0) // flags mpeg25
+
+ *br = 500 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+ else
+ *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+ }
+ }
+ }
+ if (h->option == 2)
+ { /* layer II */
+ if (h->br_index > 0)
+ *br = 1000 * mp_br_table[h->id][h->br_index];
+ else
+ *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]
+ / (144 * 20);
+ }
+ if (h->option == 3)
+ { /* layer I */
+ if (h->br_index > 0)
+ *br = 1000 * mp_br_tableL1[h->id][h->br_index];
+ else
+ *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]
+ / (48 * 20);
+ }
+
+
+ return framebytes;
+}
+/*--------------------------------------------------------------*/
+static int compare(unsigned char *buf, unsigned char *buf2)
+{
+ if (buf[0] != buf2[0])
+ return 0;
+ if (buf[1] != buf2[1])
+ return 0;
+ return 1;
+}
+/*----------------------------------------------------------*/
+/*-- does not scan for initial sync, initial sync assumed --*/
+static int find_sync(unsigned char *buf, int n)
+{
+ int i0, isync, nmatch, pad;
+ int padbytes, option;
+
+/* mod 4/12/95 i0 change from 72, allows as low as 8kbits for mpeg1 */
+ i0 = 24;
+ padbytes = 1;
+ option = (buf[1] & 0x06) >> 1;
+ if (option == 3)
+ {
+ padbytes = 4;
+ i0 = 24; /* for shorter layer I frames */
+ }
+
+ pad = (buf[2] & 0x02) >> 1;
+
+ n -= 3; /* need 3 bytes of header */
+
+ while (i0 < 2000)
+ {
+ isync = sync_scan(buf, n, i0);
+ i0 = isync + 1;
+ isync -= pad;
+ if (isync <= 0)
+ return 0;
+ nmatch = sync_test(buf, n, isync, padbytes);
+ if (nmatch > 0)
+ return isync;
+ }
+
+ return 0;
+}
+/*------------------------------------------------------*/
+/*---- scan for next sync, assume start is valid -------*/
+/*---- return number bytes to next sync ----------------*/
+static int sync_scan(unsigned char *buf, int n, int i0)
+{
+ int i;
+
+ for (i = i0; i < n; i++)
+ if (compare(buf, buf + i))
+ return i;
+
+ return 0;
+}
+/*------------------------------------------------------*/
+/*- test consecutative syncs, input isync without pad --*/
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes)
+{
+ int i, nmatch, pad;
+
+ nmatch = 0;
+ for (i = 0;;)
+ {
+ pad = padbytes * ((buf[i + 2] & 0x02) >> 1);
+ i += (pad + isync);
+ if (i > n)
+ break;
+ if (!compare(buf, buf + i))
+ return -nmatch;
+ nmatch++;
+ }
+ return nmatch;
+}
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** msis.c ***************************************************
+ Layer III
+ antialias, ms and is stereo precessing
+
+**** is_process assumes never switch
+ from short to long in is region *****
+
+is_process does ms or stereo in "forbidded sf regions"
+ //ms_mode = 0
+ lr[0][i][0] = 1.0f;
+ lr[0][i][1] = 0.0f;
+ // ms_mode = 1, in is bands is routine does ms processing
+ lr[1][i][0] = 1.0f;
+ lr[1][i][1] = 1.0f;
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+#include "mhead.h"
+
+/* The functions are different than their prototypes, by design */
+
+typedef float ARRAY2[2];
+typedef float ARRAY8_2[8][2];
+
+
+/* nBand[0] = long, nBand[1] = short */
+
+/* intensity stereo */
+/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
+ compensates */
+
+
+/* intensity stereo MPEG2 */
+/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+typedef float ARRAY2_64_2[2][64][2];
+typedef float ARRAY64_2[64][2];
+
+#ifdef ASM_X86
+extern void antialias_asm(float x[], int n);
+#endif /* ASM_X86 */
+
+
+/*===============================================================*/
+ARRAY2 *alias_init_addr(MPEG *m)
+{
+ return m->cupl.csa;
+}
+/*-----------------------------------------------------------*/
+ARRAY8_2 *msis_init_addr(MPEG *m)
+{
+/*-------
+pi = 4.0*atan(1.0);
+t = pi/12.0;
+for(i=0;i<7;i++) {
+ s = sin(i*t);
+ c = cos(i*t);
+ // ms_mode = 0
+ m->cupl.lr[0][i][0] = (float)(s/(s+c));
+ m->cupl.lr[0][i][1] = (float)(c/(s+c));
+ // ms_mode = 1
+ m->cupl.lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
+ m->cupl.lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
+}
+//sf = 7
+//ms_mode = 0
+m->cupl.lr[0][i][0] = 1.0f;
+m->cupl.lr[0][i][1] = 0.0f;
+// ms_mode = 1, in is bands is routine does ms processing
+m->cupl.lr[1][i][0] = 1.0f;
+m->cupl.lr[1][i][1] = 1.0f;
+------------*/
+
+ return m->cupl.lr;
+}
+/*-------------------------------------------------------------*/
+ARRAY2_64_2 *msis_init_addr_MPEG2(MPEG *m)
+{
+ return m->cupl.lr2;
+}
+/*===============================================================*/
+void antialias(MPEG *m, float x[], int n)
+{
+#ifdef ASM_X86
+ antialias_asm(x, n);
+#else
+ int i, k;
+ float a, b;
+
+ for (k = 0; k < n; k++)
+ {
+ for (i = 0; i < 8; i++)
+ {
+ a = x[17 - i];
+ b = x[18 + i];
+ x[17 - i] = a * m->cupl.csa[i][0] - b * m->cupl.csa[i][1];
+ x[18 + i] = b * m->cupl.csa[i][0] + a * m->cupl.csa[i][1];
+ }
+ x += 18;
+ }
+#endif
+}
+/*===============================================================*/
+void ms_process(float x[][1152], int n) /* sum-difference stereo */
+{
+ int i;
+ float xl, xr;
+
+/*-- note: sqrt(2) done scaling by dequant ---*/
+ for (i = 0; i < n; i++)
+ {
+ xl = x[0][i] + x[1][i];
+ xr = x[0][i] - x[1][i];
+ x[0][i] = xl;
+ x[1][i] = xr;
+ }
+ return;
+}
+/*===============================================================*/
+void is_process_MPEG1(MPEG *vm, float x[][1152], /* intensity stereo */
+ SCALEFACT * sf,
+ CB_INFO cb_info[2], /* [ch] */
+ int nsamp, int ms_mode)
+{
+ int i, j, n, cb, w;
+ float fl, fr;
+ int m;
+ int isf;
+ float fls[3], frs[3];
+ int cb0;
+
+
+ cb0 = cb_info[1].cbmax; /* start at end of right */
+ i = vm->cupl.sfBandIndex[cb_info[1].cbtype][cb0];
+ cb0++;
+ m = nsamp - i; /* process to len of left */
+
+ if (cb_info[1].cbtype)
+ goto short_blocks;
+/*------------------------*/
+/* long_blocks: */
+ for (cb = cb0; cb < 21; cb++)
+ {
+ isf = sf->l[cb];
+ n = vm->cupl.nBand[0][cb];
+ fl = vm->cupl.lr[ms_mode][isf][0];
+ fr = vm->cupl.lr[ms_mode][isf][1];
+ for (j = 0; j < n; j++, i++)
+ {
+ if (--m < 0)
+ goto exit;
+ x[1][i] = fr * x[0][i];
+ x[0][i] = fl * x[0][i];
+ }
+ }
+ return;
+/*------------------------*/
+ short_blocks:
+ for (cb = cb0; cb < 12; cb++)
+ {
+ for (w = 0; w < 3; w++)
+ {
+ isf = sf->s[w][cb];
+ fls[w] = vm->cupl.lr[ms_mode][isf][0];
+ frs[w] = vm->cupl.lr[ms_mode][isf][1];
+ }
+ n = vm->cupl.nBand[1][cb];
+ for (j = 0; j < n; j++)
+ {
+ m -= 3;
+ if (m < 0)
+ goto exit;
+ x[1][i] = frs[0] * x[0][i];
+ x[0][i] = fls[0] * x[0][i];
+ x[1][1 + i] = frs[1] * x[0][1 + i];
+ x[0][1 + i] = fls[1] * x[0][1 + i];
+ x[1][2 + i] = frs[2] * x[0][2 + i];
+ x[0][2 + i] = fls[2] * x[0][2 + i];
+ i += 3;
+ }
+ }
+
+ exit:
+ return;
+}
+/*===============================================================*/
+void is_process_MPEG2(MPEG *vm, float x[][1152], /* intensity stereo */
+ SCALEFACT * sf,
+ CB_INFO cb_info[2], /* [ch] */
+ IS_SF_INFO * is_sf_info,
+ int nsamp, int ms_mode)
+{
+ int i, j, k, n, cb, w;
+ float fl, fr;
+ int m;
+ int isf;
+ int il[21];
+ int tmp;
+ int r;
+ ARRAY2 *lr;
+ int cb0, cb1;
+
+ lr = vm->cupl.lr2[is_sf_info->intensity_scale][ms_mode];
+
+ if (cb_info[1].cbtype)
+ goto short_blocks;
+
+/*------------------------*/
+/* long_blocks: */
+ cb0 = cb_info[1].cbmax; /* start at end of right */
+ i = vm->cupl.sfBandIndex[0][cb0];
+ m = nsamp - i; /* process to len of left */
+/* gen sf info */
+ for (k = r = 0; r < 3; r++)
+ {
+ tmp = (1 << is_sf_info->slen[r]) - 1;
+ for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+ il[k] = tmp;
+ }
+ for (cb = cb0 + 1; cb < 21; cb++)
+ {
+ isf = il[cb] + sf->l[cb];
+ fl = lr[isf][0];
+ fr = lr[isf][1];
+ n = vm->cupl.nBand[0][cb];
+ for (j = 0; j < n; j++, i++)
+ {
+ if (--m < 0)
+ goto exit;
+ x[1][i] = fr * x[0][i];
+ x[0][i] = fl * x[0][i];
+ }
+ }
+ return;
+/*------------------------*/
+ short_blocks:
+
+ for (k = r = 0; r < 3; r++)
+ {
+ tmp = (1 << is_sf_info->slen[r]) - 1;
+ for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+ il[k] = tmp;
+ }
+
+ for (w = 0; w < 3; w++)
+ {
+ cb0 = cb_info[1].cbmax_s[w]; /* start at end of right */
+ i = vm->cupl.sfBandIndex[1][cb0] + w;
+ cb1 = cb_info[0].cbmax_s[w]; /* process to end of left */
+
+ for (cb = cb0 + 1; cb <= cb1; cb++)
+ {
+ isf = il[cb] + sf->s[w][cb];
+ fl = lr[isf][0];
+ fr = lr[isf][1];
+ n = vm->cupl.nBand[1][cb];
+ for (j = 0; j < n; j++)
+ {
+ x[1][i] = fr * x[0][i];
+ x[0][i] = fl * x[0][i];
+ i += 3;
+ }
+ }
+
+ }
+
+ exit:
+ return;
+}
+/*===============================================================*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** uph.c ***************************************************
+
+Layer 3 audio
+ huffman decode
+
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "L3.h"
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4505)
+#endif
+
+/*===============================================================*/
+
+/* max bits required for any lookup - change if htable changes */
+/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
+#define MAXBITS 9
+
+static HUFF_ELEMENT huff_table_0[4] =
+{{0}, {0}, {0}, {64}}; /* dummy must not use */
+
+#include "htable.h"
+
+/*-- 6 bit lookup (purgebits, value) --*/
+static unsigned char quad_table_a[][2] =
+{
+ {6, 11}, {6, 15}, {6, 13}, {6, 14}, {6, 7}, {6, 5}, {5, 9},
+ {5, 9}, {5, 6}, {5, 6}, {5, 3}, {5, 3}, {5, 10}, {5, 10},
+ {5, 12}, {5, 12}, {4, 2}, {4, 2}, {4, 2}, {4, 2}, {4, 1},
+ {4, 1}, {4, 1}, {4, 1}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
+ {4, 8}, {4, 8}, {4, 8}, {4, 8}, {1, 0}, {1, 0}, {1, 0},
+ {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+ {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+ {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+ {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+ {1, 0},
+};
+
+
+typedef struct
+{
+ HUFF_ELEMENT *table;
+ int linbits;
+ int ncase;
+}
+HUFF_SETUP;
+
+#define no_bits 0
+#define one_shot 1
+#define no_linbits 2
+#define have_linbits 3
+#define quad_a 4
+#define quad_b 5
+
+
+static HUFF_SETUP table_look[] =
+{
+ {huff_table_0, 0, no_bits},
+ {huff_table_1, 0, one_shot},
+ {huff_table_2, 0, one_shot},
+ {huff_table_3, 0, one_shot},
+ {huff_table_0, 0, no_bits},
+ {huff_table_5, 0, one_shot},
+ {huff_table_6, 0, one_shot},
+ {huff_table_7, 0, no_linbits},
+ {huff_table_8, 0, no_linbits},
+ {huff_table_9, 0, no_linbits},
+ {huff_table_10, 0, no_linbits},
+ {huff_table_11, 0, no_linbits},
+ {huff_table_12, 0, no_linbits},
+ {huff_table_13, 0, no_linbits},
+ {huff_table_0, 0, no_bits},
+ {huff_table_15, 0, no_linbits},
+ {huff_table_16, 1, have_linbits},
+ {huff_table_16, 2, have_linbits},
+ {huff_table_16, 3, have_linbits},
+ {huff_table_16, 4, have_linbits},
+ {huff_table_16, 6, have_linbits},
+ {huff_table_16, 8, have_linbits},
+ {huff_table_16, 10, have_linbits},
+ {huff_table_16, 13, have_linbits},
+ {huff_table_24, 4, have_linbits},
+ {huff_table_24, 5, have_linbits},
+ {huff_table_24, 6, have_linbits},
+ {huff_table_24, 7, have_linbits},
+ {huff_table_24, 8, have_linbits},
+ {huff_table_24, 9, have_linbits},
+ {huff_table_24, 11, have_linbits},
+ {huff_table_24, 13, have_linbits},
+ {huff_table_0, 0, quad_a},
+ {huff_table_0, 0, quad_b},
+};
+
+/*========================================================*/
+extern BITDAT bitdat;
+
+/*------------- get n bits from bitstream -------------*/
+/* unused
+static unsigned int bitget(int n)
+{
+ unsigned int x;
+
+ if (bitdat.bits < n)
+ { */ /* refill bit buf if necessary */
+/* while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+ bitdat.bits -= n;
+ x = bitdat.bitbuf >> bitdat.bits;
+ bitdat.bitbuf -= x << bitdat.bits;
+ return x;
+}
+*/
+/*----- get n bits - checks for n+2 avail bits (linbits+sign) -----*/
+static unsigned int bitget_lb(int n)
+{
+ unsigned int x;
+
+ if (bitdat.bits < (n + 2))
+ { /* refill bit buf if necessary */
+ while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+ bitdat.bits -= n;
+ x = bitdat.bitbuf >> bitdat.bits;
+ bitdat.bitbuf -= x << bitdat.bits;
+ return x;
+}
+
+
+
+
+/*------------- get n bits but DO NOT remove from bitstream --*/
+static unsigned int bitget2(int n)
+{
+ unsigned int x;
+
+ if (bitdat.bits < (MAXBITS + 2))
+ { /* refill bit buf if necessary */
+ while (bitdat.bits <= 24)
+ {
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+ bitdat.bits += 8;
+ }
+ }
+ x = bitdat.bitbuf >> (bitdat.bits - n);
+ return x;
+}
+/*------------- remove n bits from bitstream ---------*/
+/* unused
+static void bitget_purge(int n)
+{
+ bitdat.bits -= n;
+ bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+}
+*/
+/*------------- get 1 bit from bitstream NO CHECK -------------*/
+/* unused
+static unsigned int bitget_1bit()
+{
+ unsigned int x;
+
+ bitdat.bits--;
+ x = bitdat.bitbuf >> bitdat.bits;
+ bitdat.bitbuf -= x << bitdat.bits;
+ return x;
+}
+*/
+/*========================================================*/
+/*========================================================*/
+#define mac_bitget_check(n) if( bitdat.bits < (n) ) { \
+ while( bitdat.bits <= 24 ) { \
+ bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++; \
+ bitdat.bits += 8; \
+ } \
+}
+/*---------------------------------------------------------*/
+#define mac_bitget2(n) (bitdat.bitbuf >> (bitdat.bits-n));
+/*---------------------------------------------------------*/
+#define mac_bitget(n) ( bitdat.bits -= n, \
+ code = bitdat.bitbuf >> bitdat.bits, \
+ bitdat.bitbuf -= code << bitdat.bits, \
+ code )
+/*---------------------------------------------------------*/
+#define mac_bitget_purge(n) bitdat.bits -= n, \
+ bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+/*---------------------------------------------------------*/
+#define mac_bitget_1bit() ( bitdat.bits--, \
+ code = bitdat.bitbuf >> bitdat.bits, \
+ bitdat.bitbuf -= code << bitdat.bits, \
+ code )
+/*========================================================*/
+/*========================================================*/
+void unpack_huff(int xy[][2], int n, int ntable)
+{
+ int i;
+ HUFF_ELEMENT *t;
+ HUFF_ELEMENT *t0;
+ int linbits;
+ int bits;
+ int code;
+ int x, y;
+
+ if (n <= 0)
+ return;
+ n = n >> 1; /* huff in pairs */
+/*-------------*/
+ t0 = table_look[ntable].table;
+ linbits = table_look[ntable].linbits;
+ switch (table_look[ntable].ncase)
+ {
+ default:
+/*------------------------------------------*/
+ case no_bits:
+/*- table 0, no data, x=y=0--*/
+ for (i = 0; i < n; i++)
+ {
+ xy[i][0] = 0;
+ xy[i][1] = 0;
+ }
+ return;
+/*------------------------------------------*/
+ case one_shot:
+/*- single lookup, no escapes -*/
+ for (i = 0; i < n; i++)
+ {
+ mac_bitget_check((MAXBITS + 2));
+ bits = t0[0].b.signbits;
+ code = mac_bitget2(bits);
+ mac_bitget_purge(t0[1 + code].b.purgebits);
+ x = t0[1 + code].b.x;
+ y = t0[1 + code].b.y;
+ if (x)
+ if (mac_bitget_1bit())
+ x = -x;
+ if (y)
+ if (mac_bitget_1bit())
+ y = -y;
+ xy[i][0] = x;
+ xy[i][1] = y;
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ break; // bad data protect
+
+ }
+ return;
+/*------------------------------------------*/
+ case no_linbits:
+ for (i = 0; i < n; i++)
+ {
+ t = t0;
+ for (;;)
+ {
+ mac_bitget_check((MAXBITS + 2));
+ bits = t[0].b.signbits;
+ code = mac_bitget2(bits);
+ if (t[1 + code].b.purgebits)
+ break;
+ t += t[1 + code].ptr; /* ptr include 1+code */
+ mac_bitget_purge(bits);
+ }
+ mac_bitget_purge(t[1 + code].b.purgebits);
+ x = t[1 + code].b.x;
+ y = t[1 + code].b.y;
+ if (x)
+ if (mac_bitget_1bit())
+ x = -x;
+ if (y)
+ if (mac_bitget_1bit())
+ y = -y;
+ xy[i][0] = x;
+ xy[i][1] = y;
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ break; // bad data protect
+
+ }
+ return;
+/*------------------------------------------*/
+ case have_linbits:
+ for (i = 0; i < n; i++)
+ {
+ t = t0;
+ for (;;)
+ {
+ bits = t[0].b.signbits;
+ code = bitget2(bits);
+ if (t[1 + code].b.purgebits)
+ break;
+ t += t[1 + code].ptr; /* ptr includes 1+code */
+ mac_bitget_purge(bits);
+ }
+ mac_bitget_purge(t[1 + code].b.purgebits);
+ x = t[1 + code].b.x;
+ y = t[1 + code].b.y;
+ if (x == 15)
+ x += bitget_lb(linbits);
+ if (x)
+ if (mac_bitget_1bit())
+ x = -x;
+ if (y == 15)
+ y += bitget_lb(linbits);
+ if (y)
+ if (mac_bitget_1bit())
+ y = -y;
+ xy[i][0] = x;
+ xy[i][1] = y;
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ break; // bad data protect
+
+ }
+ return;
+ }
+/*--- end switch ---*/
+
+}
+/*==========================================================*/
+int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable)
+{
+ int i;
+ int code;
+ int x, y, v, w;
+ int tmp;
+ int i_non_zero, tmp_nz;
+
+ tmp_nz = 15;
+ i_non_zero = -1;
+
+ n = n >> 2; /* huff in quads */
+
+ if (ntable)
+ goto case_quad_b;
+
+/* case_quad_a: */
+ for (i = 0; i < n; i++)
+ {
+ if (nbits <= 0)
+ break;
+ mac_bitget_check(10);
+ code = mac_bitget2(6);
+ nbits -= quad_table_a[code][0];
+ mac_bitget_purge(quad_table_a[code][0]);
+ tmp = quad_table_a[code][1];
+ if (tmp)
+ {
+ i_non_zero = i;
+ tmp_nz = tmp;
+ }
+ v = (tmp >> 3) & 1;
+ w = (tmp >> 2) & 1;
+ x = (tmp >> 1) & 1;
+ y = tmp & 1;
+ if (v)
+ {
+ if (mac_bitget_1bit())
+ v = -v;
+ nbits--;
+ }
+ if (w)
+ {
+ if (mac_bitget_1bit())
+ w = -w;
+ nbits--;
+ }
+ if (x)
+ {
+ if (mac_bitget_1bit())
+ x = -x;
+ nbits--;
+ }
+ if (y)
+ {
+ if (mac_bitget_1bit())
+ y = -y;
+ nbits--;
+ }
+ vwxy[i][0] = v;
+ vwxy[i][1] = w;
+ vwxy[i][2] = x;
+ vwxy[i][3] = y;
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ break; // bad data protect
+
+ }
+ if (nbits < 0)
+ {
+ i--;
+ vwxy[i][0] = 0;
+ vwxy[i][1] = 0;
+ vwxy[i][2] = 0;
+ vwxy[i][3] = 0;
+ }
+
+ i_non_zero = (i_non_zero + 1) << 2;
+
+ if ((tmp_nz & 3) == 0)
+ i_non_zero -= 2;
+
+ return i_non_zero;
+
+/*--------------------*/
+ case_quad_b:
+ for (i = 0; i < n; i++)
+ {
+ if (nbits < 4)
+ break;
+ nbits -= 4;
+ mac_bitget_check(8);
+ tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */
+ if (tmp)
+ {
+ i_non_zero = i;
+ tmp_nz = tmp;
+ }
+ v = (tmp >> 3) & 1;
+ w = (tmp >> 2) & 1;
+ x = (tmp >> 1) & 1;
+ y = tmp & 1;
+ if (v)
+ {
+ if (mac_bitget_1bit())
+ v = -v;
+ nbits--;
+ }
+ if (w)
+ {
+ if (mac_bitget_1bit())
+ w = -w;
+ nbits--;
+ }
+ if (x)
+ {
+ if (mac_bitget_1bit())
+ x = -x;
+ nbits--;
+ }
+ if (y)
+ {
+ if (mac_bitget_1bit())
+ y = -y;
+ nbits--;
+ }
+ vwxy[i][0] = v;
+ vwxy[i][1] = w;
+ vwxy[i][2] = x;
+ vwxy[i][3] = y;
+ if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+ break; // bad data protect
+
+ }
+ if (nbits < 0)
+ {
+ i--;
+ vwxy[i][0] = 0;
+ vwxy[i][1] = 0;
+ vwxy[i][2] = 0;
+ vwxy[i][3] = 0;
+ }
+
+ i_non_zero = (i_non_zero + 1) << 2;
+
+ if ((tmp_nz & 3) == 0)
+ i_non_zero -= 2;
+
+ return i_non_zero; /* return non-zero sample (to nearest pair) */
+
+}
+/*-----------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/**** upsf.c ***************************************************
+
+Layer III
+ unpack scale factors
+
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+extern int iframe;
+
+unsigned int bitget(int n);
+
+/*------------------------------------------------------------*/
+static const int slen_table[16][2] =
+{
+ {0, 0}, {0, 1},
+ {0, 2}, {0, 3},
+ {3, 0}, {1, 1},
+ {1, 2}, {1, 3},
+ {2, 1}, {2, 2},
+ {2, 3}, {3, 1},
+ {3, 2}, {3, 3},
+ {4, 2}, {4, 3},
+};
+
+/* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
+/* for bt=2 nr is count for group of 3 */
+static const int nr_table[6][3][4] =
+{
+ {{6, 5, 5, 5},
+ {3, 3, 3, 3},
+ {6, 3, 3, 3}},
+
+ {{6, 5, 7, 3},
+ {3, 3, 4, 2},
+ {6, 3, 4, 2}},
+
+ {{11, 10, 0, 0},
+ {6, 6, 0, 0},
+ {6, 3, 6, 0}}, /* adjusted *//* 15, 18, 0, 0, */
+/*-intensity stereo right chan--*/
+ {{7, 7, 7, 0},
+ {4, 4, 4, 0},
+ {6, 5, 4, 0}},
+
+ {{6, 6, 6, 3},
+ {4, 3, 3, 2},
+ {6, 4, 3, 2}},
+
+ {{8, 8, 5, 0},
+ {5, 4, 3, 0},
+ {6, 6, 3, 0}},
+};
+
+/*=============================================================*/
+void unpack_sf_sub_MPEG1(SCALEFACT sf[],
+ GR * grdat,
+ int scfsi, /* bit flag */
+ int gr)
+{
+ int sfb;
+ int slen0, slen1;
+ int block_type, mixed_block_flag, scalefac_compress;
+
+
+ block_type = grdat->block_type;
+ mixed_block_flag = grdat->mixed_block_flag;
+ scalefac_compress = grdat->scalefac_compress;
+
+ slen0 = slen_table[scalefac_compress][0];
+ slen1 = slen_table[scalefac_compress][1];
+
+
+ if (block_type == 2)
+ {
+ if (mixed_block_flag)
+ { /* mixed */
+ for (sfb = 0; sfb < 8; sfb++)
+ sf[0].l[sfb] = bitget(slen0);
+ for (sfb = 3; sfb < 6; sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen0);
+ sf[0].s[1][sfb] = bitget(slen0);
+ sf[0].s[2][sfb] = bitget(slen0);
+ }
+ for (sfb = 6; sfb < 12; sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen1);
+ sf[0].s[1][sfb] = bitget(slen1);
+ sf[0].s[2][sfb] = bitget(slen1);
+ }
+ return;
+ }
+ for (sfb = 0; sfb < 6; sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen0);
+ sf[0].s[1][sfb] = bitget(slen0);
+ sf[0].s[2][sfb] = bitget(slen0);
+ }
+ for (; sfb < 12; sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen1);
+ sf[0].s[1][sfb] = bitget(slen1);
+ sf[0].s[2][sfb] = bitget(slen1);
+ }
+ return;
+ }
+
+/* long blocks types 0 1 3, first granule */
+ if (gr == 0)
+ {
+ for (sfb = 0; sfb < 11; sfb++)
+ sf[0].l[sfb] = bitget(slen0);
+ for (; sfb < 21; sfb++)
+ sf[0].l[sfb] = bitget(slen1);
+ return;
+ }
+
+/* long blocks 0, 1, 3, second granule */
+ sfb = 0;
+ if (scfsi & 8)
+ for (; sfb < 6; sfb++)
+ sf[0].l[sfb] = sf[-2].l[sfb];
+ else
+ for (; sfb < 6; sfb++)
+ sf[0].l[sfb] = bitget(slen0);
+ if (scfsi & 4)
+ for (; sfb < 11; sfb++)
+ sf[0].l[sfb] = sf[-2].l[sfb];
+ else
+ for (; sfb < 11; sfb++)
+ sf[0].l[sfb] = bitget(slen0);
+ if (scfsi & 2)
+ for (; sfb < 16; sfb++)
+ sf[0].l[sfb] = sf[-2].l[sfb];
+ else
+ for (; sfb < 16; sfb++)
+ sf[0].l[sfb] = bitget(slen1);
+ if (scfsi & 1)
+ for (; sfb < 21; sfb++)
+ sf[0].l[sfb] = sf[-2].l[sfb];
+ else
+ for (; sfb < 21; sfb++)
+ sf[0].l[sfb] = bitget(slen1);
+
+
+
+ return;
+}
+/*=============================================================*/
+void unpack_sf_sub_MPEG2(SCALEFACT sf[],
+ GR * grdat,
+ int is_and_ch, IS_SF_INFO * sf_info)
+{
+ int sfb;
+ int slen1, slen2, slen3, slen4;
+ int nr1, nr2, nr3, nr4;
+ int i, k;
+ int preflag, intensity_scale;
+ int block_type, mixed_block_flag, scalefac_compress;
+
+
+ block_type = grdat->block_type;
+ mixed_block_flag = grdat->mixed_block_flag;
+ scalefac_compress = grdat->scalefac_compress;
+
+ preflag = 0;
+ intensity_scale = 0; /* to avoid compiler warning */
+ if (is_and_ch == 0)
+ {
+ if (scalefac_compress < 400)
+ {
+ slen2 = scalefac_compress >> 4;
+ slen1 = slen2 / 5;
+ slen2 = slen2 % 5;
+ slen4 = scalefac_compress & 15;
+ slen3 = slen4 >> 2;
+ slen4 = slen4 & 3;
+ k = 0;
+ }
+ else if (scalefac_compress < 500)
+ {
+ scalefac_compress -= 400;
+ slen2 = scalefac_compress >> 2;
+ slen1 = slen2 / 5;
+ slen2 = slen2 % 5;
+ slen3 = scalefac_compress & 3;
+ slen4 = 0;
+ k = 1;
+ }
+ else
+ {
+ scalefac_compress -= 500;
+ slen1 = scalefac_compress / 3;
+ slen2 = scalefac_compress % 3;
+ slen3 = slen4 = 0;
+ if (mixed_block_flag)
+ {
+ slen3 = slen2; /* adjust for long/short mix logic */
+ slen2 = slen1;
+ }
+ preflag = 1;
+ k = 2;
+ }
+ }
+ else
+ { /* intensity stereo ch = 1 (right) */
+ intensity_scale = scalefac_compress & 1;
+ scalefac_compress >>= 1;
+ if (scalefac_compress < 180)
+ {
+ slen1 = scalefac_compress / 36;
+ slen2 = scalefac_compress % 36;
+ slen3 = slen2 % 6;
+ slen2 = slen2 / 6;
+ slen4 = 0;
+ k = 3 + 0;
+ }
+ else if (scalefac_compress < 244)
+ {
+ scalefac_compress -= 180;
+ slen3 = scalefac_compress & 3;
+ scalefac_compress >>= 2;
+ slen2 = scalefac_compress & 3;
+ slen1 = scalefac_compress >> 2;
+ slen4 = 0;
+ k = 3 + 1;
+ }
+ else
+ {
+ scalefac_compress -= 244;
+ slen1 = scalefac_compress / 3;
+ slen2 = scalefac_compress % 3;
+ slen3 = slen4 = 0;
+ k = 3 + 2;
+ }
+ }
+
+ i = 0;
+ if (block_type == 2)
+ i = (mixed_block_flag & 1) + 1;
+ nr1 = nr_table[k][i][0];
+ nr2 = nr_table[k][i][1];
+ nr3 = nr_table[k][i][2];
+ nr4 = nr_table[k][i][3];
+
+
+/* return is scale factor info (for right chan is mode) */
+ if (is_and_ch)
+ {
+ sf_info->nr[0] = nr1;
+ sf_info->nr[1] = nr2;
+ sf_info->nr[2] = nr3;
+ sf_info->slen[0] = slen1;
+ sf_info->slen[1] = slen2;
+ sf_info->slen[2] = slen3;
+ sf_info->intensity_scale = intensity_scale;
+ }
+ grdat->preflag = preflag; /* return preflag */
+
+/*--------------------------------------*/
+ if (block_type == 2)
+ {
+ if (mixed_block_flag)
+ { /* mixed */
+ if (slen1 != 0) /* long block portion */
+ for (sfb = 0; sfb < 6; sfb++)
+ sf[0].l[sfb] = bitget(slen1);
+ else
+ for (sfb = 0; sfb < 6; sfb++)
+ sf[0].l[sfb] = 0;
+ sfb = 3; /* start sfb for short */
+ }
+ else
+ { /* all short, initial short blocks */
+ sfb = 0;
+ if (slen1 != 0)
+ for (i = 0; i < nr1; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen1);
+ sf[0].s[1][sfb] = bitget(slen1);
+ sf[0].s[2][sfb] = bitget(slen1);
+ }
+ else
+ for (i = 0; i < nr1; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = 0;
+ sf[0].s[1][sfb] = 0;
+ sf[0].s[2][sfb] = 0;
+ }
+ }
+/* remaining short blocks */
+ if (slen2 != 0)
+ for (i = 0; i < nr2; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen2);
+ sf[0].s[1][sfb] = bitget(slen2);
+ sf[0].s[2][sfb] = bitget(slen2);
+ }
+ else
+ for (i = 0; i < nr2; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = 0;
+ sf[0].s[1][sfb] = 0;
+ sf[0].s[2][sfb] = 0;
+ }
+ if (slen3 != 0)
+ for (i = 0; i < nr3; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen3);
+ sf[0].s[1][sfb] = bitget(slen3);
+ sf[0].s[2][sfb] = bitget(slen3);
+ }
+ else
+ for (i = 0; i < nr3; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = 0;
+ sf[0].s[1][sfb] = 0;
+ sf[0].s[2][sfb] = 0;
+ }
+ if (slen4 != 0)
+ for (i = 0; i < nr4; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = bitget(slen4);
+ sf[0].s[1][sfb] = bitget(slen4);
+ sf[0].s[2][sfb] = bitget(slen4);
+ }
+ else
+ for (i = 0; i < nr4; i++, sfb++)
+ {
+ sf[0].s[0][sfb] = 0;
+ sf[0].s[1][sfb] = 0;
+ sf[0].s[2][sfb] = 0;
+ }
+ return;
+ }
+
+
+/* long blocks types 0 1 3 */
+ sfb = 0;
+ if (slen1 != 0)
+ for (i = 0; i < nr1; i++, sfb++)
+ sf[0].l[sfb] = bitget(slen1);
+ else
+ for (i = 0; i < nr1; i++, sfb++)
+ sf[0].l[sfb] = 0;
+
+ if (slen2 != 0)
+ for (i = 0; i < nr2; i++, sfb++)
+ sf[0].l[sfb] = bitget(slen2);
+ else
+ for (i = 0; i < nr2; i++, sfb++)
+ sf[0].l[sfb] = 0;
+
+ if (slen3 != 0)
+ for (i = 0; i < nr3; i++, sfb++)
+ sf[0].l[sfb] = bitget(slen3);
+ else
+ for (i = 0; i < nr3; i++, sfb++)
+ sf[0].l[sfb] = 0;
+
+ if (slen4 != 0)
+ for (i = 0; i < nr4; i++, sfb++)
+ sf[0].l[sfb] = bitget(slen4);
+ else
+ for (i = 0; i < nr4; i++, sfb++)
+ sf[0].l[sfb] = 0;
+
+
+}
+/*-------------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998-1999 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*---- wavep.c --------------------------------------------
+
+WAVE FILE HEADER ROUTINES
+with conditional pcm conversion to MS wave format
+portable version
+
+-----------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "port.h"
+
+typedef struct
+{
+ unsigned char riff[4];
+ unsigned char size[4];
+ unsigned char wave[4];
+ unsigned char fmt[4];
+ unsigned char fmtsize[4];
+ unsigned char tag[2];
+ unsigned char nChannels[2];
+ unsigned char nSamplesPerSec[4];
+ unsigned char nAvgBytesPerSec[4];
+ unsigned char nBlockAlign[2];
+ unsigned char nBitsPerSample[2];
+ unsigned char data[4];
+ unsigned char pcm_bytes[4];
+}
+BYTE_WAVE;
+
+static BYTE_WAVE wave =
+{
+ "RIFF",
+ {(sizeof(BYTE_WAVE) - 8), 0, 0, 0},
+ "WAVE",
+ "fmt ",
+ {16, 0, 0, 0},
+ {1, 0},
+ {1, 0},
+ {34, 86, 0, 0}, /* 86 * 256 + 34 = 22050 */
+ {172, 68, 0, 0}, /* 172 * 256 + 68 = 44100 */
+ {2, 0},
+ {16, 0},
+ "data",
+ {0, 0, 0, 0}
+};
+
+/*---------------------------------------------------------*/
+static void set_wave(unsigned char w[], int n, long x)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ {
+ w[i] = (unsigned char) (x & 0xff);
+ x >>= 8;
+ }
+}
+/*---------------------------------------------------------*/
+int write_pcm_header_wave(int handout,
+ long samprate, int channels, int bits, int type)
+{
+ int nwrite;
+
+ if (type == 0)
+ set_wave(wave.tag, sizeof(wave.tag), 1);
+ else if (type == 10)
+ set_wave(wave.tag, sizeof(wave.tag), 7);
+ else
+ return 0;
+
+ set_wave(wave.size, sizeof(wave.size), sizeof(wave) - 8);
+ set_wave(wave.nChannels, sizeof(wave.nChannels), channels);
+ set_wave(wave.nSamplesPerSec, sizeof(wave.nSamplesPerSec), samprate);
+ set_wave(wave.nAvgBytesPerSec, sizeof(wave.nAvgBytesPerSec),
+ (channels * samprate * bits + 7) / 8);
+ set_wave(wave.nBlockAlign, sizeof(wave.nBlockAlign), (channels * bits + 7) / 8);
+ set_wave(wave.nBitsPerSample, sizeof(wave.nBitsPerSample), bits);
+ set_wave(wave.pcm_bytes, sizeof(wave.pcm_bytes), 0);
+
+ nwrite = write(handout, &wave, sizeof(wave));
+ if (nwrite != sizeof(wave))
+ return 0;
+
+ return 1;
+}
+/*-----------------------------------------------*/
+int write_pcm_tailer_wave(int handout, unsigned long pcm_bytes)
+{
+ unsigned long pos;
+ int nwrite;
+
+
+ set_wave(wave.size, sizeof(wave.size), sizeof(wave) - 8 + pcm_bytes);
+ set_wave(wave.pcm_bytes, sizeof(wave.pcm_bytes), pcm_bytes);
+
+
+ pos = lseek(handout, 0L, 2);
+/*-- save current position */
+ lseek(handout, 0L, 0);
+/*-- pos to header --*/
+ nwrite = write(handout, &wave, sizeof(wave));
+ lseek(handout, pos, 0);
+/*-- restore pos --*/
+
+ if (nwrite != sizeof(wave))
+ return 0;
+ return 1;
+}
+/*-----------------------------------------------*/
+/*----------------------------------------------------------------
+ pcm conversion to wave format
+
+ This conversion code required for big endian machine, or,
+ if sizeof(short) != 16 bits.
+ Conversion routines may be used on any machine, but if
+ not required, the do nothing macros in port.h can be used instead
+ to reduce overhead.
+
+-----------------------------------------------------------------*/
+#ifndef LITTLE_SHORT16
+#include "wcvt.c"
+#endif
+/*-----------------------------------------------*/
+int cvt_to_wave_test()
+{
+/*-- test for valid compile ---*/
+
+ return sizeof(short) - 2;
+
+
+}
+/*-----------------------------------------------*/
--- /dev/null
+/*____________________________________________________________________________
+
+ FreeAmp - The Free MP3 Player
+
+ MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+ Corp. http://www.xingtech.com
+
+ Portions Copyright (C) 1998 EMusic.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ $Id$
+____________________________________________________________________________*/
+
+/*---- wcvt.c --------------------------------------------
+
+conditional inclusion to wavep.c
+
+pcm conversion to wave format
+ for big endians or when sizeof(short) > 16 bits
+
+mod 1/9/97 warnings
+
+-----------------------------------------------------------*/
+static int bytes_per_samp = 1;
+static int big_ender;
+static int cvt_flag;
+
+/*-------------------------------------------------------*/
+void cvt_to_wave_init(int bits)
+{
+
+ big_ender = 1;
+ if ((*(unsigned char *) &big_ender) == 1)
+ big_ender = 0;
+
+/*--- printf("\n big_ender = %d", big_ender ); ---*/
+
+ if (bits == 8)
+ bytes_per_samp = 1;
+ else
+ bytes_per_samp = sizeof(short);
+
+
+ cvt_flag = 0;
+ if (bits > 8)
+ {
+ if (big_ender)
+ cvt_flag = 1;
+ cvt_flag |= (sizeof(short) > 2);
+ }
+
+}
+/*-------------------------------------------------------*/
+unsigned int cvt_to_wave(unsigned char *pcm, unsigned int bytes_in)
+{
+ unsigned int i, k;
+ unsigned int nsamp;
+ short tmp;
+ unsigned short *w;
+
+// printf("\n wave convert");
+
+ if (cvt_flag == 0)
+ return bytes_in;
+/*-- no conversion required --*/
+
+ nsamp = bytes_in / bytes_per_samp;
+ w = (unsigned short *) pcm;
+ for (i = 0, k = 0; i < nsamp; i++, k += 2)
+ {
+ tmp = w[i];
+ pcm[k] = (unsigned char) tmp;
+ pcm[k + 1] = (unsigned char) (tmp >> 8);
+ }
+
+ return (nsamp << 1);
+/*--- return bytes out ---*/
+}
+/*-------------------------------------------------------*/
--- /dev/null
+#
+# FreeAmp - The Free MP3 Player
+#
+# Based on MP3 decoder originally Copyright (C) 1995-1997
+# Xing Technology Corp. http://www.xingtech.com
+#
+# Copyright (C) 1999 Mark H. Weaver <mhw@netris.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# $Id$
+#
+
+#%% extern wincoef,dword
+#%% extern coef32,dword
+#%% ! extern float wincoef[264];
+#%% ! extern float coef32[31];
+
+.equ L_tmp, 0
+#%!.equ L_pcm, 4
+#%% if-not-inline
+.equ L_vbuf, 24
+.equ L_vb_ptr, 28
+.equ L_pcm, 32
+
+.globl window_dual
+ .align 16
+#%% end-not-inline
+#%% ! void window_dual(float *vbuf, int vb_ptr, short *pcm)
+#%% ! {
+window_dual: #%% proc
+#%% if-not-inline
+ pushl %ebp
+ pushl %edi
+ pushl %esi
+ pushl %ebx
+ subl $4,%esp
+
+ movl L_vb_ptr(%esp),%esi
+ movl L_vbuf(%esp),%edi
+#%% end-not-inline
+
+#%! movl vb_ptr,%esi
+#%! movl vbuf,%edi
+#%! movl pcm,%ecx
+#%! pushl %ebp
+#%! subl $8,%esp
+#%! movl %ecx,L_pcm(%esp)
+
+ movl $511,%ebp # ebp = 511
+ leal wincoef,%ecx # coef = wincoef
+ addl $16,%esi # si = vb_ptr + 16
+ movl %esi,%ebx
+ addl $32,%ebx
+ andl %ebp,%ebx # bx = (si + 32) & 511
+
+# First 16
+ movb $16,%dh # i = 16
+ .align 4
+.FirstOuter:
+ fldz # sum = 0.0
+ movb $2,%dl # j = 2
+ .align 4
+.FirstInner:
+.rept 4 # Unrolled loop
+ flds (%ecx) # Push *coef
+ fmuls (%edi,%esi,4) # Multiply by vbuf[si]
+ addl $64,%esi # si += 64
+ addl $4,%ecx # Advance coef pointer
+ andl %ebp,%esi # si &= 511
+ faddp %st,%st(1) # Add to sum
+
+ flds (%ecx) # Push *coef
+ fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
+ addl $64,%ebx # bx += 64
+ addl $4,%ecx # Advance coef pointer
+ andl %ebp,%ebx # bx &= 511
+ fsubrp %st,%st(1) # Subtract from sum
+.endr
+
+ decb %dl # --j
+ jg .FirstInner # Jump back if j > 0
+
+ fistpl L_tmp(%esp) # tmp = (long) round (sum)
+ incl %esi # si++
+ movl L_tmp(%esp),%eax
+ decl %ebx # bx--
+ movl %eax,%ebp
+ sarl $15,%eax
+ incl %eax
+ sarl $1,%eax
+ jz .FirstInRange # Jump if in range
+
+ sarl $16,%eax # Out of range
+ movl $32767,%ebp
+ xorl %eax,%ebp
+.FirstInRange:
+ movl L_pcm(%esp),%eax
+ movw %bp,(%eax) # Store sample in *pcm
+ addl $4,%eax # Increment pcm
+ movl $511,%ebp # Reload ebp with 511
+ movl %eax,L_pcm(%esp)
+
+ decb %dh # --i
+ jg .FirstOuter # Jump back if i > 0
+
+
+# Special case
+ fldz # sum = 0.0
+ movb $4,%dl # j = 4
+ .align 4
+.SpecialInner:
+.rept 2 # Unrolled loop
+ flds (%ecx) # Push *coef
+ fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
+ addl $64,%ebx # bx += 64
+ addl $4,%ecx # Increment coef pointer
+ andl %ebp,%ebx # bx &= 511
+ faddp %st,%st(1) # Add to sum
+.endr
+
+ decb %dl # --j
+ jg .SpecialInner # Jump back if j > 0
+
+ fistpl L_tmp(%esp) # tmp = (long) round (sum)
+ decl %esi # si--
+ movl L_tmp(%esp),%eax
+ incl %ebx # bx++
+ movl %eax,%ebp
+ sarl $15,%eax
+ incl %eax
+ sarl $1,%eax
+ jz .SpecialInRange # Jump if within range
+
+ sarl $16,%eax # Out of range
+ movl $32767,%ebp
+ xorl %eax,%ebp
+.SpecialInRange:
+ movl L_pcm(%esp),%eax
+ subl $36,%ecx # Readjust coef pointer for last round
+ movw %bp,(%eax) # Store sample in *pcm
+ addl $4,%eax # Increment pcm
+ movl $511,%ebp # Reload ebp with 511
+ movl %eax,L_pcm(%esp)
+
+
+# Last 15
+ movb $15,%dh # i = 15
+ .align 4
+.LastOuter:
+ fldz # sum = 0.0
+ movb $2,%dl # j = 2
+ .align 4
+.LastInner:
+.rept 4 # Unrolled loop
+ flds (%ecx) # Push *coef
+ fmuls (%edi,%esi,4) # Multiply by vbuf[si]
+ addl $64,%esi # si += 64
+ subl $4,%ecx # Back up coef pointer
+ andl %ebp,%esi # si &= 511
+ faddp %st,%st(1) # Add to sum
+
+ flds (%ecx) # Push *coef
+ fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
+ addl $64,%ebx # bx += 64
+ subl $4,%ecx # Back up coef pointer
+ andl %ebp,%ebx # bx &= 511
+ faddp %st,%st(1) # Add to sum
+.endr
+
+ decb %dl # --j
+ jg .LastInner # Jump back if j > 0
+
+ fistpl L_tmp(%esp) # tmp = (long) round (sum)
+ decl %esi # si--
+ movl L_tmp(%esp),%eax
+ incl %ebx # bx++
+ movl %eax,%ebp
+ sarl $15,%eax
+ incl %eax
+ sarl $1,%eax
+ jz .LastInRange # Jump if in range
+
+ sarl $16,%eax # Out of range
+ movl $32767,%ebp
+ xorl %eax,%ebp
+.LastInRange:
+ movl L_pcm(%esp),%eax
+ movw %bp,(%eax) # Store sample in *pcm
+ addl $4,%eax # Increment pcm
+ movl $511,%ebp # Reload ebp with 511
+ movl %eax,L_pcm(%esp)
+
+ decb %dh # --i
+ jg .LastOuter # Jump back if i > 0
+
+#%! addl $8,%esp
+#%! popl %ebp
+
+#%% if-not-inline
+# Restore regs and return
+ addl $4,%esp
+ popl %ebx
+ popl %esi
+ popl %edi
+ popl %ebp
+ ret
+#%% end-not-inline
+#%% endp
+#%% ! }
+
+#---------------------------------------------------------------------------
+
+.equ L_mi, 0
+.equ L_m, 4
+.equ L_dummy, 8
+#%!.equ L_in, 12
+#%!.equ L_out, 16
+#%!.equ L_buf, 20 # Temporary buffer
+#%!.equ L_locals, 148 # Bytes used for locals
+#%% if-not-inline
+.equ L_buf, 12 # Temporary buffer
+.equ L_in, 160
+.equ L_out, 164
+.equ L_locals, 140 # Bytes used for locals
+
+.globl asm_fdct32
+ .align 16
+#%% end-not-inline
+#%% ! void asm_fdct32(float in[], float out[])
+#%% ! {
+asm_fdct32: #%% proc
+#%% if-not-inline
+ pushl %ebp
+ pushl %edi
+ pushl %esi
+ pushl %ebx
+ subl $L_locals,%esp
+
+ movl L_in(%esp),%edi # edi = x
+ movl L_out(%esp),%esi # esi = f
+#%% end-not-inline
+
+#%! movl in,%edi # edi = x
+#%! movl out,%esi # esi = f
+#%! pushl %ebp
+#%! subl $L_locals,%esp
+
+ leal coef32-128,%ecx # coef = coef32 - (32 * 4)
+ movl $1,4(%esp) # m = 1
+ movl $16,%ebp # n = 32 / 2
+
+ leal L_buf(%esp),%ebx
+ movl %ebx,L_out(%esp) # From now on, use temp buf instead of orig x
+ jmp .ForwardLoopStart
+
+ .align 4
+.ForwardOuterLoop:
+ movl L_in(%esp),%edi # edi = x
+ movl L_out(%esp),%esi # esi = f
+ movl %edi,L_out(%esp) # Exchange mem versions of f/x for next iter
+.ForwardLoopStart:
+ movl %esi,L_in(%esp)
+ movl L_m(%esp),%ebx # ebx = m (temporarily)
+ movl %ebx,L_mi(%esp) # mi = m
+ sall $1,%ebx # Double m for next iter
+ leal (%ecx,%ebp,8),%ecx # coef += n * 8
+ movl %ebx,L_m(%esp) # Store doubled m
+ leal (%esi,%ebp,4),%ebx # ebx = f2 = f + n * 4
+ sall $3,%ebp # n *= 8
+
+ .align 4
+.ForwardMiddleLoop:
+ movl %ebp,%eax # q = n
+ xorl %edx,%edx # p = 0
+ test $8,%eax
+ jnz .ForwardInnerLoop1
+
+ .align 4
+.ForwardInnerLoop:
+ subl $4,%eax # q -= 4
+ flds (%edi,%eax) # push x[q]
+ flds (%edi,%edx) # push x[p]
+ fld %st(1) # Duplicate top two stack entries
+ fld %st(1)
+ faddp %st,%st(1)
+ fstps (%esi,%edx) # f[p] = x[p] + x[q]
+ fsubp %st,%st(1)
+ fmuls (%ecx,%edx)
+ fstps (%ebx,%edx) # f2[p] = coef[p] * (x[p] - x[q])
+ addl $4,%edx # p += 4
+
+.ForwardInnerLoop1:
+ subl $4,%eax # q -= 4
+ flds (%edi,%eax) # push x[q]
+ flds (%edi,%edx) # push x[p]
+ fld %st(1) # Duplicate top two stack entries
+ fld %st(1)
+ faddp %st,%st(1)
+ fstps (%esi,%edx) # f[p] = x[p] + x[q]
+ fsubp %st,%st(1)
+ fmuls (%ecx,%edx)
+ fstps (%ebx,%edx) # f2[p] = coef[p] * (x[p] - x[q])
+ addl $4,%edx # p += 4
+
+ cmpl %eax,%edx
+ jb .ForwardInnerLoop # Jump back if (p < q)
+
+ addl %ebp,%esi # f += n
+ addl %ebp,%ebx # f2 += n
+ addl %ebp,%edi # x += n
+ decl L_mi(%esp) # mi--
+ jg .ForwardMiddleLoop # Jump back if mi > 0
+
+ sarl $4,%ebp # n /= 16
+ jg .ForwardOuterLoop # Jump back if n > 0
+
+
+# Setup back loop
+ movl $8,%ebx # ebx = m = 8 (temporarily)
+ movl %ebx,%ebp # n = 4 * 2
+
+ .align 4
+.BackOuterLoop:
+ movl L_out(%esp),%esi # esi = f
+ movl %ebx,L_mi(%esp) # mi = m
+ movl L_in(%esp),%edi # edi = x
+ movl %ebx,L_m(%esp) # Store m
+ movl %esi,L_in(%esp) # Exchange mem versions of f/x for next iter
+ movl %edi,%ebx
+ movl %edi,L_out(%esp)
+ subl %ebp,%ebx # ebx = x2 = x - n
+ sall $1,%ebp # n *= 2
+
+ .align 4
+.BackMiddleLoop:
+ movl -4(%ebx,%ebp),%ecx
+ movl %ecx,-8(%esi,%ebp) # f[n - 8] = x2[n - 4]
+ flds -4(%edi,%ebp) # push x[n - 4]
+ fsts -4(%esi,%ebp) # f[n - 4] = x[n - 4], without popping
+ leal -8(%ebp),%eax # q = n - 8
+ leal -16(%ebp),%edx # p = n - 16
+
+ .align 4
+.BackInnerLoop:
+ movl (%ebx,%eax),%ecx
+ movl %ecx,(%esi,%edx) # f[p] = x2[q]
+ flds (%edi,%eax) # push x[q]
+ fadd %st,%st(1)
+ fxch
+ fstps 4(%esi,%edx) # f[p + 4] = x[q] + x[q + 4]
+ subl $4,%eax # q -= 4
+ subl $8,%edx # p -= 8
+ jge .BackInnerLoop # Jump back if p >= 0
+
+ fstps L_dummy(%esp) # Pop (XXX is there a better way to do this?)
+ addl %ebp,%esi # f += n
+ addl %ebp,%ebx # x2 += n
+ addl %ebp,%edi # x += n
+ decl L_mi(%esp) # mi--
+ jg .BackMiddleLoop # Jump back if mi > 0
+
+ movl L_m(%esp),%ebx # ebx = m (temporarily)
+ sarl $1,%ebx # Halve m for next iter
+ jg .BackOuterLoop # Jump back if m > 0
+
+#%! addl $L_locals,%esp
+#%! popl %ebp
+
+#%% if-not-inline
+# Restore regs and return
+ addl $L_locals,%esp
+ popl %ebx
+ popl %esi
+ popl %edi
+ popl %ebp
+ ret
+#%% end-not-inline
+#%% endp
+#%% ! }
+
--- /dev/null
+/* *************************************************** */
+/* ************ DO NOT EDIT THIS FILE!!!! ************ */
+/* *************************************************** */
+/* This file was automatically generated by gas2intel. */
+/* Edit the original gas version instead. */
+
+
+/* FreeAmp - The Free MP3 Player */
+
+/* Based on MP3 decoder originally Copyright (C) 1995-1997 */
+/* Xing Technology Corp. http://www.xingtech.com */
+
+/* Copyright (C) 1999 Mark H. Weaver <mhw@netris.org> */
+
+/* This program is free software; you can redistribute it and/or modify */
+/* it under the terms of the GNU General Public License as published by */
+/* the Free Software Foundation; either version 2 of the License, or */
+/* (at your option) any later version. */
+
+/* This program 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 General Public License for more details. */
+
+/* You should have received a copy of the GNU General Public License */
+/* along with this program; if not, write to the Free Software */
+/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* $Id$ */
+/* Generated from Id: x86gas.s,v 1.9 1999/03/05 08:58:18 mhw Exp $ */
+
+
+extern float wincoef[264];
+extern float coef32[31];
+
+#define L_tmp 0
+#define L_pcm 4
+void window_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+__asm {
+
+ mov esi,vb_ptr
+ mov edi,vbuf
+ mov ecx,pcm
+ push ebp
+ sub esp,8
+ mov DWORD PTR [esp+L_pcm],ecx
+
+ mov ebp,511 ; ebp = 511
+ lea ecx,wincoef ; coef = wincoef
+ add esi,16 ; si = vb_ptr + 16
+ mov ebx,esi
+ add ebx,32
+ and ebx,ebp ; bx = (si + 32) & 511
+
+; First 16
+ mov dh,16 ; i = 16
+ align 4
+FirstOuter:
+ fldz ; sum = 0.0
+ mov dl,2 ; j = 2
+ align 4
+FirstInner:
+; REPEAT 4 ; Unrolled loop
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ add ecx,4 ; Advance coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Advance coef pointer
+ and ebx,ebp ; bx &= 511
+ fsubp st(1),st ; Subtract from sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ add ecx,4 ; Advance coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Advance coef pointer
+ and ebx,ebp ; bx &= 511
+ fsubp st(1),st ; Subtract from sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ add ecx,4 ; Advance coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Advance coef pointer
+ and ebx,ebp ; bx &= 511
+ fsubp st(1),st ; Subtract from sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ add ecx,4 ; Advance coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Advance coef pointer
+ and ebx,ebp ; bx &= 511
+ fsubp st(1),st ; Subtract from sum
+;--
+; END REPEAT
+
+ dec dl ; --j
+ jg FirstInner ; Jump back if j > 0
+
+ fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
+ inc esi ; si++
+ mov eax,DWORD PTR [esp+L_tmp]
+ dec ebx ; bx--
+ mov ebp,eax
+ sar eax,15
+ inc eax
+ sar eax,1
+ jz FirstInRange ; Jump if in range
+
+ sar eax,16 ; Out of range
+ mov ebp,32767
+ xor ebp,eax
+FirstInRange:
+ mov eax,DWORD PTR [esp+L_pcm]
+ mov WORD PTR [eax],bp ; Store sample in *pcm
+ add eax,4 ; Increment pcm
+ mov ebp,511 ; Reload ebp with 511
+ mov DWORD PTR [esp+L_pcm],eax
+
+ dec dh ; --i
+ jg FirstOuter ; Jump back if i > 0
+
+
+; Special case
+ fldz ; sum = 0.0
+ mov dl,4 ; j = 4
+ align 4
+SpecialInner:
+; REPEAT 2 ; Unrolled loop
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Increment coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ add ecx,4 ; Increment coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+; END REPEAT
+
+ dec dl ; --j
+ jg SpecialInner ; Jump back if j > 0
+
+ fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
+ dec esi ; si--
+ mov eax,DWORD PTR [esp+L_tmp]
+ inc ebx ; bx++
+ mov ebp,eax
+ sar eax,15
+ inc eax
+ sar eax,1
+ jz SpecialInRange ; Jump if within range
+
+ sar eax,16 ; Out of range
+ mov ebp,32767
+ xor ebp,eax
+SpecialInRange:
+ mov eax,DWORD PTR [esp+L_pcm]
+ sub ecx,36 ; Readjust coef pointer for last round
+ mov WORD PTR [eax],bp ; Store sample in *pcm
+ add eax,4 ; Increment pcm
+ mov ebp,511 ; Reload ebp with 511
+ mov DWORD PTR [esp+L_pcm],eax
+
+
+; Last 15
+ mov dh,15 ; i = 15
+ align 4
+LastOuter:
+ fldz ; sum = 0.0
+ mov dl,2 ; j = 2
+ align 4
+LastInner:
+; REPEAT 4 ; Unrolled loop
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ sub ecx,4 ; Back up coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ sub ecx,4 ; Back up coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ sub ecx,4 ; Back up coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ sub ecx,4 ; Back up coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ sub ecx,4 ; Back up coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ sub ecx,4 ; Back up coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
+ add esi,64 ; si += 64
+ sub ecx,4 ; Back up coef pointer
+ and esi,ebp ; si &= 511
+ faddp st(1),st ; Add to sum
+
+ fld DWORD PTR [ecx] ; Push *coef
+ fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
+ add ebx,64 ; bx += 64
+ sub ecx,4 ; Back up coef pointer
+ and ebx,ebp ; bx &= 511
+ faddp st(1),st ; Add to sum
+;--
+; END REPEAT
+
+ dec dl ; --j
+ jg LastInner ; Jump back if j > 0
+
+ fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
+ dec esi ; si--
+ mov eax,DWORD PTR [esp+L_tmp]
+ inc ebx ; bx++
+ mov ebp,eax
+ sar eax,15
+ inc eax
+ sar eax,1
+ jz LastInRange ; Jump if in range
+
+ sar eax,16 ; Out of range
+ mov ebp,32767
+ xor ebp,eax
+LastInRange:
+ mov eax,DWORD PTR [esp+L_pcm]
+ mov WORD PTR [eax],bp ; Store sample in *pcm
+ add eax,4 ; Increment pcm
+ mov ebp,511 ; Reload ebp with 511
+ mov DWORD PTR [esp+L_pcm],eax
+
+ dec dh ; --i
+ jg LastOuter ; Jump back if i > 0
+
+ add esp,8
+ pop ebp
+
+ }
+}
+
+/*--------------------------------------------------------------------------- */
+
+#define L_mi 0
+#define L_m 4
+#define L_dummy 8
+#define L_in 12
+#define L_out 16
+#define L_buf 20 /* Temporary buffer */
+#define L_locals 148 /* Bytes used for locals */
+void asm_fdct32(float in[], float out[])
+{
+__asm {
+
+ mov edi,in ; edi = x
+ mov esi,out ; esi = f
+ push ebp
+ sub esp,L_locals
+
+ lea ecx,coef32-128 ; coef = coef32 - (32 * 4)
+ mov DWORD PTR [esp+4],1 ; m = 1
+ mov ebp,16 ; n = 32 / 2
+
+ lea ebx,DWORD PTR [esp+L_buf]
+ mov DWORD PTR [esp+L_out],ebx ; From now on, use temp buf instead of orig x
+ jmp ForwardLoopStart
+
+ align 4
+ForwardOuterLoop:
+ mov edi,DWORD PTR [esp+L_in] ; edi = x
+ mov esi,DWORD PTR [esp+L_out] ; esi = f
+ mov DWORD PTR [esp+L_out],edi ; Exchange mem versions of f/x for next iter
+ForwardLoopStart:
+ mov DWORD PTR [esp+L_in],esi
+ mov ebx,DWORD PTR [esp+L_m] ; ebx = m (temporarily)
+ mov DWORD PTR [esp+L_mi],ebx ; mi = m
+ sal ebx,1 ; Double m for next iter
+ lea ecx,DWORD PTR [ecx+ebp*8] ; coef += n * 8
+ mov DWORD PTR [esp+L_m],ebx ; Store doubled m
+ lea ebx,DWORD PTR [esi+ebp*4] ; ebx = f2 = f + n * 4
+ sal ebp,3 ; n *= 8
+
+ align 4
+ForwardMiddleLoop:
+ mov eax,ebp ; q = n
+ xor edx,edx ; p = 0
+ test eax,8
+ jnz ForwardInnerLoop1
+
+ align 4
+ForwardInnerLoop:
+ sub eax,4 ; q -= 4
+ fld DWORD PTR [edi+eax] ; push x[q]
+ fld DWORD PTR [edi+edx] ; push x[p]
+ fld st(1) ; Duplicate top two stack entries
+ fld st(1)
+ faddp st(1),st
+ fstp DWORD PTR [esi+edx] ; f[p] = x[p] + x[q]
+ fsubrp st(1),st
+ fmul DWORD PTR [ecx+edx]
+ fstp DWORD PTR [ebx+edx] ; f2[p] = coef[p] * (x[p] - x[q])
+ add edx,4 ; p += 4
+
+ForwardInnerLoop1:
+ sub eax,4 ; q -= 4
+ fld DWORD PTR [edi+eax] ; push x[q]
+ fld DWORD PTR [edi+edx] ; push x[p]
+ fld st(1) ; Duplicate top two stack entries
+ fld st(1)
+ faddp st(1),st
+ fstp DWORD PTR [esi+edx] ; f[p] = x[p] + x[q]
+ fsubrp st(1),st
+ fmul DWORD PTR [ecx+edx]
+ fstp DWORD PTR [ebx+edx] ; f2[p] = coef[p] * (x[p] - x[q])
+ add edx,4 ; p += 4
+
+ cmp edx,eax
+ jb ForwardInnerLoop ; Jump back if (p < q)
+
+ add esi,ebp ; f += n
+ add ebx,ebp ; f2 += n
+ add edi,ebp ; x += n
+ dec DWORD PTR [esp+L_mi] ; mi--
+ jg ForwardMiddleLoop ; Jump back if mi > 0
+
+ sar ebp,4 ; n /= 16
+ jg ForwardOuterLoop ; Jump back if n > 0
+
+
+; Setup back loop
+ mov ebx,8 ; ebx = m = 8 (temporarily)
+ mov ebp,ebx ; n = 4 * 2
+
+ align 4
+BackOuterLoop:
+ mov esi,DWORD PTR [esp+L_out] ; esi = f
+ mov DWORD PTR [esp+L_mi],ebx ; mi = m
+ mov edi,DWORD PTR [esp+L_in] ; edi = x
+ mov DWORD PTR [esp+L_m],ebx ; Store m
+ mov DWORD PTR [esp+L_in],esi ; Exchange mem versions of f/x for next iter
+ mov ebx,edi
+ mov DWORD PTR [esp+L_out],edi
+ sub ebx,ebp ; ebx = x2 = x - n
+ sal ebp,1 ; n *= 2
+
+ align 4
+BackMiddleLoop:
+ mov ecx,DWORD PTR [ebx+ebp-4]
+ mov DWORD PTR [esi+ebp-8],ecx ; f[n - 8] = x2[n - 4]
+ fld DWORD PTR [edi+ebp-4] ; push x[n - 4]
+ fst DWORD PTR [esi+ebp-4] ; f[n - 4] = x[n - 4], without popping
+ lea eax,DWORD PTR [ebp-8] ; q = n - 8
+ lea edx,DWORD PTR [ebp-16] ; p = n - 16
+
+ align 4
+BackInnerLoop:
+ mov ecx,DWORD PTR [ebx+eax]
+ mov DWORD PTR [esi+edx],ecx ; f[p] = x2[q]
+ fld DWORD PTR [edi+eax] ; push x[q]
+ fadd st(1),st
+ fxch
+ fstp DWORD PTR [esi+edx+4] ; f[p + 4] = x[q] + x[q + 4]
+ sub eax,4 ; q -= 4
+ sub edx,8 ; p -= 8
+ jge BackInnerLoop ; Jump back if p >= 0
+
+ fstp DWORD PTR [esp+L_dummy] ; Pop (XXX is there a better way to do this?)
+ add esi,ebp ; f += n
+ add ebx,ebp ; x2 += n
+ add edi,ebp ; x += n
+ dec DWORD PTR [esp+L_mi] ; mi--
+ jg BackMiddleLoop ; Jump back if mi > 0
+
+ mov ebx,DWORD PTR [esp+L_m] ; ebx = m (temporarily)
+ sar ebx,1 ; Halve m for next iter
+ jg BackOuterLoop ; Jump back if m > 0
+
+ add esp,L_locals
+ pop ebp
+
+ }
+}
+
projects / thirdparty / asterisk.git / commitdiff
