Remove really broke MP3 stuff in favor of G.726 in the near future
authorMark Spencer <markster@digium.com>
Tue, 4 Nov 2003 02:40:09 +0000 (02:40 +0000)
committerMark Spencer <markster@digium.com>
Tue, 4 Nov 2003 02:40:09 +0000 (02:40 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@1689 65c4cc65-6c06-0410-ace0-fbb531ad65f3

58 files changed:
Makefile
channel.c
channels/chan_iax.c
channels/chan_iax2.c
channels/chan_sip.c
channels/chan_zap.c
codecs/Makefile
codecs/codec_mp3_d.c [deleted file]
codecs/mp3/Makefile [deleted file]
codecs/mp3/include/L3.h [deleted file]
codecs/mp3/include/htable.h [deleted file]
codecs/mp3/include/itype.h [deleted file]
codecs/mp3/include/jdw.h [deleted file]
codecs/mp3/include/mhead.h [deleted file]
codecs/mp3/include/port.h [deleted file]
codecs/mp3/include/protos.h [deleted file]
codecs/mp3/include/tableawd.h [deleted file]
codecs/mp3/include/xinglmc.h [deleted file]
codecs/mp3/src/cdct.c [deleted file]
codecs/mp3/src/csbt.c [deleted file]
codecs/mp3/src/csbtL3.c [deleted file]
codecs/mp3/src/csbtb.c [deleted file]
codecs/mp3/src/cup.c [deleted file]
codecs/mp3/src/cupL1.c [deleted file]
codecs/mp3/src/cupini.c [deleted file]
codecs/mp3/src/cupl3.c [deleted file]
codecs/mp3/src/cwin.c [deleted file]
codecs/mp3/src/cwinb.c [deleted file]
codecs/mp3/src/cwinm.c [deleted file]
codecs/mp3/src/dec8.c [deleted file]
codecs/mp3/src/hwin.c [deleted file]
codecs/mp3/src/icdct.c [deleted file]
codecs/mp3/src/isbt.c [deleted file]
codecs/mp3/src/isbtb.c [deleted file]
codecs/mp3/src/iup.c [deleted file]
codecs/mp3/src/iupL1.c [deleted file]
codecs/mp3/src/iupini.c [deleted file]
codecs/mp3/src/iwinQ.c [deleted file]
codecs/mp3/src/iwinbQ.c [deleted file]
codecs/mp3/src/iwinm.c [deleted file]
codecs/mp3/src/l3dq.c [deleted file]
codecs/mp3/src/l3init.c [deleted file]
codecs/mp3/src/mdct.c [deleted file]
codecs/mp3/src/mhead.c [deleted file]
codecs/mp3/src/msis.c [deleted file]
codecs/mp3/src/uph.c [deleted file]
codecs/mp3/src/upsf.c [deleted file]
codecs/mp3/src/wavep.c [deleted file]
codecs/mp3/src/wcvt.c [deleted file]
codecs/mp3/src/x86gas.s [deleted file]
codecs/mp3/src/x86intel.c [deleted file]
codecs/mp3_slin_ex.h [deleted file]
codecs/mp3anal.h [deleted file]
formats/Makefile
formats/format_mp3.c [deleted file]
frame.c
include/asterisk/frame.h
rtp.c

index 65df33e..caacc70 100755 (executable)
--- a/Makefile
+++ b/Makefile
@@ -311,6 +311,7 @@ bininstall: all
        rm -f $(DESTDIR)$(MODULES_DIR)/chan_ixj.so
        rm -f $(DESTDIR)$(MODULES_DIR)/chan_tor.so
        rm -f $(DESTDIR)$(MODULES_DIR)/cdr_mysql.so
+       rm -f $(DESTDIR)$(MODULES_DIR)/codec_mp3_d.so
        mkdir -p $(DESTDIR)$(ASTVARLIBDIR)/sounds
        mkdir -p $(DESTDIR)$(ASTLOGDIR)/cdr-csv
        mkdir -p $(DESTDIR)$(ASTVARLIBDIR)/keys
index e6a5437..74b192c 100755 (executable)
--- a/channel.c
+++ b/channel.c
@@ -233,6 +233,8 @@ int ast_best_codec(int fmts)
                AST_FORMAT_ALAW,
                /* Okay, well, signed linear is easy to translate into other stuff */
                AST_FORMAT_SLINEAR,
+               /* G.726 is standard ADPCM */
+               AST_FORMAT_G726,
                /* ADPCM has great sound quality and is still pretty easy to translate */
                AST_FORMAT_ADPCM,
                /* Okay, we're down to vocoders now, so pick GSM because it's small and easier to
@@ -249,8 +251,6 @@ int ast_best_codec(int fmts)
                AST_FORMAT_G729A,
                /* Down to G.723.1 which is proprietary but at least designed for voice */
                AST_FORMAT_G723_1,
-               /* Last and least, MP3 which was of course never designed for real-time voice */
-               AST_FORMAT_MP3,
        };
        
        
index b80614d..d1c8394 100755 (executable)
@@ -104,8 +104,8 @@ int (*iax_regfunk)(char *username, int onoff) = NULL;
                                                                        ~AST_FORMAT_ALAW) 
 /* A modem */
 #define IAX_CAPABILITY_LOWBANDWIDTH            (IAX_CAPABILITY_MEDBANDWIDTH & \
-                                                                       ~AST_FORMAT_MP3 & \
-                                                                       ~AST_FORMAT_ADPCM)
+                                                                       ~AST_FORMAT_ADPCM & \
+                                                                       ~AST_FORMAT_G726)
 
 #define IAX_CAPABILITY_LOWFREE         (IAX_CAPABILITY_LOWBANDWIDTH & \
                                                                         ~AST_FORMAT_G723_1)
index bb476c2..c34d016 100755 (executable)
@@ -122,7 +122,7 @@ int (*iax2_regfunk)(char *username, int onoff) = NULL;
                                                                        ~AST_FORMAT_ALAW) 
 /* A modem */
 #define IAX_CAPABILITY_LOWBANDWIDTH            (IAX_CAPABILITY_MEDBANDWIDTH & \
-                                                                       ~AST_FORMAT_MP3 & \
+                                                                       ~AST_FORMAT_G726 & \
                                                                        ~AST_FORMAT_ADPCM)
 
 #define IAX_CAPABILITY_LOWFREE         (IAX_CAPABILITY_LOWBANDWIDTH & \
index ebc05e4..27148d6 100755 (executable)
@@ -234,6 +234,7 @@ static struct sip_pvt {
        char realm[256];                                /* Authorization realm */
        char nonce[256];                                /* Authorization nonce */
        char domain[256];                               /* Authorization nonce */
+       char lastmsg[256];                              /* Last Message sent/received */
        int amaflags;                                           /* AMA Flags */
        int pendinginvite;                                      /* Any pending invite */
        int pendingbye;                                         /* Need to send bye after we ack? */
@@ -2241,6 +2242,8 @@ static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int se
 
        memset(req, 0, sizeof(struct sip_request));
        
+       snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
+       
        if (!seqno) {
                p->ocseq++;
                seqno = p->ocseq;
@@ -2695,6 +2698,9 @@ static void initreqprep(struct sip_request *req, struct sip_pvt *p, char *cmd, c
        char tmp[80];
        char cid[256];
        char *l = callerid, *n=NULL;
+
+       snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", cmd);
+
        if (p->owner && p->owner->callerid) {
                strcpy(cid, p->owner->callerid);
                ast_callerid_parse(cid, &n, &l);
@@ -4225,6 +4231,7 @@ static int sip_show_channel(int fd, int argc, char *argv[])
                        ast_cli(fd, "Our Tag:             %08d\n", cur->tag);
                        ast_cli(fd, "Their Tag:           %s\n", cur->theirtag);
                        ast_cli(fd, "Need Destroy:        %d\n", cur->needdestroy);
+                       ast_cli(fd, "Last Message:        %s\n", cur->lastmsg);
                        strcpy(tmp, "");
                        if (cur->dtmfmode & SIP_DTMF_RFC2833)
                                strcat(tmp, "rfc2833 ");
@@ -4870,6 +4877,7 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
                                        *from = '\0';
                        }
                }
+               snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd);
        } else {
                /* Response to our request -- Do some sanity checks */  
                if (!p->initreq.headers) {
index 875c48f..751cd96 100755 (executable)
@@ -1312,7 +1312,9 @@ static int zt_call(struct ast_channel *ast, char *rdest, int timeout)
        struct zt_pvt *p = ast->pvt->pvt;
        int x, res, index;
        char *c, *n, *l;
+#ifdef ZAPATA_PRI
        char *s;
+#endif
        char callerid[256];
        char dest[256];
        strncpy(dest, rdest, sizeof(dest) - 1);
index f7a69fd..742739a 100755 (executable)
@@ -28,13 +28,12 @@ LIBG723=g723.1/libg723.a
 LIBG723B=g723.1b/libg723b.a
 LIBGSM=gsm/lib/libgsm.a
 LIBGSMT=gsm/lib/libgsm.a
-LIBMP3=mp3/libmp3.a
 LIBLPC10=lpc10/liblpc10.a
 LIBSPEEX=$(shell [ -f /usr/local/lib/libspeex.a ] && echo "-L/usr/local/lib")
 LIBSPEEX+=-lspeex -lm
 LIBILBC=ilbc/libilbc.a
 
-CODECS+=$(MODG723) $(MODSPEEX) $(MODILBC) codec_gsm.so codec_mp3_d.so codec_lpc10.so  \
+CODECS+=$(MODG723) $(MODSPEEX) $(MODILBC) codec_gsm.so codec_lpc10.so  \
         codec_adpcm.so codec_ulaw.so codec_alaw.so codec_a_mu.so
 
 all: depend $(CODECS)
@@ -44,7 +43,6 @@ clean:
        ! [ -d g723.1 ] || $(MAKE) -C g723.1 clean
        ! [ -d g723.1b ] || $(MAKE) -C g723.1b clean
        $(MAKE) -C gsm clean
-       $(MAKE) -C mp3 clean
        $(MAKE) -C lpc10 clean
        $(MAKE) -C ilbc clean
 
@@ -57,9 +55,6 @@ gsm/lib/libgsm.a:
 $(LIBG723B):
        $(MAKE) -C g723.1b all
 
-$(LIBMP3):
-       $(MAKE) -C mp3 all
-
 $(LIBLPC10):
        $(MAKE) -C lpc10 all
 
@@ -87,9 +82,6 @@ codec_speex.so: codec_speex.o
 codec_lpc10.so: codec_lpc10.o $(LIBLPC10)
        $(CC) $(SOLINK) -o $@ $< $(LIBLPC10) -lm
 
-codec_mp3_d.so: codec_mp3_d.o $(LIBMP3)
-       $(CC) -lm $(SOLINK) -o $@ $< $(LIBMP3)
-
 %.so : %.o
        $(CC) $(SOLINK) -o $@ $<
 
diff --git a/codecs/codec_mp3_d.c b/codecs/codec_mp3_d.c
deleted file mode 100755 (executable)
index 9ff3961..0000000
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Asterisk -- A telephony toolkit for Linux.
- *
- * MP3 Decoder
- *
- * The MP3 code is from freeamp, which in turn is from xingmp3's release
- * which I can't seem to find anywhere
- * 
- * Copyright (C) 1999, Mark Spencer
- *
- * Mark Spencer <markster@linux-support.net>
- *
- * This program is free software, distributed under the terms of
- * the GNU General Public License
- */
-
-#include <asterisk/lock.h>
-#include <asterisk/translate.h>
-#include <asterisk/module.h>
-#include <asterisk/logger.h>
-#include <asterisk/channel.h>
-#include <pthread.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "mp3/include/L3.h"
-#include "mp3/include/mhead.h"
-
-#include "mp3anal.h"
-
-/* Sample frame data */
-#include "mp3_slin_ex.h"
-
-#define MAX_OUT_FRAME 320
-
-#define MAX_FRAME_SIZE 1441
-#define MAX_OUTPUT_LEN 2304
-
-static ast_mutex_t localuser_lock = AST_MUTEX_INITIALIZER;
-static int localusecnt=0;
-
-static char *tdesc = "MP3/PCM16 (signed linear) Translator (Decoder only)";
-
-struct ast_translator_pvt {
-       MPEG m;
-       MPEG_HEAD head;
-       DEC_INFO info;
-       struct ast_frame f;
-       /* Space to build offset */
-       char offset[AST_FRIENDLY_OFFSET];
-       /* Mini buffer */
-       char outbuf[MAX_OUT_FRAME];
-       /* Enough to store a full second */
-       short buf[32000];
-       /* Tail of signed linear stuff */
-       int tail;
-       /* Current bitrate */
-       int bitrate;
-       /* XXX What's forward? XXX */
-       int forward;
-       /* Have we called head info yet? */
-       int init;
-       int copy;
-};
-
-#define mp3_coder_pvt ast_translator_pvt
-
-static struct ast_translator_pvt *mp3_new(void)
-{
-       struct mp3_coder_pvt *tmp;
-       tmp = malloc(sizeof(struct mp3_coder_pvt));
-       if (tmp) {
-               tmp->init = 0;
-               tmp->tail = 0;
-               tmp->copy = -1;
-               mpeg_init(&tmp->m);
-       }
-       return tmp;
-}
-
-static struct ast_frame *mp3tolin_sample(void)
-{
-       static struct ast_frame f;
-       int size;
-       if (mp3_badheader(mp3_slin_ex)) {
-               ast_log(LOG_WARNING, "Bad MP3 sample??\n");
-               return NULL;
-       }
-       size = mp3_framelen(mp3_slin_ex);
-       if (size < 1) {
-               ast_log(LOG_WARNING, "Failed to size??\n");
-               return NULL;
-       }
-       f.frametype = AST_FRAME_VOICE;
-       f.subclass = AST_FORMAT_MP3;
-       f.data = mp3_slin_ex;
-       f.datalen = sizeof(mp3_slin_ex);
-       /* Dunno how long an mp3 frame is -- kinda irrelevant anyway */
-       f.samples = 240;
-       f.mallocd = 0;
-       f.offset = 0;
-       f.src = __PRETTY_FUNCTION__;
-       return &f;
-}
-
-static struct ast_frame *mp3tolin_frameout(struct ast_translator_pvt *tmp)
-{
-       if (!tmp->tail)
-               return NULL;
-       /* Signed linear is no particular frame size, so just send whatever
-          we have in the buffer in one lump sum */
-       tmp->f.frametype = AST_FRAME_VOICE;
-       tmp->f.subclass = AST_FORMAT_SLINEAR;
-       tmp->f.datalen = tmp->tail * 2;
-       /* Assume 8000 Hz */
-       tmp->f.samples = tmp->tail;
-       tmp->f.mallocd = 0;
-       tmp->f.offset = AST_FRIENDLY_OFFSET;
-       tmp->f.src = __PRETTY_FUNCTION__;
-       tmp->f.data = tmp->buf;
-       /* Reset tail pointer */
-       tmp->tail = 0;
-
-#if 0
-       /* Save a sample frame */
-       {
-               static int fd = -1;
-               if (fd < 0) 
-                       fd = open("mp3out.raw", O_WRONLY | O_CREAT | O_TRUNC, 0644);
-               write(fd, tmp->f.data, tmp->f.datalen);
-       }               
-#endif
-       return &tmp->f; 
-}
-
-static int mp3_init(struct ast_translator_pvt *tmp, int len)
-{      
-       if (!audio_decode_init(&tmp->m, &tmp->head, len,0,0,1 /* Convert to mono */,24000)) {
-               ast_log(LOG_WARNING, "audio_decode_init() failed\n");
-               return -1;
-       }
-       audio_decode_info(&tmp->m, &tmp->info);
-#if 0
-       ast_verbose(
-"Channels: %d\nOutValues: %d\nSample Rate: %d\nBits: %d\nFramebytes: %d\nType: %d\n",
-       tmp->info.channels, tmp->info.outvalues, tmp->info.samprate, tmp->info.bits,tmp->info.framebytes,tmp->info.type);
-#endif
-       return 0;
-}
-
-#ifndef MIN
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-#endif
-
-#if 1
-static int add_to_buf(short *dst, int maxdst, short *src, int srclen, int samprate)
-{
-       float inc, cur, sum=0;
-       int cnt=0, pos, ptr, lastpos = -1;
-       /* Resample source to destination converting from its sampling rate to 8000 Hz */
-       if (samprate == 8000) {
-               /* Quickly, all we have to do is copy */
-               memcpy(dst, src, 2 * MIN(maxdst, srclen));
-               return MIN(maxdst, srclen);
-       }
-       if (samprate < 8000) {
-               ast_log(LOG_WARNING, "Don't know how to resample a source less than 8000 Hz!\n");
-               /* XXX Wrong thing to do XXX */
-               memcpy(dst, src, 2 * MIN(maxdst, srclen));
-               return MIN(maxdst, srclen);
-       }
-       /* Ugh, we actually *have* to resample */
-       inc = 8000.0 / (float)samprate;
-       cur = 0;
-       ptr = 0;
-       pos = 0;
-#if 0
-       ast_verbose("Incrementing by %f, in = %d bytes, out = %d bytes\n", inc, srclen, maxdst);
-#endif
-       while((pos < maxdst) && (ptr < srclen)) {
-               if (pos != lastpos) {
-                       if (lastpos > -1) {
-                               sum = sum / (float)cnt;
-                               dst[pos - 1] = (int) sum;
-#if 0
-                               ast_verbose("dst[%d] = %d\n", pos - 1, dst[pos - 1]);
-#endif
-                       }
-                       /* Each time we have a first pass */
-                       sum = 0;
-                       cnt = 0;
-               } else {
-                       sum += src[ptr];
-               }
-               ptr++;
-               cur += inc;
-               cnt++;
-               lastpos = pos;
-               pos = (int)cur;
-       }
-       return pos;
-}
-#endif
-
-static int mp3tolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
-{
-       /* Assuming there's space left, decode into the current buffer at
-          the tail location */
-       int framelen;
-       short tmpbuf[8000];
-       IN_OUT x;
-#if 0
-       if (tmp->copy < 0) {
-               tmp->copy = open("sample.out", O_WRONLY | O_CREAT | O_TRUNC, 0700);
-       }
-       if (tmp->copy > -1)
-               write(tmp->copy, f->data, f->datalen);
-#endif
-       /* Check if it's a valid frame */
-       if (mp3_badheader((unsigned char *)f->data)) {
-               ast_log(LOG_WARNING, "Invalid MP3 header\n");
-               return -1;
-       }
-       if ((framelen = mp3_framelen((unsigned char *)f->data) != f->datalen)) {
-               ast_log(LOG_WARNING, "Calculated length %d does not match real length %d\n", framelen, f->datalen);
-               return -1;
-       }
-       /* Start by putting this in the mp3 buffer */
-       if((framelen = head_info3(f->data, 
-                       f->datalen, &tmp->head, &tmp->bitrate, &tmp->forward)) > 0) {
-               if (!tmp->init) {
-                       if (mp3_init(tmp, framelen))
-                               return -1;
-                       else
-                               tmp->init++;
-               }
-               if (tmp->tail + MAX_OUTPUT_LEN/2  < sizeof(tmp->buf)/2) {       
-                       x = audio_decode(&tmp->m, f->data, tmpbuf);
-                       audio_decode_info(&tmp->m, &tmp->info);
-                       if (!x.in_bytes) {
-                               ast_log(LOG_WARNING, "Invalid MP3 data\n");
-                       } else {
-#if 1
-                               /* Resample to 8000 Hz */
-                               tmp->tail += add_to_buf(tmp->buf + tmp->tail, 
-                                  sizeof(tmp->buf) / 2 - tmp->tail, 
-                                          tmpbuf,
-                                          x.out_bytes/2,
-                                          tmp->info.samprate);
-#else
-                               memcpy(tmp->buf + tmp->tail, tmpbuf, x.out_bytes);
-                               /* Signed linear output */
-                               tmp->tail+=x.out_bytes/2;
-#endif
-                       }
-               } else {
-                       ast_log(LOG_WARNING, "Out of buffer space\n");
-                       return -1;
-               }
-       } else {
-               ast_log(LOG_WARNING, "Not a valid MP3 frame\n");
-       }
-       return 0;
-}
-
-static void mp3_destroy_stuff(struct ast_translator_pvt *pvt)
-{
-       close(pvt->copy);
-       free(pvt);
-}
-
-static struct ast_translator mp3tolin =
-       { "mp3tolin", 
-          AST_FORMAT_MP3, AST_FORMAT_SLINEAR,
-          mp3_new,
-          mp3tolin_framein,
-          mp3tolin_frameout,
-          mp3_destroy_stuff,
-          mp3tolin_sample
-          };
-
-int unload_module(void)
-{
-       int res;
-       ast_mutex_lock(&localuser_lock);
-       res = ast_unregister_translator(&mp3tolin);
-       if (localusecnt)
-               res = -1;
-       ast_mutex_unlock(&localuser_lock);
-       return res;
-}
-
-int load_module(void)
-{
-       int res;
-       res=ast_register_translator(&mp3tolin);
-       return res;
-}
-
-char *description(void)
-{
-       return tdesc;
-}
-
-int usecount(void)
-{
-       int res;
-       STANDARD_USECOUNT(res);
-       return res;
-}
-
-char *key()
-{
-       return ASTERISK_GPL_KEY;
-}
diff --git a/codecs/mp3/Makefile b/codecs/mp3/Makefile
deleted file mode 100755 (executable)
index 4ee7731..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-# LMC section
-
-CFLAGS+= -I../include -Iinclude -O3 -funroll-loops -Wall -Wno-missing-prototypes -Wno-missing-declarations -g -fPIC
-
-RANLIB=ranlib
-
-# the XING decoder objs and dependencies:
-# This is kinda nasty, since there's C, C++, and asm, oh my!
-# of course, each needs different compilation methods. grr.
-XINGOBJX86 = src/x86gas.o
-
-XINGOBJS = src/cdct.o src/cupl3.o \
-  src/hwin.o src/iup.o src/l3init.o \
-  src/msis.o src/wavep.o src/csbt.o \
-  src/cwinm.o src/icdct.o src/mdct.o \
-  src/uph.o src/cup.o src/dec8.o \
-  src/isbt.o src/l3dq.o src/mhead.o \
-  src/upsf.o src/iwinm.o
-
-LIBMP3=libmp3.a
-ARFLAGS=cr
-
-XINGLMCOBJC += $(shell if uname -m | grep -q i.86; then echo src/x86gas.o; fi)
-
-#assembly lang code, if we need it
-
-XINGLMCOBJ = $(XINGOBJS)
-
-all: $(LIBMP3)
-
-$(LIBMP3): $(XINGOBJS)
-       $(AR) $(ARFLAGS) $(LIBMP3) $(XINGLMCOBJ)
-       $(RANLIB) $(LIBMP3)
-
-clean:
-       rm -f $(XINGOBJS)
-       rm -f $(LIBMP3)
diff --git a/codecs/mp3/include/L3.h b/codecs/mp3/include/L3.h
deleted file mode 100755 (executable)
index 337a721..0000000
+++ /dev/null
@@ -1,184 +0,0 @@
-/*____________________________________________________________________________
-       
-       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 __FreeBSD__
-#ifdef __i386__
-#undef LITTLE_ENDIAN
-#define LITTLE_ENDIAN 1
-#endif
-#endif
-
-#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
deleted file mode 100755 (executable)
index 45a5dae..0000000
+++ /dev/null
@@ -1,999 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 0b24f40..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index bbb6e5b..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 37791d9..0000000
+++ /dev/null
@@ -1,298 +0,0 @@
-/*____________________________________________________________________________
-       
-       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 struct MPEGI
-{
-       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;
-               void (*unpack_routine) (struct MPEGI *);
-               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
deleted file mode 100755 (executable)
index 537be83..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index c812e54..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-/*====================================================================*/
-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
deleted file mode 100755 (executable)
index 8c0d97f..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index b03caa1..0000000
+++ /dev/null
@@ -1,166 +0,0 @@
-/*____________________________________________________________________________
-   
-   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
deleted file mode 100755 (executable)
index f9ce28a..0000000
+++ /dev/null
@@ -1,349 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index bb90795..0000000
+++ /dev/null
@@ -1,345 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 85f9599..0000000
+++ /dev/null
@@ -1,316 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 158c381..0000000
+++ /dev/null
@@ -1,276 +0,0 @@
-/*____________________________________________________________________________
-       
-       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/cup.c b/codecs/mp3/src/cup.c
deleted file mode 100755 (executable)
index 34659f1..0000000
+++ /dev/null
@@ -1,500 +0,0 @@
-/*____________________________________________________________________________
-       
-       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$
-____________________________________________________________________________*/
-
-/****  cup.c  ***************************************************
-
-MPEG audio decoder Layer I/II  mpeg1 and mpeg2
-should be portable ANSI C, should be endian independent
-
-
-mod  2/21/95 2/21/95  add bit skip, sb limiting
-
-mods 11/15/95 for Layer I
-
-******************************************************************/
-/******************************************************************
-
-       MPEG audio software decoder portable ANSI c.
-       Decodes all Layer I/II to 16 bit linear pcm.
-       Optional stereo to mono conversion.  Optional
-       output sample rate conversion to half or quarter of
-       native mpeg rate. dec8.c adds oupuut conversion features.
-
--------------------------------------
-int 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 *m                        input, mpeg structure for multiple streams
-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
-                    2 = 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 audio_decode_info( MPEG *m, DEC_INFO *info)
-
-MPEG *m                        input, mpeg structure for multiple streams
-information return:
-          Call after audio_decode_init.  See mhead.h for
-          information returned in DEC_INFO structure.
-
-
----------------------------------
-IN_OUT audio_decode(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 */
-
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4709)
-#endif
-
-
-/*-------------------------------------------------------
-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)
----------------------------------------------------------*/
-
-/*====================================================================*/
-/*----------------*/
-
-/* 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 */
-
-/* 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 sbt_mono(MPEG *m, float *sample, short *pcm, int n);
-void sbt_dual(MPEG *m, float *sample, short *pcm, int n);
-
-
-IN_OUT L2audio_decode(void *mv, unsigned char *bs, signed short *pcm);
-
-/*======================================================================*/
-/*======================================================================*/
-
-/*------------- initialize bit getter -------------*/
-static void load_init(MPEG *m, unsigned char *buf)
-{
-   m->cup.bs_ptr = buf;
-   m->cup.bits = 0;
-   m->cup.bitbuf = 0;
-}
-/*------------- get n bits from bitstream -------------*/
-static long load(MPEG *m, int n)
-{
-   unsigned long x;
-
-   if (m->cup.bits < n)
-   {                           /* refill bit buf if necessary */
-      while (m->cup.bits <= 24)
-      {
-        m->cup.bitbuf = (m->cup.bitbuf << 8) | *m->cup.bs_ptr++;
-        m->cup.bits += 8;
-      }
-   }
-   m->cup.bits -= n;
-   x = m->cup.bitbuf >> m->cup.bits;
-   m->cup.bitbuf -= x << m->cup.bits;
-   return x;
-}
-/*------------- skip over n bits in bitstream -------------*/
-static void skip(MPEG *m, int n)
-{
-   int k;
-
-   if (m->cup.bits < n)
-   {
-      n -= m->cup.bits;
-      k = n >> 3;
-/*--- bytes = n/8 --*/
-      m->cup.bs_ptr += k;
-      n -= k << 3;
-      m->cup.bitbuf = *m->cup.bs_ptr++;
-      m->cup.bits = 8;
-   }
-   m->cup.bits -= n;
-   m->cup.bitbuf -= (m->cup.bitbuf >> m->cup.bits) << m->cup.bits;
-}
-/*--------------------------------------------------------------*/
-#define mac_load_check(n) if( m->cup.bits < (n) ) {                           \
-          while( m->cup.bits <= 24 ) {               \
-             m->cup.bitbuf = (m->cup.bitbuf << 8) | *m->cup.bs_ptr++;  \
-             m->cup.bits += 8;                       \
-          }                                   \
-   }
-/*--------------------------------------------------------------*/
-#define mac_load(n) ( m->cup.bits -= n,                    \
-         m->cup.bitval = m->cup.bitbuf >> m->cup.bits,      \
-         m->cup.bitbuf -= m->cup.bitval << m->cup.bits,     \
-         m->cup.bitval )
-/*======================================================================*/
-static void unpack_ba(MPEG *m)
-{
-   int i, j, k;
-   /* Read Only */
-   static int nbit[4] =
-   {4, 4, 3, 2};
-   int nstereo;
-
-   m->cup.bit_skip = 0;
-   nstereo = m->cup.stereo_sb;
-   k = 0;
-   for (i = 0; i < 4; i++)
-   {
-      for (j = 0; j < m->cup.nbat[i]; j++, k++)
-      {
-        mac_load_check(4);
-        m->cup.ballo[k] = m->cup.samp_dispatch[k] = m->cup.bat[i][mac_load(nbit[i])];
-        if (k >= m->cup.nsb_limit)
-           m->cup.bit_skip += bat_bit_master[m->cup.samp_dispatch[k]];
-        m->cup.c_value[k] = m->cup.look_c_value[m->cup.samp_dispatch[k]];
-        if (--nstereo < 0)
-        {
-           m->cup.ballo[k + 1] = m->cup.ballo[k];
-           m->cup.samp_dispatch[k] += 18;      /* flag as joint */
-           m->cup.samp_dispatch[k + 1] = m->cup.samp_dispatch[k];      /* flag for sf */
-           m->cup.c_value[k + 1] = m->cup.c_value[k];
-           k++;
-           j++;
-        }
-      }
-   }
-   m->cup.samp_dispatch[m->cup.nsb_limit] = 37;        /* terminate the dispatcher with skip */
-   m->cup.samp_dispatch[k] = 36;       /* terminate the dispatcher */
-
-}
-/*-------------------------------------------------------------------------*/
-static void unpack_sfs(MPEG *m)        /* unpack scale factor selectors */
-{
-   int i;
-   for (i = 0; i < m->cup.max_sb; i++)
-   {
-      mac_load_check(2);
-      if (m->cup.ballo[i])
-        m->cup.sf_dispatch[i] = mac_load(2);
-      else
-        m->cup.sf_dispatch[i] = 4;     /* no allo */
-   }
-   m->cup.sf_dispatch[i] = 5;          /* terminate dispatcher */
-}
-/*-------------------------------------------------------------------------*/
-static void unpack_sf(MPEG *m)         /* unpack scale factor */
-{                              /* combine dequant and scale factors */
-   int i;
-
-   i = -1;
- dispatch:switch (m->cup.sf_dispatch[++i])
-   {
-      case 0:                  /* 3 factors 012 */
-        mac_load_check(18);
-        m->cup.cs_factor[0][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        m->cup.cs_factor[1][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        m->cup.cs_factor[2][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        goto dispatch;
-      case 1:                  /* 2 factors 002 */
-        mac_load_check(12);
-        m->cup.cs_factor[1][i] = m->cup.cs_factor[0][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        m->cup.cs_factor[2][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        goto dispatch;
-      case 2:                  /* 1 factor 000 */
-        mac_load_check(6);
-        m->cup.cs_factor[2][i] = m->cup.cs_factor[1][i] = m->cup.cs_factor[0][i] =
-           m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        goto dispatch;
-      case 3:                  /* 2 factors 022 */
-        mac_load_check(12);
-        m->cup.cs_factor[0][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        m->cup.cs_factor[2][i] = m->cup.cs_factor[1][i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-        goto dispatch;
-      case 4:                  /* no allo */
-/*-- m->cup.cs_factor[2][i] = m->cup.cs_factor[1][i] = m->cup.cs_factor[0][i] = 0.0;  --*/
-        goto dispatch;
-      case 5:                  /* all done */
-        ;
-   }                           /* end switch */
-}
-/*-------------------------------------------------------------------------*/
-#define UNPACK_N(n) s[k]     =  m->cup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1));   \
-    s[k+64]  =  m->cup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1));   \
-    s[k+128] =  m->cup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1));   \
-    goto dispatch;
-#define UNPACK_N2(n) mac_load_check(3*n);                                         \
-    s[k]     =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    s[k+64]  =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    s[k+128] =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    goto dispatch;
-#define UNPACK_N3(n) mac_load_check(2*n);                                         \
-    s[k]     =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    s[k+64]  =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    mac_load_check(n);                                           \
-    s[k+128] =  m->cup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
-    goto dispatch;
-#define UNPACKJ_N(n) tmp        =  (load(m,n)-((1 << (n-1)) -1));                \
-    s[k]       =  m->cup.cs_factor[i][k]*tmp;                       \
-    s[k+1]     =  m->cup.cs_factor[i][k+1]*tmp;                     \
-    tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
-    s[k+64]    =  m->cup.cs_factor[i][k]*tmp;                       \
-    s[k+64+1]  =  m->cup.cs_factor[i][k+1]*tmp;                     \
-    tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
-    s[k+128]   =  m->cup.cs_factor[i][k]*tmp;                       \
-    s[k+128+1] =  m->cup.cs_factor[i][k+1]*tmp;                     \
-    k++;       /* skip right chan dispatch */                \
-    goto dispatch;
-/*-------------------------------------------------------------------------*/
-static void unpack_samp(MPEG *m)       /* unpack samples */
-{
-   int i, j, k;
-   float *s;
-   int n;
-   long tmp;
-
-   s = m->cup.sample;
-   for (i = 0; i < 3; i++)
-   {                           /* 3 groups of scale factors */
-      for (j = 0; j < 4; j++)
-      {
-        k = -1;
-       dispatch:switch (m->cup.samp_dispatch[++k])
-        {
-           case 0:
-              s[k + 128] = s[k + 64] = s[k] = 0.0F;
-              goto dispatch;
-           case 1:             /* 3 levels grouped 5 bits */
-              mac_load_check(5);
-              n = mac_load(5);
-              s[k] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][2];
-              goto dispatch;
-           case 2:             /* 5 levels grouped 7 bits */
-              mac_load_check(7);
-              n = mac_load(7);
-              s[k] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][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] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][2];
-              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.0F;
-              k++;             /* skip right chan dispatch */
-              goto dispatch;
-           case 18 + 1:        /* 3 levels grouped 5 bits */
-              n = load(m,5);
-              s[k] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][0];
-              s[k + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group3_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][1];
-              s[k + 64 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group3_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group3_table[n][2];
-              s[k + 128 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group3_table[n][2];
-              k++;             /* skip right chan dispatch */
-              goto dispatch;
-           case 18 + 2:        /* 5 levels grouped 7 bits */
-              n = load(m,7);
-              s[k] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][0];
-              s[k + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group5_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][1];
-              s[k + 64 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group5_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group5_table[n][2];
-              s[k + 128 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group5_table[n][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] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][0];
-              s[k + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group9_table[n][0];
-              s[k + 64] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][1];
-              s[k + 64 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group9_table[n][1];
-              s[k + 128] = m->cup.cs_factor[i][k] * m->cup.group9_table[n][2];
-              s[k + 128 + 1] = m->cup.cs_factor[i][k + 1] * m->cup.group9_table[n][2];
-              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->cup.bit_skip);
-           case 36:
-              s += 3 * 64;
-        }                      /* end switch */
-      }                                /* end j loop */
-   }                           /* end i loop */
-
-
-}
-/*-------------------------------------------------------------------------*/
-IN_OUT audio_decode(MPEG *m, unsigned char *bs, signed short *pcm)
-{
-   return m->cup.audio_decode_routine(m, bs, pcm);
-}
-/*-------------------------------------------------------------------------*/
-IN_OUT L2audio_decode(void *mv, unsigned char *bs, signed short *pcm)
-{
-   MPEG *m = mv;
-   int sync, prot;
-   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 */
-
-   load(m,3);                  /* skip id and option (checked by init) */
-   prot = load(m,1);           /* load prot bit */
-   load(m,6);                  /* skip to pad */
-   m->cup.pad = load(m,1);
-   load(m,1);                  /* skip to mode */
-   m->cup.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 */
-
-   m->cup.sbt(m, m->cup.sample, pcm, 36);
-/*-----------*/
-   in_out.in_bytes = m->cup.framebytes + m->cup.pad;
-   in_out.out_bytes = m->cup.outbytes;
-
-   return in_out;
-}
-/*-------------------------------------------------------------------------*/
-#include "cupini.c"            /* initialization */
-#include "cupL1.c"             /* Layer I */
-/*-------------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/cupL1.c b/codecs/mp3/src/cupL1.c
deleted file mode 100755 (executable)
index 3ffe168..0000000
+++ /dev/null
@@ -1,319 +0,0 @@
-/*____________________________________________________________________________
-       
-       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$
-____________________________________________________________________________*/
-
-/****  cupL1.c  ***************************************************
-
-MPEG audio decoder Layer I mpeg1 and mpeg2
-
-include to clup.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(MPEG *m)
-{
-   int j;
-   int nstereo;
-
-   m->cup.bit_skip = 0;
-   nstereo = m->cup.stereo_sb;
-
-   for (j = 0; j < m->cup.nbatL1; j++)
-   {
-      mac_load_check(4);
-      m->cup.ballo[j] = m->cup.samp_dispatch[j] = mac_load(4);
-      if (j >= m->cup.nsb_limit)
-        m->cup.bit_skip += bat_bit_masterL1[m->cup.samp_dispatch[j]];
-      m->cup.c_value[j] = m->cup.look_c_valueL1[m->cup.samp_dispatch[j]];
-      if (--nstereo < 0)
-      {
-        m->cup.ballo[j + 1] = m->cup.ballo[j];
-        m->cup.samp_dispatch[j] += 15; /* flag as joint */
-        m->cup.samp_dispatch[j + 1] = m->cup.samp_dispatch[j]; /* flag for sf */
-        m->cup.c_value[j + 1] = m->cup.c_value[j];
-        j++;
-      }
-   }
-/*-- terminate with bit skip and end --*/
-   m->cup.samp_dispatch[m->cup.nsb_limit] = 31;
-   m->cup.samp_dispatch[j] = 30;
-}
-/*-------------------------------------------------------------------------*/
-static void unpack_sfL1(MPEG *m)       /* unpack scale factor */
-{                              /* combine dequant and scale factors */
-   int i;
-
-   for (i = 0; i < m->cup.nbatL1; i++)
-   {
-      if (m->cup.ballo[i])
-      {
-        mac_load_check(6);
-        m->cup.cs_factorL1[i] = m->cup.c_value[i] * m->cup.sf_table[mac_load(6)];
-      }
-   }
-/*-- done --*/
-}
-/*-------------------------------------------------------------------------*/
-#define UNPACKL1_N(n) s[k]     =  m->cup.cs_factorL1[k]*(load(m,n)-((1 << (n-1)) -1));  \
-    goto dispatch;
-#define UNPACKL1J_N(n) tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
-    s[k]       =  m->cup.cs_factorL1[k]*tmp;                        \
-    s[k+1]     =  m->cup.cs_factorL1[k+1]*tmp;                      \
-    k++;                                                     \
-    goto dispatch;
-/*-------------------------------------------------------------------------*/
-static void unpack_sampL1(MPEG *m)     /* unpack samples */
-{
-   int j, k;
-   float *s;
-   long tmp;
-
-   s = m->cup.sample;
-   for (j = 0; j < 12; j++)
-   {
-      k = -1;
-    dispatch:switch (m->cup.samp_dispatch[++k])
-      {
-        case 0:
-           s[k] = 0.0F;
-           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.0F;
-           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->cup.bit_skip);
-        case 30:
-           s += 64;
-      }                                /* end switch */
-   }                           /* end j loop */
-
-/*-- done --*/
-}
-/*-------------------------------------------------------------------*/
-IN_OUT L1audio_decode(void *mv, unsigned char *bs, signed short *pcm)
-{
-   MPEG *m = mv;
-   int sync, prot;
-   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 */
-
-
-   load(m,3);                  /* skip id and option (checked by init) */
-   prot = load(m,1);           /* load prot bit */
-   load(m,6);                  /* skip to pad */
-   m->cup.pad = (load(m,1)) << 2;
-   load(m,1);                  /* skip to mode */
-   m->cup.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 */
-
-   m->cup.sbt(m, m->cup.sample, pcm, 12);
-/*-----------*/
-   in_out.in_bytes = m->cup.framebytes + m->cup.pad;
-   in_out.out_bytes = m->cup.outbytes;
-
-   return in_out;
-}
-/*-------------------------------------------------------------------------*/
-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 i, k;
-   long samprate;
-   int limit;
-   long step;
-   int bit_code;
-
-/*--- sf init done by layer II init ---*/
-   if (m->cup.first_pass_L1)
-   {
-      for (step = 4, i = 1; i < 16; i++, step <<= 1)
-        m->cup.look_c_valueL1[i] = (float) (2.0 / (step - 1));
-      m->cup.first_pass_L1 = 0;
-   }
-
-   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 != 3)
-      return 0;                        /* layer I only */
-
-   m->cup.nbatL1 = 32;
-   m->cup.max_sb = m->cup.nbatL1;
-/*----- 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 = 384 >> reduction_code;
-   if (h->mode != 3)
-   {                           /* adjust for 2 channel modes */
-      m->cup.nbatL1 *= 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 < 768; i++)
-      m->cup.sample[i] = 0.0F;
-
-
-/* init sub-band transform */
-   sbt_init(m);
-
-   return 1;
-}
-/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/cupini.c b/codecs/mp3/src/cupini.c
deleted file mode 100755 (executable)
index f92d062..0000000
+++ /dev/null
@@ -1,421 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
-
-#include <string.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};
-
-
-/* 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(MPEG *m);
-
-
-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(m);
-
-   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
deleted file mode 100755 (executable)
index 59ec37c..0000000
+++ /dev/null
@@ -1,1187 +0,0 @@
-/*____________________________________________________________________________
-       
-       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(void)
-{
-   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(void)
-{
-   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
-
-/*---------------------------------------------------------*/
-/* 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
deleted file mode 100755 (executable)
index 5698d82..0000000
+++ /dev/null
@@ -1,500 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 6b7212d..0000000
+++ /dev/null
@@ -1,496 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index c462fcc..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index 50ec0a9..0000000
+++ /dev/null
@@ -1,339 +0,0 @@
-/*____________________________________________________________________________
-       
-       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 <string.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
deleted file mode 100755 (executable)
index 2ba1106..0000000
+++ /dev/null
@@ -1,284 +0,0 @@
-/*____________________________________________________________________________
-       
-       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
deleted file mode 100755 (executable)
index c2e3097..0000000
+++ /dev/null
@@ -1,383 +0,0 @@
-/*____________________________________________________________________________
-       
-       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(void)
-{
-   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
deleted file mode 100755 (executable)
index 7bd4566..0000000
+++ /dev/null
@@ -1,457 +0,0 @@
-/*____________________________________________________________________________
-       
-       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(void);
-
-/*======================================================================*/
-static void gencoef(void)              /* 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(void);
-static void genwincoef_q(void) /* 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(void)   /* gen int window coefs from floating table */
-{
-   int i;
-   float x;
-   WINCOEF *iwincoef;
-
-   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(void)
-{
-   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
deleted file mode 100755 (executable)
index f598419..0000000
+++ /dev/null
@@ -1,288 +0,0 @@
-/*____________________________________________________________________________
-       
-       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++)
-   {
-