Version 0.1.1 from FTP
authorMark Spencer <markster@digium.com>
Tue, 7 Dec 1999 05:45:48 +0000 (05:45 +0000)
committerMark Spencer <markster@digium.com>
Tue, 7 Dec 1999 05:45:48 +0000 (05:45 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@95 65c4cc65-6c06-0410-ace0-fbb531ad65f3

40 files changed:
codecs/mp3/include/L3.h [new file with mode: 0755]
codecs/mp3/include/htable.h [new file with mode: 0755]
codecs/mp3/include/itype.h [new file with mode: 0755]
codecs/mp3/include/jdw.h [new file with mode: 0755]
codecs/mp3/include/mhead.h [new file with mode: 0755]
codecs/mp3/include/port.h [new file with mode: 0755]
codecs/mp3/include/protos.h [new file with mode: 0755]
codecs/mp3/include/tableawd.h [new file with mode: 0755]
codecs/mp3/include/xinglmc.h [new file with mode: 0755]
codecs/mp3/src/cdct.c [new file with mode: 0755]
codecs/mp3/src/csbt.c [new file with mode: 0755]
codecs/mp3/src/csbtL3.c [new file with mode: 0755]
codecs/mp3/src/csbtb.c [new file with mode: 0755]
codecs/mp3/src/cupini.c [new file with mode: 0755]
codecs/mp3/src/cupl3.c [new file with mode: 0755]
codecs/mp3/src/cwin.c [new file with mode: 0755]
codecs/mp3/src/cwinb.c [new file with mode: 0755]
codecs/mp3/src/cwinm.c [new file with mode: 0755]
codecs/mp3/src/dec8.c [new file with mode: 0755]
codecs/mp3/src/hwin.c [new file with mode: 0755]
codecs/mp3/src/icdct.c [new file with mode: 0755]
codecs/mp3/src/isbt.c [new file with mode: 0755]
codecs/mp3/src/isbtb.c [new file with mode: 0755]
codecs/mp3/src/iup.c [new file with mode: 0755]
codecs/mp3/src/iupL1.c [new file with mode: 0755]
codecs/mp3/src/iupini.c [new file with mode: 0755]
codecs/mp3/src/iwinQ.c [new file with mode: 0755]
codecs/mp3/src/iwinbQ.c [new file with mode: 0755]
codecs/mp3/src/iwinm.c [new file with mode: 0755]
codecs/mp3/src/l3dq.c [new file with mode: 0755]
codecs/mp3/src/l3init.c [new file with mode: 0755]
codecs/mp3/src/mdct.c [new file with mode: 0755]
codecs/mp3/src/mhead.c [new file with mode: 0755]
codecs/mp3/src/msis.c [new file with mode: 0755]
codecs/mp3/src/uph.c [new file with mode: 0755]
codecs/mp3/src/upsf.c [new file with mode: 0755]
codecs/mp3/src/wavep.c [new file with mode: 0755]
codecs/mp3/src/wcvt.c [new file with mode: 0755]
codecs/mp3/src/x86gas.s [new file with mode: 0755]
codecs/mp3/src/x86intel.c [new file with mode: 0755]

diff --git a/codecs/mp3/include/L3.h b/codecs/mp3/include/L3.h
new file mode 100755 (executable)
index 0000000..e920afd
--- /dev/null
@@ -0,0 +1,177 @@
+/*____________________________________________________________________________
+       
+       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;
+
+/*-----------------------------------------------------------*/
diff --git a/codecs/mp3/include/htable.h b/codecs/mp3/include/htable.h
new file mode 100755 (executable)
index 0000000..45a5dae
--- /dev/null
@@ -0,0 +1,999 @@
+/*____________________________________________________________________________
+       
+       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 */
diff --git a/codecs/mp3/include/itype.h b/codecs/mp3/include/itype.h
new file mode 100755 (executable)
index 0000000..0b24f40
--- /dev/null
@@ -0,0 +1,108 @@
+/*____________________________________________________________________________
+       
+       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))
diff --git a/codecs/mp3/include/jdw.h b/codecs/mp3/include/jdw.h
new file mode 100755 (executable)
index 0000000..bbb6e5b
--- /dev/null
@@ -0,0 +1,28 @@
+/*____________________________________________________________________________
+       
+       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
diff --git a/codecs/mp3/include/mhead.h b/codecs/mp3/include/mhead.h
new file mode 100755 (executable)
index 0000000..06b43ef
--- /dev/null
@@ -0,0 +1,299 @@
+/*____________________________________________________________________________
+       
+       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
diff --git a/codecs/mp3/include/port.h b/codecs/mp3/include/port.h
new file mode 100755 (executable)
index 0000000..537be83
--- /dev/null
@@ -0,0 +1,99 @@
+/*____________________________________________________________________________
+       
+       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);
diff --git a/codecs/mp3/include/protos.h b/codecs/mp3/include/protos.h
new file mode 100755 (executable)
index 0000000..c812e54
--- /dev/null
@@ -0,0 +1,52 @@
+/*====================================================================*/
+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);
diff --git a/codecs/mp3/include/tableawd.h b/codecs/mp3/include/tableawd.h
new file mode 100755 (executable)
index 0000000..8c0d97f
--- /dev/null
@@ -0,0 +1,93 @@
+/*____________________________________________________________________________
+       
+       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,
diff --git a/codecs/mp3/include/xinglmc.h b/codecs/mp3/include/xinglmc.h
new file mode 100755 (executable)
index 0000000..b03caa1
--- /dev/null
@@ -0,0 +1,166 @@
+/*____________________________________________________________________________
+   
+   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 */
+
+
+
+
diff --git a/codecs/mp3/src/cdct.c b/codecs/mp3/src/cdct.c
new file mode 100755 (executable)
index 0000000..f9ce28a
--- /dev/null
@@ -0,0 +1,349 @@
+/*____________________________________________________________________________
+       
+       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);
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/csbt.c b/codecs/mp3/src/csbt.c
new file mode 100755 (executable)
index 0000000..bb90795
--- /dev/null
@@ -0,0 +1,345 @@
+/*____________________________________________________________________________
+       
+       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 */
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/csbtL3.c b/codecs/mp3/src/csbtL3.c
new file mode 100755 (executable)
index 0000000..85f9599
--- /dev/null
@@ -0,0 +1,316 @@
+/*____________________________________________________________________________
+       
+       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;
+      }
+   }
+
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/csbtb.c b/codecs/mp3/src/csbtb.c
new file mode 100755 (executable)
index 0000000..158c381
--- /dev/null
@@ -0,0 +1,276 @@
+/*____________________________________________________________________________
+       
+       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;
+   }
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/cupini.c b/codecs/mp3/src/cupini.c
new file mode 100755 (executable)
index 0000000..5775a86
--- /dev/null
@@ -0,0 +1,421 @@
+/*____________________________________________________________________________
+       
+       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 */
+}
+/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/cupl3.c b/codecs/mp3/src/cupl3.c
new file mode 100755 (executable)
index 0000000..7d387b6
--- /dev/null
@@ -0,0 +1,1189 @@
+/*____________________________________________________________________________
+       
+       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;
+}
diff --git a/codecs/mp3/src/cwin.c b/codecs/mp3/src/cwin.c
new file mode 100755 (executable)
index 0000000..5698d82
--- /dev/null
@@ -0,0 +1,500 @@
+/*____________________________________________________________________________
+       
+       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
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/cwinb.c b/codecs/mp3/src/cwinb.c
new file mode 100755 (executable)
index 0000000..6b7212d
--- /dev/null
@@ -0,0 +1,496 @@
+/*____________________________________________________________________________
+       
+       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
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/cwinm.c b/codecs/mp3/src/cwinm.c
new file mode 100755 (executable)
index 0000000..c462fcc
--- /dev/null
@@ -0,0 +1,59 @@
+/*____________________________________________________________________________
+       
+       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
+/*--------------------------------------------------------*/
diff --git a/codecs/mp3/src/dec8.c b/codecs/mp3/src/dec8.c
new file mode 100755 (executable)
index 0000000..478bbf1
--- /dev/null
@@ -0,0 +1,338 @@
+/*____________________________________________________________________________
+       
+       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;
+}
diff --git a/codecs/mp3/src/hwin.c b/codecs/mp3/src/hwin.c
new file mode 100755 (executable)
index 0000000..2ba1106
--- /dev/null
@@ -0,0 +1,284 @@
+/*____________________________________________________________________________
+       
+       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
+}
+/*--------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/icdct.c b/codecs/mp3/src/icdct.c
new file mode 100755 (executable)
index 0000000..a38c401
--- /dev/null
@@ -0,0 +1,383 @@
+/*____________________________________________________________________________
+       
+       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);
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/isbt.c b/codecs/mp3/src/isbt.c
new file mode 100755 (executable)
index 0000000..bc240bd
--- /dev/null
@@ -0,0 +1,458 @@
+/*____________________________________________________________________________
+       
+       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
diff --git a/codecs/mp3/src/isbtb.c b/codecs/mp3/src/isbtb.c
new file mode 100755 (executable)
index 0000000..f598419
--- /dev/null
@@ -0,0 +1,288 @@
+/*____________________________________________________________________________
+       
+       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;
+   }
+}
+/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/iup.c b/codecs/mp3/src/iup.c
new file mode 100755 (executable)
index 0000000..8dd2fcc
--- /dev/null
@@ -0,0 +1,529 @@
+/*____________________________________________________________________________
+       
+       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 */
+/*-------------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/iupL1.c b/codecs/mp3/src/iupL1.c
new file mode 100755 (executable)
index 0000000..041c2a0
--- /dev/null
@@ -0,0 +1,330 @@
+/*____________________________________________________________________________
+       
+       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
+
+/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/iupini.c b/codecs/mp3/src/iupini.c
new file mode 100755 (executable)
index 0000000..83d5793
--- /dev/null
@@ -0,0 +1,389 @@
+/*____________________________________________________________________________
+       
+       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 */
+}
+/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/iwinQ.c b/codecs/mp3/src/iwinQ.c
new file mode 100755 (executable)
index 0000000..fae859b
--- /dev/null
@@ -0,0 +1,712 @@
+/*____________________________________________________________________________
+       
+       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;<