From 1e95c3a4acfa127b90a02132826b00ab8ab3a3aa Mon Sep 17 00:00:00 2001
From: Mark Spencer <markster@digium.com>
Date: Tue, 4 Nov 2003 02:40:09 +0000
Subject: [PATCH] Remove really broke MP3 stuff in favor of G.726 in the near
future
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@1689 65c4cc65-6c06-0410-ace0-fbb531ad65f3
---
Makefile | 1 +
channel.c | 4 +-
channels/chan_iax.c | 4 +-
channels/chan_iax2.c | 2 +-
channels/chan_sip.c | 8 +
channels/chan_zap.c | 2 +
codecs/Makefile | 10 +-
codecs/codec_mp3_d.c | 320 ---------
codecs/mp3/Makefile | 38 --
codecs/mp3/include/L3.h | 184 -----
codecs/mp3/include/htable.h | 999 ---------------------------
codecs/mp3/include/itype.h | 108 ---
codecs/mp3/include/jdw.h | 28 -
codecs/mp3/include/mhead.h | 298 ---------
codecs/mp3/include/port.h | 99 ---
codecs/mp3/include/protos.h | 52 --
codecs/mp3/include/tableawd.h | 93 ---
codecs/mp3/include/xinglmc.h | 166 -----
codecs/mp3/src/cdct.c | 349 ----------
codecs/mp3/src/csbt.c | 345 ----------
codecs/mp3/src/csbtL3.c | 316 ---------
codecs/mp3/src/csbtb.c | 276 --------
codecs/mp3/src/cup.c | 500 --------------
codecs/mp3/src/cupL1.c | 319 ---------
codecs/mp3/src/cupini.c | 421 ------------
codecs/mp3/src/cupl3.c | 1187 ---------------------------------
codecs/mp3/src/cwin.c | 500 --------------
codecs/mp3/src/cwinb.c | 496 --------------
codecs/mp3/src/cwinm.c | 59 --
codecs/mp3/src/dec8.c | 339 ----------
codecs/mp3/src/hwin.c | 284 --------
codecs/mp3/src/icdct.c | 383 -----------
codecs/mp3/src/isbt.c | 457 -------------
codecs/mp3/src/isbtb.c | 288 --------
codecs/mp3/src/iup.c | 529 ---------------
codecs/mp3/src/iupL1.c | 330 ---------
codecs/mp3/src/iupini.c | 390 -----------
codecs/mp3/src/iwinQ.c | 712 --------------------
codecs/mp3/src/iwinbQ.c | 712 --------------------
codecs/mp3/src/iwinm.c | 64 --
codecs/mp3/src/l3dq.c | 256 -------
codecs/mp3/src/l3init.c | 383 -----------
codecs/mp3/src/mdct.c | 239 -------
codecs/mp3/src/mhead.c | 321 ---------
codecs/mp3/src/msis.c | 300 ---------
codecs/mp3/src/uph.c | 505 --------------
codecs/mp3/src/upsf.c | 404 -----------
codecs/mp3/src/wavep.c | 165 -----
codecs/mp3/src/wcvt.c | 92 ---
codecs/mp3/src/x86gas.s | 393 -----------
codecs/mp3/src/x86intel.c | 437 ------------
codecs/mp3_slin_ex.h | 70 --
codecs/mp3anal.h | 83 ---
formats/Makefile | 2 +-
formats/format_mp3.c | 236 -------
frame.c | 8 +-
include/asterisk/frame.h | 6 +-
rtp.c | 4 +-
58 files changed, 27 insertions(+), 15549 deletions(-)
delete mode 100755 codecs/codec_mp3_d.c
delete mode 100755 codecs/mp3/Makefile
delete mode 100755 codecs/mp3/include/L3.h
delete mode 100755 codecs/mp3/include/htable.h
delete mode 100755 codecs/mp3/include/itype.h
delete mode 100755 codecs/mp3/include/jdw.h
delete mode 100755 codecs/mp3/include/mhead.h
delete mode 100755 codecs/mp3/include/port.h
delete mode 100755 codecs/mp3/include/protos.h
delete mode 100755 codecs/mp3/include/tableawd.h
delete mode 100755 codecs/mp3/include/xinglmc.h
delete mode 100755 codecs/mp3/src/cdct.c
delete mode 100755 codecs/mp3/src/csbt.c
delete mode 100755 codecs/mp3/src/csbtL3.c
delete mode 100755 codecs/mp3/src/csbtb.c
delete mode 100755 codecs/mp3/src/cup.c
delete mode 100755 codecs/mp3/src/cupL1.c
delete mode 100755 codecs/mp3/src/cupini.c
delete mode 100755 codecs/mp3/src/cupl3.c
delete mode 100755 codecs/mp3/src/cwin.c
delete mode 100755 codecs/mp3/src/cwinb.c
delete mode 100755 codecs/mp3/src/cwinm.c
delete mode 100755 codecs/mp3/src/dec8.c
delete mode 100755 codecs/mp3/src/hwin.c
delete mode 100755 codecs/mp3/src/icdct.c
delete mode 100755 codecs/mp3/src/isbt.c
delete mode 100755 codecs/mp3/src/isbtb.c
delete mode 100755 codecs/mp3/src/iup.c
delete mode 100755 codecs/mp3/src/iupL1.c
delete mode 100755 codecs/mp3/src/iupini.c
delete mode 100755 codecs/mp3/src/iwinQ.c
delete mode 100755 codecs/mp3/src/iwinbQ.c
delete mode 100755 codecs/mp3/src/iwinm.c
delete mode 100755 codecs/mp3/src/l3dq.c
delete mode 100755 codecs/mp3/src/l3init.c
delete mode 100755 codecs/mp3/src/mdct.c
delete mode 100755 codecs/mp3/src/mhead.c
delete mode 100755 codecs/mp3/src/msis.c
delete mode 100755 codecs/mp3/src/uph.c
delete mode 100755 codecs/mp3/src/upsf.c
delete mode 100755 codecs/mp3/src/wavep.c
delete mode 100755 codecs/mp3/src/wcvt.c
delete mode 100755 codecs/mp3/src/x86gas.s
delete mode 100755 codecs/mp3/src/x86intel.c
delete mode 100755 codecs/mp3_slin_ex.h
delete mode 100755 codecs/mp3anal.h
delete mode 100755 formats/format_mp3.c
diff --git a/Makefile b/Makefile
index 65df33e805..caacc70f3a 100755
--- 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
diff --git a/channel.c b/channel.c
index e6a5437458..74b192c112 100755
--- 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,
};
diff --git a/channels/chan_iax.c b/channels/chan_iax.c
index b80614ddd9..d1c8394260 100755
--- a/channels/chan_iax.c
+++ b/channels/chan_iax.c
@@ -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)
diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c
index bb476c20ee..c34d016f7c 100755
--- a/channels/chan_iax2.c
+++ b/channels/chan_iax2.c
@@ -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 & \
diff --git a/channels/chan_sip.c b/channels/chan_sip.c
index ebc05e4043..27148d698d 100755
--- a/channels/chan_sip.c
+++ b/channels/chan_sip.c
@@ -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) {
diff --git a/channels/chan_zap.c b/channels/chan_zap.c
index 875c48ff7c..751cd96d56 100755
--- a/channels/chan_zap.c
+++ b/channels/chan_zap.c
@@ -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);
diff --git a/codecs/Makefile b/codecs/Makefile
index f7a69fd1aa..742739af4e 100755
--- a/codecs/Makefile
+++ b/codecs/Makefile
@@ -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
index 9ff3961aab..0000000000
--- a/codecs/codec_mp3_d.c
+++ /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
index 4ee7731181..0000000000
--- a/codecs/mp3/Makefile
+++ /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
index 337a721fb7..0000000000
--- a/codecs/mp3/include/L3.h
+++ /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
index 45a5daef94..0000000000
--- a/codecs/mp3/include/htable.h
+++ /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
index 0b24f40e19..0000000000
--- a/codecs/mp3/include/itype.h
+++ /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
index bbb6e5bfff..0000000000
--- a/codecs/mp3/include/jdw.h
+++ /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
index 37791d909b..0000000000
--- a/codecs/mp3/include/mhead.h
+++ /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
index 537be833a4..0000000000
--- a/codecs/mp3/include/port.h
+++ /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
index c812e54cd1..0000000000
--- a/codecs/mp3/include/protos.h
+++ /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
index 8c0d97ff62..0000000000
--- a/codecs/mp3/include/tableawd.h
+++ /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
index b03caa1e87..0000000000
--- a/codecs/mp3/include/xinglmc.h
+++ /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
index f9ce28a7e2..0000000000
--- a/codecs/mp3/src/cdct.c
+++ /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
index bb90795263..0000000000
--- a/codecs/mp3/src/csbt.c
+++ /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
index 85f9599b06..0000000000
--- a/codecs/mp3/src/csbtL3.c
+++ /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
index 158c38151f..0000000000
--- a/codecs/mp3/src/csbtb.c
+++ /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
index 34659f15b0..0000000000
--- a/codecs/mp3/src/cup.c
+++ /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
index 3ffe16801b..0000000000
--- a/codecs/mp3/src/cupL1.c
+++ /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
index f92d06284a..0000000000
--- a/codecs/mp3/src/cupini.c
+++ /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
index 59ec37c7db..0000000000
--- a/codecs/mp3/src/cupl3.c
+++ /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
index 5698d82bb5..0000000000
--- a/codecs/mp3/src/cwin.c
+++ /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
index 6b7212dda7..0000000000
--- a/codecs/mp3/src/cwinb.c
+++ /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
index c462fcc9a0..0000000000
--- a/codecs/mp3/src/cwinm.c
+++ /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
index 50ec0a9ad8..0000000000
--- a/codecs/mp3/src/dec8.c
+++ /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
index 2ba1106d77..0000000000
--- a/codecs/mp3/src/hwin.c
+++ /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
index c2e30971f6..0000000000
--- a/codecs/mp3/src/icdct.c
+++ /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
index 7bd456653c..0000000000
--- a/codecs/mp3/src/isbt.c
+++ /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
index f598419756..0000000000
--- a/codecs/mp3/src/isbtb.c
+++ /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++)
- {
- i_dct16_dual(sample, vbuf + vb_ptr);
- i_windowB16(vbuf, vb_ptr, pcm);
- sample += 64;
- vb_ptr = (vb_ptr - 16) & 255;
- pcm += 16;
- }
-}
-/*------------------------------------------------------------*/
-/*---------------- 8 pt sbt's -------------------------------*/
-/*------------------------------------------------------------*/
-void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
-{
- int i;
-
- for (i = 0; i < n; i++)
- {
- i_dct8(sample, vbuf + vb_ptr);
- i_windowB8(vbuf, vb_ptr, pcm);
- sample += 64;
- vb_ptr = (vb_ptr - 8) & 127;
- pcm += 8;
- }
-
-}
-/*------------------------------------------------------------*/
-void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
-{
- int i;
-
- for (i = 0; i < n; i++)
- {
- i_dct8_dual(sample, vbuf + vb_ptr);
- i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
- i_windowB8_dual(vbuf, vb_ptr, pcm);
- i_windowB8_dual_right(vbuf2, vb_ptr, pcm + 1);
- sample += 64;
- vb_ptr = (vb_ptr - 8) & 127;
- pcm += 16;
- }
-}
-/*------------------------------------------------------------*/
-void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
-{
- int i;
-
- for (i = 0; i < n; i++)
- {
- i_dct8_dual_mono(sample, vbuf + vb_ptr);
- i_windowB8(vbuf, vb_ptr, pcm);
- sample += 64;
- vb_ptr = (vb_ptr - 8) & 127;
- pcm += 8;
- }
-}
-/*------------------------------------------------------------*/
-void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
-{
- int i;
-
- for (i = 0; i < n; i++)
- {
- i_dct8_dual(sample, vbuf + vb_ptr);
- i_windowB8(vbuf, vb_ptr, pcm);
- sample += 64;
- vb_ptr = (vb_ptr - 8) & 127;
- pcm += 8;
- }
-}
-/*------------------------------------------------------------*/
-void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
-{
- int i;
-
- sample++;
- for (i = 0; i < n; i++)
- {
- i_dct8_dual(sample, vbuf + vb_ptr);
- i_windowB8(vbuf, vb_ptr, pcm);
- sample += 64;
- vb_ptr = (vb_ptr - 8) & 127;
- pcm += 8;
- }
-}
-/*------------------------------------------------------------*/
diff --git a/codecs/mp3/src/iup.c b/codecs/mp3/src/iup.c
deleted file mode 100755
index 1fdd41b651..0000000000
--- a/codecs/mp3/src/iup.c
+++ /dev/null
@@ -1,529 +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$
-____________________________________________________________________________*/
-
-/**** iup.c ***************************************************
-
-MPEG audio decoder Layer I/II, mpeg1 and mpeg2
-should be portable ANSI C, should be endian independent
-
-icup integer version of cup.c
-
-
-
-mod 10/18/95 mod grouped sample unpack for:
- Overflow possible in grouped if native int is 16 bit.
- Rare occurance. 16x16-->32 mult needed.
-
-mods 11/15/95 for Layer I
-
-
-1/5/95 Quick fix, cs_factor can overflow int16 (why?). Typed to int32.
-
-mods 1/7/97 warnings
-
-******************************************************************/
-/******************************************************************
-
- MPEG audio software decoder portable ANSI c.
- Decodes all Layer II to 16 bit linear pcm.
- Optional stereo to mono conversion. Optional
- output sample rate conversion to half or quarter of
- native mpeg rate.
-
--------------------------------------
-int i_audio_decode_init(MPEG *m, MPEG_HEAD *h, int framebytes_arg,
- int reduction_code, int transform_code, int convert_code,
- int freq_limit)
-
-initilize decoder:
- return 0 = fail, not 0 = success
-
-MPEG_HEAD *h input, mpeg header info (returned by call to head_info)
-framebytes input, mpeg frame size (returned by call to head_info)
-reduction_code input, sample rate reduction code
- 0 = full rate
- 1 = half rate
- 0 = quarter rate
-
-transform_code input, ignored
-convert_code input, channel conversion
- convert_code: 0 = two chan output
- 1 = convert two chan to mono
- 2 = convert two chan to left chan
- 3 = convert two chan to right chan
-freq_limit input, limits bandwidth of pcm output to specified
- frequency. Special use. Set to 24000 for normal use.
-
-
----------------------------------
-void i_audio_decode_info( MPEG *m, DEC_INFO *info)
-
-information return:
- Call after audio_decode_init. See mhead.h for
- information returned in DEC_INFO structure.
-
-
----------------------------------
-IN_OUT i_audio_decode(MPEG *m, unsigned char *bs, void *pcmbuf)
-
-decode one mpeg audio frame:
-bs input, mpeg bitstream, must start with
- sync word. Caution: may read up to 3 bytes
- beyond end of frame.
-pcmbuf output, pcm samples.
-
-IN_OUT structure returns:
- Number bytes conceptually removed from mpeg bitstream.
- Returns 0 if sync loss.
- Number bytes of pcm output.
-
-*******************************************************************/
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "L3.h"
-#include "mhead.h" /* mpeg header structure */
-#include "jdw.h"
-
-/*-------------------------------------------------------
-NOTE: Decoder may read up to three bytes beyond end of
-frame. Calling application must ensure that this does
-not cause a memory access violation (protection fault)
----------------------------------------------------------*/
-
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4709)
-#endif
-
-
-/* Okay to be global -- is read/only */
-static int look_joint[16] =
-{ /* lookup stereo sb's by mode+ext */
- 64, 64, 64, 64, /* stereo */
- 2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
- 64, 64, 64, 64, /* dual */
- 32, 32, 32, 32, /* mono */
-};
-
-/* Okay to be global -- is read/only */
-static int bat_bit_master[] =
-{
- 0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48};
-
-void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
-
-static void unpack(MPEGI *m);
-
-/*------------- initialize bit getter -------------*/
-static void load_init(MPEGI *m, unsigned char *buf)
-{
- m->iup.bs_ptr = buf;
- m->iup.bits = 0;
- m->iup.bitbuf = 0;
-}
-/*------------- get n bits from bitstream -------------*/
-static INT32 load(MPEGI *m, int n)
-{
- UINT32 x;
-
- if (m->iup.bits < n)
- { /* refill bit buf if necessary */
- while (m->iup.bits <= 24)
- {
- m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++;
- m->iup.bits += 8;
- }
- }
- m->iup.bits -= n;
- x = m->iup.bitbuf >> m->iup.bits;
- m->iup.bitbuf -= x << m->iup.bits;
- return x;
-}
-/*------------- skip over n bits in bitstream -------------*/
-static void skip(MPEGI *m, int n)
-{
- int k;
-
- if (m->iup.bits < n)
- {
- n -= m->iup.bits;
- k = n >> 3;
-/*--- bytes = n/8 --*/
- m->iup.bs_ptr += k;
- n -= k << 3;
- m->iup.bitbuf = *m->iup.bs_ptr++;
- m->iup.bits = 8;
- }
- m->iup.bits -= n;
- m->iup.bitbuf -= (m->iup.bitbuf >> m->iup.bits) << m->iup.bits;
-}
-/*--------------------------------------------------------------*/
-#define mac_load_check(n) \
- if( m->iup.bits < (n) ) { \
- while( m->iup.bits <= 24 ) { \
- m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++; \
- m->iup.bits += 8; \
- } \
- }
-/*--------------------------------------------------------------*/
-#define mac_load(n) \
- ( m->iup.bits -= n, \
- m->iup.bitval = m->iup.bitbuf >> m->iup.bits, \
- m->iup.bitbuf -= m->iup.bitval << m->iup.bits, \
- m->iup.bitval )
-/*======================================================================*/
-static void unpack_ba(MPEGI *m)
-{
- int i, j, k;
- static int nbit[4] =
- {4, 4, 3, 2};
- int nstereo;
- int n;
-
- m->iup.bit_skip = 0;
- nstereo = m->iup.stereo_sb;
- k = 0;
- for (i = 0; i < 4; i++)
- {
- for (j = 0; j < m->iup.nbat[i]; j++, k++)
- {
- mac_load_check(4);
- n = m->iup.ballo[k] = m->iup.samp_dispatch[k] = m->iup.bat[i][mac_load(nbit[i])];
- if (k >= m->iup.nsb_limit)
- m->iup.bit_skip += bat_bit_master[m->iup.samp_dispatch[k]];
- m->iup.c_value[k] = m->iup.look_c_value[n];
- m->iup.c_shift[k] = m->iup.look_c_shift[n];
- if (--nstereo < 0)
- {
- m->iup.ballo[k + 1] = m->iup.ballo[k];
- m->iup.samp_dispatch[k] += 18; /* flag as joint */
- m->iup.samp_dispatch[k + 1] = m->iup.samp_dispatch[k]; /* flag for sf */
- m->iup.c_value[k + 1] = m->iup.c_value[k];
- m->iup.c_shift[k + 1] = m->iup.c_shift[k];
- k++;
- j++;
- }
- }
- }
- m->iup.samp_dispatch[m->iup.nsb_limit] = 37; /* terminate the dispatcher with skip */
- m->iup.samp_dispatch[k] = 36; /* terminate the dispatcher */
-
-}
-/*-------------------------------------------------------------------------*/
-static void unpack_sfs(MPEGI *m) /* unpack scale factor selectors */
-{
- int i;
-
- for (i = 0; i < m->iup.max_sb; i++)
- {
- mac_load_check(2);
- if (m->iup.ballo[i])
- m->iup.sf_dispatch[i] = mac_load(2);
- else
- m->iup.sf_dispatch[i] = 4; /* no allo */
- }
- m->iup.sf_dispatch[i] = 5; /* terminate dispatcher */
-}
-/*-------------------------------------------------------------------------*/
-/*--- multiply note -------------------------------------------------------*/
-/*--- 16bit x 16bit mult --> 32bit >> 15 --> 16 bit or better -----------*/
-static void unpack_sf(MPEGI *m) /* unpack scale factor */
-{ /* combine dequant and scale factors */
- int i, n;
- INT32 tmp; /* only reason tmp is 32 bit is to get 32 bit mult result */
-
- i = -1;
- dispatch:switch (m->iup.sf_dispatch[++i])
- {
- case 0: /* 3 factors 012 */
- mac_load_check(18);
- tmp = m->iup.c_value[i];
- n = m->iup.c_shift[i];
- m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- m->iup.cs_factor[1][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- goto dispatch;
- case 1: /* 2 factors 002 */
- mac_load_check(12);
- tmp = m->iup.c_value[i];
- n = m->iup.c_shift[i];
- m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
- (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- goto dispatch;
- case 2: /* 1 factor 000 */
- mac_load_check(6);
- tmp = m->iup.c_value[i];
- n = m->iup.c_shift[i];
- m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
- (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- goto dispatch;
- case 3: /* 2 factors 022 */
- mac_load_check(12);
- tmp = m->iup.c_value[i];
- n = m->iup.c_shift[i];
- m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] =
- (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- goto dispatch;
- case 4: /* no allo */
- goto dispatch;
- case 5: /* all done */
- ;
- } /* end switch */
-}
-/*-------------------------------------------------------------------------*/
-/*-------------------------------------------------------------------------*/
-/*--- unpack multiply note ------------------------------------------------*/
-/*--- 16bit x 16bit mult --> 32bit or better required---------------------*/
-#define UNPACK_N(n) \
- s[k] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
- s[k+64] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
- s[k+128] = ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1)); \
- goto dispatch;
-#define UNPACK_N2(n) \
- mac_load_check(3*n); \
- s[k] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- s[k+64] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- s[k+128] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- goto dispatch;
-#define UNPACK_N3(n) \
- mac_load_check(2*n); \
- s[k] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- s[k+64] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- mac_load_check(n); \
- s[k+128] = (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1); \
- goto dispatch;
-#define UNPACKJ_N(n) \
- tmp = (load(m,n)-((1 << (n-1)) -1)); \
- s[k] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
- s[k+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
- tmp = (load(m,n)-((1 << (n-1)) -1)); \
- s[k+64] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
- s[k+64+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
- tmp = (load(m,n)-((1 << (n-1)) -1)); \
- s[k+128] = (m->iup.cs_factor[i][k]*tmp)>>(n-1); \
- s[k+128+1] = (m->iup.cs_factor[i][k+1]*tmp)>>(n-1); \
- k++; /* skip right chan dispatch */ \
- goto dispatch;
-/*-------------------------------------------------------------------------*/
-static void unpack_samp(MPEGI *m) /* unpack samples */
-{
- int i, j, k;
- SAMPLEINT *s;
- int n;
- INT32 tmp;
-
- s = m->iup.sample;
- for (i = 0; i < 3; i++)
- { /* 3 groups of scale factors */
- for (j = 0; j < 4; j++)
- {
- k = -1;
- dispatch:switch (m->iup.samp_dispatch[++k])
- {
- case 0:
- s[k + 128] = s[k + 64] = s[k] = 0;
- goto dispatch;
- case 1: /* 3 levels grouped 5 bits */
- mac_load_check(5);
- n = mac_load(5);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
- goto dispatch;
- case 2: /* 5 levels grouped 7 bits */
- mac_load_check(7);
- n = mac_load(7);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
- goto dispatch;
- case 3:
- UNPACK_N2(3) /* 7 levels */
- case 4: /* 9 levels grouped 10 bits */
- mac_load_check(10);
- n = mac_load(10);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
- goto dispatch;
- case 5:
- UNPACK_N2(4) /* 15 levels */
- case 6:
- UNPACK_N2(5) /* 31 levels */
- case 7:
- UNPACK_N2(6) /* 63 levels */
- case 8:
- UNPACK_N2(7) /* 127 levels */
- case 9:
- UNPACK_N2(8) /* 255 levels */
- case 10:
- UNPACK_N3(9) /* 511 levels */
- case 11:
- UNPACK_N3(10) /* 1023 levels */
- case 12:
- UNPACK_N3(11) /* 2047 levels */
- case 13:
- UNPACK_N3(12) /* 4095 levels */
- case 14:
- UNPACK_N(13) /* 8191 levels */
- case 15:
- UNPACK_N(14) /* 16383 levels */
- case 16:
- UNPACK_N(15) /* 32767 levels */
- case 17:
- UNPACK_N(16) /* 65535 levels */
-/* -- joint ---- */
- case 18 + 0:
- s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0;
- k++; /* skip right chan dispatch */
- goto dispatch;
- case 18 + 1: /* 3 levels grouped 5 bits */
- n = load(m,5);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
- s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][0]) >> 1;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
- s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][1]) >> 1;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
- s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][2]) >> 1;
- k++; /* skip right chan dispatch */
- goto dispatch;
- case 18 + 2: /* 5 levels grouped 7 bits */
- n = load(m,7);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
- s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][0]) >> 2;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
- s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][1]) >> 2;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
- s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][2]) >> 2;
- k++; /* skip right chan dispatch */
- goto dispatch;
- case 18 + 3:
- UNPACKJ_N(3) /* 7 levels */
- case 18 + 4: /* 9 levels grouped 10 bits */
- n = load(m,10);
- s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
- s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][0]) >> 3;
- s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
- s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][1]) >> 3;
- s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
- s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][2]) >> 3;
- k++; /* skip right chan dispatch */
- goto dispatch;
- case 18 + 5:
- UNPACKJ_N(4) /* 15 levels */
- case 18 + 6:
- UNPACKJ_N(5) /* 31 levels */
- case 18 + 7:
- UNPACKJ_N(6) /* 63 levels */
- case 18 + 8:
- UNPACKJ_N(7) /* 127 levels */
- case 18 + 9:
- UNPACKJ_N(8) /* 255 levels */
- case 18 + 10:
- UNPACKJ_N(9) /* 511 levels */
- case 18 + 11:
- UNPACKJ_N(10) /* 1023 levels */
- case 18 + 12:
- UNPACKJ_N(11) /* 2047 levels */
- case 18 + 13:
- UNPACKJ_N(12) /* 4095 levels */
- case 18 + 14:
- UNPACKJ_N(13) /* 8191 levels */
- case 18 + 15:
- UNPACKJ_N(14) /* 16383 levels */
- case 18 + 16:
- UNPACKJ_N(15) /* 32767 levels */
- case 18 + 17:
- UNPACKJ_N(16) /* 65535 levels */
-/* -- end of dispatch -- */
- case 37:
- skip(m, m->iup.bit_skip);
- case 36:
- s += 3 * 64;
- } /* end switch */
- } /* end j loop */
- } /* end i loop */
-
-
-}
-/*-------------------------------------------------------------------------*/
-static void unpack(MPEGI *m)
-{
- int prot;
-
-/* at entry bit getter points at id, sync skipped by caller */
-
- load(m,3); /* skip id and option (checked by init) */
- prot = load(m,1); /* load prot bit */
- load(m,6); /* skip to pad */
- m->iup.pad = load(m,1);
- load(m,1); /* skip to mode */
- m->iup.stereo_sb = look_joint[load(m,4)];
- if (prot)
- load(m,4); /* skip to data */
- else
- load(m,20); /* skip crc */
-
- unpack_ba(m); /* unpack bit allocation */
- unpack_sfs(m); /* unpack scale factor selectors */
- unpack_sf(m); /* unpack scale factor */
- unpack_samp(m); /* unpack samples */
-
-
-}
-/*-------------------------------------------------------------------------*/
-IN_OUT i_audio_decode(MPEGI *m, unsigned char *bs, signed short *pcm)
-{
- int sync;
- IN_OUT in_out;
-
- load_init(m,bs); /* initialize bit getter */
-/* test sync */
- in_out.in_bytes = 0; /* assume fail */
- in_out.out_bytes = 0;
- sync = load(m,12);
-
- if (sync != 0xFFF)
- return in_out; /* sync fail */
-/*-----------*/
- m->iup.unpack_routine(m);
-
-
- m->iup.sbt(m->iup.sample, pcm, m->iup.nsbt);
-/*-----------*/
- in_out.in_bytes = m->iup.framebytes + m->iup.pad;
- in_out.out_bytes = m->iup.outbytes;
- return in_out;
-}
-/*-------------------------------------------------------------------------*/
-#include "iupini.c" /* initialization */
-#include "iupL1.c" /* Layer 1 */
-/*-------------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/iupL1.c b/codecs/mp3/src/iupL1.c
deleted file mode 100755
index 041c2a00b4..0000000000
--- a/codecs/mp3/src/iupL1.c
+++ /dev/null
@@ -1,330 +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$
-____________________________________________________________________________*/
-
-/**** iupL1.c ***************************************************
-
-MPEG audio decoder Layer I mpeg1 and mpeg2
-should be portable ANSI C, should be endian independent
-
-icupL1 integer version of cupL1.c
-
-******************************************************************/
-/*======================================================================*/
-/* Read Only */
-static int bat_bit_masterL1[] =
-{
- 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-
-/*======================================================================*/
-static void unpack_baL1(MPEGI *m)
-{
- int k;
- int nstereo;
- int n;
-
- m->iup.bit_skip = 0;
- nstereo = m->iup.stereo_sb;
- for (k = 0; k < m->iup.nbatL1; k++)
- {
- mac_load_check(4);
- n = m->iup.ballo[k] = m->iup.samp_dispatch[k] = mac_load(4);
- if (k >= m->iup.nsb_limit)
- m->iup.bit_skip += bat_bit_masterL1[m->iup.samp_dispatch[k]];
- m->iup.c_value[k] = m->iup.look_c_valueL1[n];
- m->iup.c_shift[k] = m->iup.look_c_shiftL1[n];
- if (--nstereo < 0)
- {
- m->iup.ballo[k + 1] = m->iup.ballo[k];
- m->iup.samp_dispatch[k] += 15; /* flag as joint */
- m->iup.samp_dispatch[k + 1] = m->iup.samp_dispatch[k]; /* flag for sf */
- m->iup.c_value[k + 1] = m->iup.c_value[k];
- m->iup.c_shift[k + 1] = m->iup.c_shift[k];
- k++;
- }
- }
- m->iup.samp_dispatch[m->iup.nsb_limit] = 31; /* terminate the dispatcher with skip */
- m->iup.samp_dispatch[k] = 30; /* terminate the dispatcher */
-
-}
-/*-------------------------------------------------------------------------*/
-static void unpack_sfL1(MPEGI *m) /* unpack scale factor */
-{ /* combine dequant and scale factors */
- int i, n;
- INT32 tmp; /* only reason tmp is 32 bit is to get 32 bit mult result */
-
- for (i = 0; i < m->iup.nbatL1; i++)
- {
- if (m->iup.ballo[i])
- {
- mac_load_check(6);
- tmp = m->iup.c_value[i];
- n = m->iup.c_shift[i];
- m->iup.cs_factorL1[i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
- }
- }
-
-/*-- done --*/
-}
-/*-------------------------------------------------------------------------*/
-#define UNPACKL1_N(n) s[k] = (m->iup.cs_factorL1[k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1); \
- goto dispatch;
-#define UNPACKL1J_N(n) tmp = (load(m,n)-((1 << (n-1)) -1)); \
- s[k] = (m->iup.cs_factorL1[k]*tmp)>>(n-1); \
- s[k+1] = (m->iup.cs_factorL1[k+1]*tmp)>>(n-1); \
- k++; /* skip right chan dispatch */ \
- goto dispatch;
-/*-------------------------------------------------------------------------*/
-static void unpack_sampL1(MPEGI *m) /* unpack samples */
-{
- int j, k;
- SAMPLEINT *s;
- INT32 tmp;
-
- s = m->iup.sample;
- for (j = 0; j < 12; j++)
- {
- k = -1;
- dispatch:switch (m->iup.samp_dispatch[++k])
- {
- case 0:
- s[k] = 0;
- goto dispatch;
- case 1:
- UNPACKL1_N(2) /* 3 levels */
- case 2:
- UNPACKL1_N(3) /* 7 levels */
- case 3:
- UNPACKL1_N(4) /* 15 levels */
- case 4:
- UNPACKL1_N(5) /* 31 levels */
- case 5:
- UNPACKL1_N(6) /* 63 levels */
- case 6:
- UNPACKL1_N(7) /* 127 levels */
- case 7:
- UNPACKL1_N(8) /* 255 levels */
- case 8:
- UNPACKL1_N(9) /* 511 levels */
- case 9:
- UNPACKL1_N(10) /* 1023 levels */
- case 10:
- UNPACKL1_N(11) /* 2047 levels */
- case 11:
- UNPACKL1_N(12) /* 4095 levels */
- case 12:
- UNPACKL1_N(13) /* 8191 levels */
- case 13:
- UNPACKL1_N(14) /* 16383 levels */
- case 14:
- UNPACKL1_N(15) /* 32767 levels */
-/* -- joint ---- */
- case 15 + 0:
- s[k + 1] = s[k] = 0;
- k++; /* skip right chan dispatch */
- goto dispatch;
-/* -- joint ---- */
- case 15 + 1:
- UNPACKL1J_N(2) /* 3 levels */
- case 15 + 2:
- UNPACKL1J_N(3) /* 7 levels */
- case 15 + 3:
- UNPACKL1J_N(4) /* 15 levels */
- case 15 + 4:
- UNPACKL1J_N(5) /* 31 levels */
- case 15 + 5:
- UNPACKL1J_N(6) /* 63 levels */
- case 15 + 6:
- UNPACKL1J_N(7) /* 127 levels */
- case 15 + 7:
- UNPACKL1J_N(8) /* 255 levels */
- case 15 + 8:
- UNPACKL1J_N(9) /* 511 levels */
- case 15 + 9:
- UNPACKL1J_N(10) /* 1023 levels */
- case 15 + 10:
- UNPACKL1J_N(11) /* 2047 levels */
- case 15 + 11:
- UNPACKL1J_N(12) /* 4095 levels */
- case 15 + 12:
- UNPACKL1J_N(13) /* 8191 levels */
- case 15 + 13:
- UNPACKL1J_N(14) /* 16383 levels */
- case 15 + 14:
- UNPACKL1J_N(15) /* 32767 levels */
-
-/* -- end of dispatch -- */
- case 31:
- skip(m, m->iup.bit_skip);
- case 30:
- s += 64;
- } /* end switch */
- } /* end j loop */
-
-/*-- done --*/
-}
-/*-------------------------------------------------------------------------*/
-static void unpackL1(MPEGI *m)
-{
- int prot;
-
-/* at entry bit getter points at id, sync skipped by caller */
-
- load(m,3); /* skip id and option (checked by init) */
- prot = load(m,1); /* load prot bit */
- load(m,6); /* skip to pad */
- m->iup.pad = load(m,1) << 2;
- load(m,1); /* skip to mode */
- m->iup.stereo_sb = look_joint[load(m,4)];
- if (prot)
- load(m,4); /* skip to data */
- else
- load(m,20); /* skip crc */
-
- unpack_baL1(m); /* unpack bit allocation */
- unpack_sfL1(m); /* unpack scale factor */
- unpack_sampL1(m); /* unpack samples */
-
-
-}
-/*-------------------------------------------------------------------------*/
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4056)
-#endif
-
-int i_audio_decode_initL1(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
- int reduction_code, int transform_code, int convert_code,
- int freq_limit)
-{
- int i, k;
- long samprate;
- int limit;
- int stepbit;
- long step;
- int bit_code;
-
-/*--- sf table built by Layer II init ---*/
-
- if (m->iup.first_pass_L1)
- {
- stepbit = 2;
- step = 4;
- for (i = 1; i < 16; i++)
- {
- m->iup.look_c_valueL1[i] = (int) (32768.0 * 2.0 / (step - 1));
- m->iup.look_c_shiftL1[i] = 16 - stepbit;
- stepbit++;
- step <<= 1;
- }
- m->iup.first_pass_L1 = 0;
- }
-
- m->iup.unpack_routine = unpackL1;
-
-
- transform_code = transform_code; /* not used, asm compatability */
- bit_code = 0;
- if (convert_code & 8)
- bit_code = 1;
- convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
- if (reduction_code < 0)
- reduction_code = 0;
- if (reduction_code > 2)
- reduction_code = 2;
- if (freq_limit < 1000)
- freq_limit = 1000;
-
-
- m->iup.framebytes = framebytes_arg;
-/* check if code handles */
- if (h->option != 3)
- return 0; /* layer I only */
-
- m->iup.nbatL1 = 32;
- m->iup.max_sb = m->iup.nbatL1;
-/*----- compute nsb_limit --------*/
- samprate = sr_table[4 * h->id + h->sr_index];
- m->iup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
-/*- caller limit -*/
-/*---- limit = 0.94*(32>>reduction_code); ----*/
- limit = (32 >> reduction_code);
- if (limit > 8)
- limit--;
- if (m->iup.nsb_limit > limit)
- m->iup.nsb_limit = limit;
- if (m->iup.nsb_limit > m->iup.max_sb)
- m->iup.nsb_limit = m->iup.max_sb;
-
- m->iup.outvalues = 384 >> reduction_code;
- if (h->mode != 3)
- { /* adjust for 2 channel modes */
- m->iup.nbatL1 *= 2;
- m->iup.max_sb *= 2;
- m->iup.nsb_limit *= 2;
- }
-
-/* set sbt function */
- m->iup.nsbt = 12;
- k = 1 + convert_code;
- if (h->mode == 3)
- {
- k = 0;
- }
- m->iup.sbt = sbt_table[bit_code][reduction_code][k];
- m->iup.outvalues *= out_chans[k];
- if (bit_code != 0)
- m->iup.outbytes = m->iup.outvalues;
- else
- m->iup.outbytes = sizeof(short) * m->iup.outvalues;
-
- m->iup.decinfo.channels = out_chans[k];
- m->iup.decinfo.outvalues = m->iup.outvalues;
- m->iup.decinfo.samprate = samprate >> reduction_code;
- if (bit_code != 0)
- m->iup.decinfo.bits = 8;
- else
- m->iup.decinfo.bits = sizeof(short) * 8;
-
- m->iup.decinfo.framebytes = m->iup.framebytes;
- m->iup.decinfo.type = 0;
-
-
-/* clear sample buffer, unused sub bands must be 0 */
- for (i = 0; i < 768; i++)
- m->iup.sample[i] = 0;
-
-
-/* init sub-band transform */
- i_sbt_init();
-
- return 1;
-}
-
-#ifdef _MSC_VER
-#pragma warning(default: 4056)
-#endif
-
-/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/iupini.c b/codecs/mp3/src/iupini.c
deleted file mode 100755
index 616fd63d2f..0000000000
--- a/codecs/mp3/src/iupini.c
+++ /dev/null
@@ -1,390 +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 iup.c - include to iup.c
- mpeg audio decoder portable "c" integer
-
-
-mods 11/15/95 for Layer I
-
-mods 1/8/97 warnings
-
-=========================================================*/
-#include <limits.h>
-#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};
-
-/* Read only */
-static int stepbits[18] =
-{
- 0, 2, 3, 3, 4, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 14, 15, 16};
-
-/* ABCD_INDEX = lookqt[mode][sr_index][br_index] */
-/* -1 = invalid */
-/* Read only */
-static signed char lookqt[4][3][16] =
-{
- {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks stereo */
- {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
- {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
- {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks joint stereo */
- {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
- {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
- {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1}, /* 44ks dual chan */
- {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1}, /* 48ks */
- {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}}, /* 32ks */
- {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}, /* 44ks single chan */
- {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1}, /* 48ks */
- {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}}, /* 32ks */
-};
-
-/* Read only */
-static long sr_table[8] =
-{22050L, 24000L, 16000L, 1L,
- 44100L, 48000L, 32000L, 1L};
-
-/* bit allocation table look up */
-/* table per mpeg spec tables 3b2a/b/c/d /e is mpeg2 */
-/* look_bat[abcd_index][4][16] */
-/* Read only */
-static unsigned char look_bat[5][4][16] =
-{
-/* LOOK_BATA */
- {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
- {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
- {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
-/* LOOK_BATB */
- {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
- {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
- {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
-/* LOOK_BATC */
- {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
-/* LOOK_BATD */
- {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
-/* LOOK_BATE */
- {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
-};
-
-/* look_nbat[abcd_index]][4] */
-/* Read only */
-static unsigned char look_nbat[5][4] =
-{
- {3, 8, 12, 4},
- {3, 8, 12, 7},
- {2, 0, 6, 0},
- {2, 0, 10, 0},
- {4, 0, 7, 19},
-};
-
-
-void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n);
-void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n);
-
-/*--- 8 bit output ---*/
-void i_sbtB_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB16_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB16_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB16_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB16_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB16_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
-void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
-
-
-/* Read Only */
-static SBT_FUNCTION sbt_table[2][3][5] =
-{
- {{i_sbt_mono, i_sbt_dual, i_sbt_dual_mono, i_sbt_dual_left, i_sbt_dual_right},
- {i_sbt16_mono, i_sbt16_dual, i_sbt16_dual_mono, i_sbt16_dual_left, i_sbt16_dual_right},
- {i_sbt8_mono, i_sbt8_dual, i_sbt8_dual_mono, i_sbt8_dual_left, i_sbt8_dual_right}},
-
- {{(SBT_FUNCTION) i_sbtB_mono,
- (SBT_FUNCTION) i_sbtB_dual,
- (SBT_FUNCTION) i_sbtB_dual_mono,
- (SBT_FUNCTION) i_sbtB_dual_left,
- (SBT_FUNCTION) i_sbtB_dual_right},
- {(SBT_FUNCTION) i_sbtB16_mono,
- (SBT_FUNCTION) i_sbtB16_dual,
- (SBT_FUNCTION) i_sbtB16_dual_mono,
- (SBT_FUNCTION) i_sbtB16_dual_left,
- (SBT_FUNCTION) i_sbtB16_dual_right},
- {(SBT_FUNCTION) i_sbtB8_mono,
- (SBT_FUNCTION) i_sbtB8_dual,
- (SBT_FUNCTION) i_sbtB8_dual_mono,
- (SBT_FUNCTION) i_sbtB8_dual_left,
- (SBT_FUNCTION) i_sbtB8_dual_right}},
-};
-/* Read Only */
-static int out_chans[5] =
-{1, 2, 1, 1, 1};
-
-/*---------------------------------------------------------*/
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4056)
-#endif
-
-void i_mpeg_init(MPEGI *m)
-{
- memset(&m->iup, 0, sizeof(m->iup));
- m->iup.nsb_limit = 6;
- m->iup.nbat[0] = 3;
- m->iup.nbat[1] = 8;
- m->iup.nbat[3] = 12;
- m->iup.nbat[4] = 7;
- m->iup.nsbt = 36;
- m->iup.sbt = i_sbt_mono;
- m->iup.unpack_routine = unpack;
- m->iup.first_pass = 1;
- m->iup.first_pass_L1 = 1;
- m->iup.nbatL1 = 32;
- m->iup.cs_factorL1 = m->iup.cs_factor[0];
-}
-
-static void table_init(MPEGI *m)
-{
- int i, j;
- int code;
- int bits;
- long tmp, sfmax;
-
-/*-- c_values (dequant) --*/
- for (i = 1; i < 18; i++)
- m->iup.look_c_value[i] = (int) (32768.0 * 2.0 / steps[i]);
- for (i = 1; i < 18; i++)
- m->iup.look_c_shift[i] = 16 - stepbits[i];
-
-/*-- scale factor table, scale by 32768 for 16 pcm output --*/
- bits = min(8 * sizeof(SAMPLEINT), 8 * sizeof(m->iup.sf_table[0]));
- tmp = 1L << (bits - 2);
- sfmax = tmp + (tmp - 1);
- for (i = 0; i < 64; i++)
- {
- tmp = (long) (32768.0 * 2.0 * pow(2.0, -i / 3.0));
- if (tmp > sfmax)
- tmp = sfmax;
- m->iup.sf_table[i] = tmp;
- }
-/*-- grouped 3 level lookup table 5 bit token --*/
- for (i = 0; i < 32; i++)
- {
- code = i;
- for (j = 0; j < 3; j++)
- {
- m->iup.group3_table[i][j] = (char) ((code % 3) - 1);
- code /= 3;
- }
- }
-/*-- grouped 5 level lookup table 7 bit token --*/
- for (i = 0; i < 128; i++)
- {
- code = i;
- for (j = 0; j < 3; j++)
- {
- m->iup.group5_table[i][j] = (char) ((code % 5) - 2);
- code /= 5;
- }
- }
-/*-- grouped 9 level lookup table 10 bit token --*/
- for (i = 0; i < 1024; i++)
- {
- code = i;
- for (j = 0; j < 3; j++)
- {
- m->iup.group9_table[i][j] = (short) ((code % 9) - 4);
- code /= 9;
- }
- }
-
-
-}
-
-#ifdef _MSC_VER
-#pragma warning(default: 4056)
-#endif
-
-/*---------------------------------------------------------*/
-int i_audio_decode_initL1(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
- int reduction_code, int transform_code, int convert_code,
- int freq_limit);
-void i_sbt_init(void);
-
-/*---------------------------------------------------------*/
-/* mpeg_head defined in mhead.h frame bytes is without pad */
-int i_audio_decode_init(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
- int reduction_code, int transform_code, int convert_code,
- int freq_limit)
-{
- int i, j, k;
- int abcd_index;
- long samprate;
- int limit;
- int bit_code;
-
- if (m->iup.first_pass)
- {
- table_init(m);
- m->iup.first_pass = 0;
- }
-
-/* check if code handles */
- if (h->option == 3) /* layer I */
- return i_audio_decode_initL1(m, h, framebytes_arg,
- reduction_code, transform_code, convert_code, freq_limit);
- if (h->option != 2)
- return 0; /* layer II only */
-
-
- m->iup.unpack_routine = unpack;
-
- transform_code = transform_code; /* not used, asm compatability */
- bit_code = 0;
- if (convert_code & 8)
- bit_code = 1;
- convert_code = convert_code & 3; /* higher bits used by dec8 freq cvt */
- if (reduction_code < 0)
- reduction_code = 0;
- if (reduction_code > 2)
- reduction_code = 2;
- if (freq_limit < 1000)
- freq_limit = 1000;
-
-
- m->iup.framebytes = framebytes_arg;
-
-/* compute abcd index for bit allo table selection */
- if (h->id) /* mpeg 1 */
- abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
- else
- abcd_index = 4; /* mpeg 2 */
- for (i = 0; i < 4; i++)
- for (j = 0; j < 16; j++)
- m->iup.bat[i][j] = look_bat[abcd_index][i][j];
- for (i = 0; i < 4; i++)
- m->iup.nbat[i] = look_nbat[abcd_index][i];
- m->iup.max_sb = m->iup.nbat[0] + m->iup.nbat[1] + m->iup.nbat[2] + m->iup.nbat[3];
-/*----- compute nsb_limit --------*/
- samprate = sr_table[4 * h->id + h->sr_index];
- m->iup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
-/*- caller limit -*/
-/*---- limit = 0.94*(32>>reduction_code); ----*/
- limit = (32 >> reduction_code);
- if (limit > 8)
- limit--;
- if (m->iup.nsb_limit > limit)
- m->iup.nsb_limit = limit;
- if (m->iup.nsb_limit > m->iup.max_sb)
- m->iup.nsb_limit = m->iup.max_sb;
-
- m->iup.outvalues = 1152 >> reduction_code;
- if (h->mode != 3)
- { /* adjust for 2 channel modes */
- for (i = 0; i < 4; i++)
- m->iup.nbat[i] *= 2;
- m->iup.max_sb *= 2;
- m->iup.nsb_limit *= 2;
- }
-
-/* set sbt function */
- m->iup.nsbt = 36;
- k = 1 + convert_code;
- if (h->mode == 3)
- {
- k = 0;
- }
- m->iup.sbt = sbt_table[bit_code][reduction_code][k];
- m->iup.outvalues *= out_chans[k];
- if (bit_code != 0)
- m->iup.outbytes = m->iup.outvalues;
- else
- m->iup.outbytes = sizeof(short) * m->iup.outvalues;
-
- m->iup.decinfo.channels = out_chans[k];
- m->iup.decinfo.outvalues = m->iup.outvalues;
- m->iup.decinfo.samprate = samprate >> reduction_code;
- if (bit_code != 0)
- m->iup.decinfo.bits = 8;
- else
- m->iup.decinfo.bits = sizeof(short) * 8;
-
- m->iup.decinfo.framebytes = m->iup.framebytes;
- m->iup.decinfo.type = 0;
-
-
-/* clear sample buffer, unused sub bands must be 0 */
- for (i = 0; i < 2304; i++)
- m->iup.sample[i] = 0;
-
-
-/* init sub-band transform */
- i_sbt_init();
-
- return 1;
-}
-/*---------------------------------------------------------*/
-void i_audio_decode_info(MPEGI *m, DEC_INFO * info)
-{
- *info = m->iup.decinfo; /* info return, call after init */
-}
-/*---------------------------------------------------------*/
diff --git a/codecs/mp3/src/iwinQ.c b/codecs/mp3/src/iwinQ.c
deleted file mode 100755
index fae859b995..0000000000
--- a/codecs/mp3/src/iwinQ.c
+++ /dev/null
@@ -1,712 +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$
-____________________________________________________________________________*/
-
-/*----- iwinq.c ---------------------------------------------------
-
-portable c
-mpeg1/2 Layer II audio decode
-
-conditional include to iwinm.c
-
-quick integer window
-
-mods 1/8/97 warnings
-
---------------------------------------------------------------*/
-/*--------------------------------------------------------------------*/
-void i_window(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-}
-/*------------------------------------------------------------*/
-void i_window_dual(WININT * vbuf, int vb_ptr, short *pcm)
-{
-/* dual window interleaves output */
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-void i_window_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
-{
-/* right identical to dual, for asm */
-/* dual window interleaves output */
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*------------------------------------------------------------*/
-/*------------------- 16 pt window ------------------------------*/
-void i_window16(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-}
-/*--------------- 16 pt dual window (interleaved output) -----------------*/
-void i_window16_dual(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*--------------- 16 pt dual window (interleaved output) -----------------*/
-void i_window16_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
-{
-/* right identical to dual, for asm */
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*------------------- 8 pt window ------------------------------*/
-void i_window8(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (short) sum;
- }
-}
-/*--------------- 8 pt dual window (interleaved output) --------------*/
-void i_window8_dual(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*--------------- 8 pt dual window (interleaved output) --------------*/
-void i_window8_dual_right(WININT * vbuf, int vb_ptr, short *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/* right identical to dual, for asm */
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (short) sum;
- pcm += 2;
- }
-}
-/*--------------------------------------------------------*/
diff --git a/codecs/mp3/src/iwinbQ.c b/codecs/mp3/src/iwinbQ.c
deleted file mode 100755
index 15c573a16c..0000000000
--- a/codecs/mp3/src/iwinbQ.c
+++ /dev/null
@@ -1,712 +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$
-____________________________________________________________________________*/
-
-/*----- iwinbq.c ---------------------------------------------------
-
-portable c
-mpeg1/2 Layer I/II audio decode
-
-conditional include to iwinm.c
-
-quick integer window - 8 bit output
-
-mods 1/8/97 warnings
-
---------------------------------------------------------------*/
-/*--------------------------------------------------------------------*/
-void i_windowB(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-}
-/*------------------------------------------------------------*/
-void i_windowB_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
-/* dual window interleaves output */
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-void i_windowB_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
-/* right identical to dual, for asm */
-/* dual window interleaves output */
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 16 --*/
- si = (vb_ptr + (16 + 3 * 64)) & 511;
- bx = (si + (32 + 512 - 3 * 64 + 2 * 64)) & 511;
- coef = iwincoef;
- for (i = 0; i < 16; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 64) & 511;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 64 + 1)) & 511;
- bx = (bx + (64 + 4 * 64 - 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (512 - 64)) & 511;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 15 --*/
- coef = iwincoef + 111; /* back pass through coefs */
- si = (si + (512 - 3 * 64 + 2 * 64 - 1)) & 511;
- bx = (bx + (64 + 3 * 64 + 2 * 64 + 1)) & 511;
- for (i = 0; i < 15; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 64) & 511;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 64) & 511;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (64 - 1 + 4 * 64)) & 511;
- bx = (bx + (5 * 64 + 1)) & 511;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*------------------------------------------------------------*/
-/*------------------- 16 pt window ------------------------------*/
-void i_windowB16(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-}
-/*--------------- 16 pt dual window (interleaved output) -----------------*/
-void i_windowB16_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*--------------- 16 pt dual window (interleaved output) -----------------*/
-void i_windowB16_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
-/* right identical to dual, for asm */
- int i, j;
- unsigned char si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-
-/*-- first 8 --*/
- si = (unsigned char) (vb_ptr + 8 + 3 * 32);
- bx = (unsigned char) (si + (16 + 256 - 3 * 32 + 2 * 32));
- coef = iwincoef;
- for (i = 0; i < 8; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef++));
- si += 32;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si += (5 * 32 + 1);
- bx += (32 + 4 * 32 - 1);
- coef += 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx += (256 - 32);
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx += 32;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 7 --*/
- coef = iwincoef + (111 - 7); /* back pass through coefs */
- si += (256 + -3 * 32 + 2 * 32 - 1);
- bx += (32 + 3 * 32 + 2 * 32 + 1);
- for (i = 0; i < 7; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si += 32;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx += 32;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si += (32 - 1 + 4 * 32);
- bx += (5 * 32 + 1);
- coef -= 7;
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*------------------- 8 pt window ------------------------------*/
-void i_windowB8(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm++ = (unsigned char) ((sum >> 8) ^ 0x80);
- }
-}
-/*--------------- 8 pt dual window (interleaved output) --------------*/
-void i_windowB8_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*------------------------------------------------------------*/
-/*--------------- 8 pt dual window (interleaved output) --------------*/
-void i_windowB8_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm)
-{
- int i, j;
- unsigned int si, bx;
- WINCOEF *coef;
- INT32 sum;
-
-/* right identical to dual, for asm */
-
-/*-- first 4 --*/
- si = (vb_ptr + (4 + 3 * 16)) & 127;
- bx = (si + (8 + 128 - 3 * 16 + 2 * 16)) & 127;
- coef = iwincoef;
- for (i = 0; i < 4; i++)
- {
- sum = -WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef++));
- si = (si + 16) & 127;
- sum -= WINMULT(vbuf[bx], (*coef++));
- }
- si = (si + (5 * 16 + 1)) & 127;
- bx = (bx + (16 + 4 * 16 - 1)) & 127;
- coef += (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-/*-- special case --*/
- bx = (bx + (128 - 16)) & 127;
- sum = WINMULT(vbuf[bx], (*coef++));
- for (j = 0; j < 3; j++)
- {
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef++));
- }
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
-
-/*-- last 3 --*/
- coef = iwincoef + (111 - 3 * 7); /* back pass through coefs */
- si = (si + (128 - 3 * 16 + 2 * 16 - 1)) & 127;
- bx = (bx + (16 + 3 * 16 + 2 * 16 + 1)) & 127;
- for (i = 0; i < 3; i++)
- {
- sum = WINMULT(vbuf[si], (*coef--));
- for (j = 0; j < 3; j++)
- {
- si = (si + 16) & 127;
- sum += WINMULT(vbuf[bx], (*coef--));
- bx = (bx + 16) & 127;
- sum += WINMULT(vbuf[si], (*coef--));
- }
- si = (si + (16 - 1 + 4 * 16)) & 127;
- bx = (bx + (5 * 16 + 1)) & 127;
- coef -= (3 * 7);
- sum >>= WINBITS;
- if (sum > 32767)
- sum = 32767;
- else if (sum < -32768)
- sum = -32768;
- *pcm = (unsigned char) ((sum >> 8) ^ 0x80);
- pcm += 2;
- }
-}
-/*--------------------------------------------------------*/
diff --git a/codecs/mp3/src/iwinm.c b/codecs/mp3/src/iwinm.c
deleted file mode 100755
index 11cfef33a0..0000000000
--- a/codecs/mp3/src/iwinm.c
+++ /dev/null
@@ -1,64 +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$
-____________________________________________________________________________*/
-
-/**** iwinm.c ***************************************************
-
-MPEG audio decoder, window master
-portable C integer version of cwinm.c
-
-
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "itype.h"
-
-/*-------------------------------------------------------------------------*/
-/* public vbuf's */
-WININT vbuf[512];
-WININT vbuf2[512];
-
-/*-- integer point window coefs ---*/
-/*-- quick uses only first 116 ----*/
-static WINCOEF iwincoef[264];
-
-/*==================================================================*/
-WINCOEF *i_wincoef_addr(void)
-{
- return iwincoef;
-}
-/*-------------------------------------------------------------------*/
-#ifdef FULL_INTEGER
-#include "iwin.c"
-#include "iwinb.c"
-#else
-#include "iwinQ.c"
-#include "iwinbQ.c"
-#endif
-/*-------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/l3dq.c b/codecs/mp3/src/l3dq.c
deleted file mode 100755
index 3ee0764aa5..0000000000
--- a/codecs/mp3/src/l3dq.c
+++ /dev/null
@@ -1,256 +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$
-____________________________________________________________________________*/
-
-/**** quant.c ***************************************************
- Layer III dequant
-
- does reordering of short blocks
-
- mod 8/19/98 decode 22 sf bands
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include <string.h>
-#include "L3.h"
-#include "mhead.h"
-#include "protos.h"
-
-
-/*----------
-static struct {
-int l[23];
-int s[14];} sfBandTable[3] =
-{{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
- {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
-{{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
- {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
-{{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
- {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
-----------*/
-
-/*--------------------------------*/
-static int pretab[2][22] =
-{
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0},
-};
-
-
-/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
-/* two extra slots to do 1/sqrt(2) scaling for ms */
-/* 4 extra slots to do 1/2 scaling for cvt to mono */
-
-/*-------- scaling lookup
-x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
-look_scale[scalefact_scale][preemp][scalefac]
------------------------*/
-#if 0
-typedef float LS[4][32];
-#endif
-
-/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
-
-/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
-
-/*-- reorder buffer ---*/
-typedef float ARRAY3[3];
-
-
-/*=============================================================*/
-float *quant_init_global_addr(MPEG *m)
-{
- return m->cupl.look_global;
-}
-/*-------------------------------------------------------------*/
-LS *quant_init_scale_addr(MPEG *m)
-{
- return m->cupl.look_scale;
-}
-/*-------------------------------------------------------------*/
-float *quant_init_pow_addr(MPEG *m)
-{
- return m->cupl.look_pow;
-}
-/*-------------------------------------------------------------*/
-float *quant_init_subblock_addr(MPEG *m)
-{
- return m->cupl.look_subblock;
-}
-/*=============================================================*/
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4056)
-#endif
-
-void dequant(MPEG *m, SAMPLE Sample[], int *nsamp,
- SCALEFACT * sf,
- GR * gr,
- CB_INFO * cb_info, int ncbl_mixed)
-{
- int i, j;
- int cb, n, w;
- float x0, xs;
- float xsb[3];
- double tmp;
- int ncbl;
- int cbs0;
- ARRAY3 *buf; /* short block reorder */
- int nbands;
- int i0;
- int non_zero;
- int cbmax[3];
-
- nbands = *nsamp;
-
-
- ncbl = 22; /* long block cb end */
- cbs0 = 12; /* short block cb start */
-/* ncbl_mixed = 8 or 6 mpeg1 or 2 */
- if (gr->block_type == 2)
- {
- ncbl = 0;
- cbs0 = 0;
- if (gr->mixed_block_flag)
- {
- ncbl = ncbl_mixed;
- cbs0 = 3;
- }
- }
-/* fill in cb_info -- */
- /* This doesn't seem used anywhere...
- cb_info->lb_type = gr->block_type;
- if (gr->block_type == 2)
- cb_info->lb_type;
- */
- cb_info->cbs0 = cbs0;
- cb_info->ncbl = ncbl;
-
- cbmax[2] = cbmax[1] = cbmax[0] = 0;
-/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
- x0 = m->cupl.look_global[(2 + 4) + gr->global_gain];
- i = 0;
-/*----- long blocks ---*/
- for (cb = 0; cb < ncbl; cb++)
- {
- non_zero = 0;
- xs = x0 * m->cupl.look_scale[gr->scalefac_scale][pretab[gr->preflag][cb]][sf->l[cb]];
- n = m->cupl.nBand[0][cb];
- for (j = 0; j < n; j++, i++)
- {
- if (Sample[i].s == 0)
- Sample[i].x = 0.0F;
- else
- {
- non_zero = 1;
- if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
- Sample[i].x = xs * m->cupl.look_pow[ISMAX + Sample[i].s];
- else
- {
- float tmpConst = (float)(1.0/3.0);
- tmp = (double) Sample[i].s;
- Sample[i].x = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
- }
- }
- }
- if (non_zero)
- cbmax[0] = cb;
- if (i >= nbands)
- break;
- }
-
- cb_info->cbmax = cbmax[0];
- cb_info->cbtype = 0; // type = long
-
- if (cbs0 >= 12)
- return;
-/*---------------------------
-block type = 2 short blocks
-----------------------------*/
- cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
- i0 = i; /* save for reorder */
- buf = m->cupl.re_buf;
- for (w = 0; w < 3; w++)
- xsb[w] = x0 * m->cupl.look_subblock[gr->subblock_gain[w]];
- for (cb = cbs0; cb < 13; cb++)
- {
- n = m->cupl.nBand[1][cb];
- for (w = 0; w < 3; w++)
- {
- non_zero = 0;
- xs = xsb[w] * m->cupl.look_scale[gr->scalefac_scale][0][sf->s[w][cb]];
- for (j = 0; j < n; j++, i++)
- {
- if (Sample[i].s == 0)
- buf[j][w] = 0.0F;
- else
- {
- non_zero = 1;
- if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
- buf[j][w] = xs * m->cupl.look_pow[ISMAX + Sample[i].s];
- else
- {
- float tmpConst = (float)(1.0/3.0);
- tmp = (double) Sample[i].s;
- buf[j][w] = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
- }
- }
- }
- if (non_zero)
- cbmax[w] = cb;
- }
- if (i >= nbands)
- break;
- buf += n;
- }
-
-
- memmove(&Sample[i0].x, &m->cupl.re_buf[0][0], sizeof(float) * (i - i0));
-
- *nsamp = i; /* update nsamp */
- cb_info->cbmax_s[0] = cbmax[0];
- cb_info->cbmax_s[1] = cbmax[1];
- cb_info->cbmax_s[2] = cbmax[2];
- if (cbmax[1] > cbmax[0])
- cbmax[0] = cbmax[1];
- if (cbmax[2] > cbmax[0])
- cbmax[0] = cbmax[2];
-
- cb_info->cbmax = cbmax[0];
- cb_info->cbtype = 1; /* type = short */
-
-
- return;
-}
-
-#ifdef _MSC_VER
-#pragma warning(default: 4056)
-#endif
-
-/*-------------------------------------------------------------*/
diff --git a/codecs/mp3/src/l3init.c b/codecs/mp3/src/l3init.c
deleted file mode 100755
index 290d4e3172..0000000000
--- a/codecs/mp3/src/l3init.c
+++ /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$
-____________________________________________________________________________*/
-
-/**** tinit.c ***************************************************
- Layer III init tables
-
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "L3.h"
-#include "mhead.h"
-#include "protos.h"
-
-/* get rid of precision loss warnings on conversion */
-#ifdef _MSC_VER
-#pragma warning(disable:4244 4056)
-#endif
-
-
-
-static const float Ci[8] =
-{
- -0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f};
-
-
-void hwin_init(MPEG *m); /* hybrid windows -- */
-void imdct_init(MPEG *m);
-typedef struct
-{
- float *w;
- float *w2;
- void *coef;
-}
-IMDCT_INIT_BLOCK;
-
-void msis_init(MPEG *m);
-void msis_init_MPEG2(MPEG *m);
-
-/*=============================================================*/
-int L3table_init(MPEG *m)
-{
- int i;
- float *x;
- LS *ls;
- int scalefact_scale, preemp, scalefac;
- double tmp;
- PAIR *csa;
-
-/*================ quant ===============================*/
-
-/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
-/* extra 2 for ms scaling by 1/sqrt(2) */
-/* extra 4 for cvt to mono scaling by 1/2 */
- x = quant_init_global_addr(m);
- for (i = 0; i < 256 + 2 + 4; i++)
- x[i] = (float) pow(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
-
-
-/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
- ls = quant_init_scale_addr(m);
- for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
- {
- for (preemp = 0; preemp < 4; preemp++)
- {
- for (scalefac = 0; scalefac < 32; scalefac++)
- {
- ls[scalefact_scale][preemp][scalefac] =
- (float) pow(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
- }
- }
- }
-
-/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
- x = quant_init_pow_addr(m);
- for (i = 0; i < 64; i++)
- {
- tmp = i - 32;
- x[i] = (float) (tmp * pow(fabs(tmp), (1.0 / 3.0)));
- }
-
-
-/*-- pow(2.0, -0.25*8.0*subblock_gain) 3 bits --*/
- x = quant_init_subblock_addr(m);
- for (i = 0; i < 8; i++)
- {
- x[i] = (float) pow(2.0, 0.25 * -8.0 * i);
- }
-
-/*-------------------------*/
-// quant_init_sf_band(sr_index); replaced by code in sup.c
-
-
-/*================ antialias ===============================*/
- csa = alias_init_addr(m);
- for (i = 0; i < 8; i++)
- {
- csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
- csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
- }
-
-
-/*================ msis ===============================*/
- msis_init(m);
- msis_init_MPEG2(m);
-
-/*================ imdct ===============================*/
- imdct_init(m);
-
-/*--- hybrid windows ------------*/
- hwin_init(m);
-
- return 0;
-}
-/*====================================================================*/
-typedef float ARRAY36[36];
-ARRAY36 *hwin_init_addr(MPEG *m);
-
-/*--------------------------------------------------------------------*/
-void hwin_init(MPEG *m)
-{
- int i, j;
- double pi;
- ARRAY36 *win;
-
- win = hwin_init_addr(m);
-
- pi = 4.0 * atan(1.0);
-
-/* type 0 */
- for (i = 0; i < 36; i++)
- win[0][i] = (float) sin(pi / 36 * (i + 0.5));
-
-/* type 1 */
- for (i = 0; i < 18; i++)
- win[1][i] = (float) sin(pi / 36 * (i + 0.5));
- for (i = 18; i < 24; i++)
- win[1][i] = 1.0F;
- for (i = 24; i < 30; i++)
- win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
- for (i = 30; i < 36; i++)
- win[1][i] = 0.0F;
-
-/* type 3 */
- for (i = 0; i < 6; i++)
- win[3][i] = 0.0F;
- for (i = 6; i < 12; i++)
- win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
- for (i = 12; i < 18; i++)
- win[3][i] = 1.0F;
- for (i = 18; i < 36; i++)
- win[3][i] = (float) sin(pi / 36 * (i + 0.5));
-
-/* type 2 */
- for (i = 0; i < 12; i++)
- win[2][i] = (float) sin(pi / 12 * (i + 0.5));
- for (i = 12; i < 36; i++)
- win[2][i] = 0.0F;
-
-/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
- for (j = 0; j < 4; j++)
- {
- if (j == 2)
- continue;
- for (i = 9; i < 36; i++)
- win[j][i] = -win[j][i];
- }
-
-/*-- invert signs for short blocks --*/
- for (i = 3; i < 12; i++)
- win[2][i] = -win[2][i];
-
- return;
-}
-/*=============================================================*/
-typedef float ARRAY4[4];
-IMDCT_INIT_BLOCK *imdct_init_addr_18(void);
-IMDCT_INIT_BLOCK *imdct_init_addr_6(void);
-
-/*-------------------------------------------------------------*/
-void imdct_init(MPEG *m)
-{
- int k, p, n;
- double t, pi;
- IMDCT_INIT_BLOCK *addr;
- float *w, *w2;
- float *v, *v2, *coef87;
- ARRAY4 *coef;
-
-/*--- 18 point --*/
- addr = imdct_init_addr_18();
- w = addr->w;
- w2 = addr->w2;
- coef = addr->coef;
-/*----*/
- n = 18;
- pi = 4.0 * atan(1.0);
- t = pi / (4 * n);
- for (p = 0; p < n; p++)
- w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
- for (p = 0; p < 9; p++)
- w2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
-
- t = pi / (2 * n);
- for (k = 0; k < 9; k++)
- {
- for (p = 0; p < 4; p++)
- coef[k][p] = (float) cos(t * (2 * k) * (2 * p + 1));
- }
-
-/*--- 6 point */
- addr = imdct_init_addr_6();
- v = addr->w;
- v2 = addr->w2;
- coef87 = addr->coef;
-/*----*/
- n = 6;
- pi = 4.0 * atan(1.0);
- t = pi / (4 * n);
- for (p = 0; p < n; p++)
- v[p] = (float) 2.0 *cos(t * (2 * p + 1));
-
- for (p = 0; p < 3; p++)
- v2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
-
- t = pi / (2 * n);
- k = 1;
- p = 0;
- *coef87 = (float) cos(t * (2 * k) * (2 * p + 1));
-/* adjust scaling to save a few mults */
- for (p = 0; p < 6; p++)
- v[p] = v[p] / 2.0f;
- *coef87 = (float) 2.0 *(*coef87);
-
-
- return;
-}
-/*===============================================================*/
-typedef float ARRAY8_2[8][2];
-ARRAY8_2 *msis_init_addr(MPEG *m);
-
-/*-------------------------------------------------------------*/
-void msis_init(MPEG *m)
-{
- int i;
- double s, c;
- double pi;
- double t;
- ARRAY8_2 *lr;
-
- lr = msis_init_addr(m);
-
-
- pi = 4.0 * atan(1.0);
- t = pi / 12.0;
- for (i = 0; i < 7; i++)
- {
- s = sin(i * t);
- c = cos(i * t);
- /* ms_mode = 0 */
- lr[0][i][0] = (float) (s / (s + c));
- lr[0][i][1] = (float) (c / (s + c));
- /* ms_mode = 1 */
- lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
- lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
- }
-/* sf = 7 */
-/* ms_mode = 0 */
- lr[0][i][0] = 1.0f;
- lr[0][i][1] = 0.0f;
-/* ms_mode = 1, in is bands is routine does ms processing */
- lr[1][i][0] = 1.0f;
- lr[1][i][1] = 1.0f;
-
-
-/*-------
-for(i=0;i<21;i++) nBand[0][i] =
- sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
-for(i=0;i<12;i++) nBand[1][i] =
- sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
--------------*/
-
-}
-/*-------------------------------------------------------------*/
-/*===============================================================*/
-typedef float ARRAY2_64_2[2][64][2];
-ARRAY2_64_2 *msis_init_addr_MPEG2(MPEG *m);
-
-/*-------------------------------------------------------------*/
-void msis_init_MPEG2(MPEG *m)
-{
- int k, n;
- double t;
- ARRAY2_64_2 *lr;
- int intensity_scale, ms_mode, sf, sflen;
- float ms_factor[2];
-
-
- ms_factor[0] = 1.0;
- ms_factor[1] = (float) sqrt(2.0);
-
- lr = msis_init_addr_MPEG2(m);
-
-/* intensity stereo MPEG2 */
-/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
-
- for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
- {
- t = pow(2.0, -0.25 * (1 + intensity_scale));
- for (ms_mode = 0; ms_mode < 2; ms_mode++)
- {
-
- n = 1;
- k = 0;
- for (sflen = 0; sflen < 6; sflen++)
- {
- for (sf = 0; sf < (n - 1); sf++, k++)
- {
- if (sf == 0)
- {
- lr[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
- lr[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
- }
- else if ((sf & 1))
- {
- lr[intensity_scale][ms_mode][k][0] =
- (float) (ms_factor[ms_mode] * pow(t, (sf + 1) / 2));
- lr[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
- }
- else
- {
- lr[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
- lr[intensity_scale][ms_mode][k][1] =
- (float) (ms_factor[ms_mode] * pow(t, sf / 2));
- }
- }
-
- /* illegal is_pos used to do ms processing */
- if (ms_mode == 0)
- { /* ms_mode = 0 */
- lr[intensity_scale][ms_mode][k][0] = 1.0f;
- lr[intensity_scale][ms_mode][k][1] = 0.0f;
- }
- else
- {
- /* ms_mode = 1, in is bands is routine does ms processing */
- lr[intensity_scale][ms_mode][k][0] = 1.0f;
- lr[intensity_scale][ms_mode][k][1] = 1.0f;
- }
- k++;
- n = n + n;
- }
- }
- }
-
-}
-/*-------------------------------------------------------------*/
diff --git a/codecs/mp3/src/mdct.c b/codecs/mp3/src/mdct.c
deleted file mode 100755
index fa1b92416a..0000000000
--- a/codecs/mp3/src/mdct.c
+++ /dev/null
@@ -1,239 +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$
-____________________________________________________________________________*/
-
-/**** mdct.c ***************************************************
-
-Layer III
-
- cos transform for n=18, n=6
-
-computes c[k] = Sum( cos((pi/4*n)*(2*k+1)*(2*p+1))*f[p] )
- k = 0, ...n-1, p = 0...n-1
-
-
-inplace ok.
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-
-#ifdef ASM_X86
-extern void imdct18_asm(float f[18]);
-extern void imdct6_3_asm(float f[]);
-#endif /* ASM_X86 */
-
-/*------ 18 point xform -------*/
-float mdct18w[18];
-float mdct18w2[9];
-float coef[9][4];
-
-float mdct6_3v[6];
-float mdct6_3v2[3];
-float coef87;
-
-typedef struct
-{
- float *w;
- float *w2;
- void *coef;
-}
-IMDCT_INIT_BLOCK;
-
-static IMDCT_INIT_BLOCK imdct_info_18 =
-{mdct18w, mdct18w2, coef};
-static IMDCT_INIT_BLOCK imdct_info_6 =
-{mdct6_3v, mdct6_3v2, &coef87};
-
-/*====================================================================*/
-IMDCT_INIT_BLOCK *imdct_init_addr_18(void)
-{
- return &imdct_info_18;
-}
-IMDCT_INIT_BLOCK *imdct_init_addr_6(void)
-{
- return &imdct_info_6;
-}
-/*--------------------------------------------------------------------*/
-void imdct18(float f[18]) /* 18 point */
-{
-#ifdef ASM_X86
- imdct18_asm(f);
-#else
- int p;
- float a[9], b[9];
- float ap, bp, a8p, b8p;
- float g1, g2;
-
-
- for (p = 0; p < 4; p++)
- {
- g1 = mdct18w[p] * f[p];
- g2 = mdct18w[17 - p] * f[17 - p];
- ap = g1 + g2; // a[p]
-
- bp = mdct18w2[p] * (g1 - g2); // b[p]
-
- g1 = mdct18w[8 - p] * f[8 - p];
- g2 = mdct18w[9 + p] * f[9 + p];
- a8p = g1 + g2; // a[8-p]
-
- b8p = mdct18w2[8 - p] * (g1 - g2); // b[8-p]
-
- a[p] = ap + a8p;
- a[5 + p] = ap - a8p;
- b[p] = bp + b8p;
- b[5 + p] = bp - b8p;
- }
- g1 = mdct18w[p] * f[p];
- g2 = mdct18w[17 - p] * f[17 - p];
- a[p] = g1 + g2;
- b[p] = mdct18w2[p] * (g1 - g2);
-
-
- f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
- f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
-
- f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
- + coef[1][3] * a[8];
- f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
- + coef[1][3] * b[8] - f[1];
- f[1] = f[1] - f[0];
- f[2] = f[2] - f[1];
-
- f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
- + coef[2][3] * a[3] - a[4];
- f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
- + coef[2][3] * b[3] - b[4] - f[3];
- f[3] = f[3] - f[2];
- f[4] = f[4] - f[3];
-
- f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
- f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
- f[5] = f[5] - f[4];
- f[6] = f[6] - f[5];
-
- f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
- + coef[4][3] * a[3] + a[4];
- f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
- + coef[4][3] * b[3] + b[4] - f[7];
- f[7] = f[7] - f[6];
- f[8] = f[8] - f[7];
-
- f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
- + coef[5][3] * a[8];
- f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
- + coef[5][3] * b[8] - f[9];
- f[9] = f[9] - f[8];
- f[10] = f[10] - f[9];
-
- f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
- f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
- f[11] = f[11] - f[10];
- f[12] = f[12] - f[11];
-
- f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
- + coef[7][3] * a[8];
- f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
- + coef[7][3] * b[8] - f[13];
- f[13] = f[13] - f[12];
- f[14] = f[14] - f[13];
-
- f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
- + coef[8][3] * a[3] + a[4];
- f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
- + coef[8][3] * b[3] + b[4] - f[15];
- f[15] = f[15] - f[14];
- f[16] = f[16] - f[15];
- f[17] = f[17] - f[16];
-
-
- return;
-#endif
-}
-/*--------------------------------------------------------------------*/
-/* does 3, 6 pt dct. changes order from f[i][window] c[window][i] */
-void imdct6_3(float f[]) /* 6 point */
-{
-#ifdef ASM_X86
- imdct6_3_asm(f);
-#else
- int w;
- float buf[18];
- float *a, *c; // b[i] = a[3+i]
-
- float g1, g2;
- float a02, b02;
-
- c = f;
- a = buf;
- for (w = 0; w < 3; w++)
- {
- g1 = mdct6_3v[0] * f[3 * 0];
- g2 = mdct6_3v[5] * f[3 * 5];
- a[0] = g1 + g2;
- a[3 + 0] = mdct6_3v2[0] * (g1 - g2);
-
- g1 = mdct6_3v[1] * f[3 * 1];
- g2 = mdct6_3v[4] * f[3 * 4];
- a[1] = g1 + g2;
- a[3 + 1] = mdct6_3v2[1] * (g1 - g2);
-
- g1 = mdct6_3v[2] * f[3 * 2];
- g2 = mdct6_3v[3] * f[3 * 3];
- a[2] = g1 + g2;
- a[3 + 2] = mdct6_3v2[2] * (g1 - g2);
-
- a += 6;
- f++;
- }
-
- a = buf;
- for (w = 0; w < 3; w++)
- {
- a02 = (a[0] + a[2]);
- b02 = (a[3 + 0] + a[3 + 2]);
- c[0] = a02 + a[1];
- c[1] = b02 + a[3 + 1];
- c[2] = coef87 * (a[0] - a[2]);
- c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
- c[1] = c[1] - c[0];
- c[2] = c[2] - c[1];
- c[4] = a02 - a[1] - a[1];
- c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
- c[3] = c[3] - c[2];
- c[4] = c[4] - c[3];
- c[5] = c[5] - c[4];
- a += 6;
- c += 6;
- }
-
- return;
-#endif
-}
-/*--------------------------------------------------------------------*/
diff --git a/codecs/mp3/src/mhead.c b/codecs/mp3/src/mhead.c
deleted file mode 100755
index d368f095fe..0000000000
--- a/codecs/mp3/src/mhead.c
+++ /dev/null
@@ -1,321 +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$
-____________________________________________________________________________*/
-
-/*------------ mhead.c ----------------------------------------------
- mpeg audio
- extract info from mpeg header
- portable version (adapted from c:\eco\mhead.c
-
- add Layer III
-
- mods 6/18/97 re mux restart, 32 bit ints
-
- mod 5/7/98 parse mpeg 2.5
-
----------------------------------------------------------------------*/
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "L3.h"
-#include "mhead.h" /* mpeg header structure */
-
-static int mp_br_table[2][16] =
-{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
- {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}};
-static int mp_sr20_table[2][4] =
-{{441, 480, 320, -999}, {882, 960, 640, -999}};
-
-static int mp_br_tableL1[2][16] =
-{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},/* mpeg2 */
- {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0}};
-
-static int mp_br_tableL3[2][16] =
-{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}, /* mpeg 2 */
- {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
-
-
-
-static int find_sync(unsigned char *buf, int n);
-static int sync_scan(unsigned char *buf, int n, int i0);
-static int sync_test(unsigned char *buf, int n, int isync, int padbytes);
-
-// jdw
-extern unsigned int g_jdw_additional;
-
-/*--------------------------------------------------------------*/
-int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h)
-{
- int framebytes;
- int mpeg25_flag;
-
- if (n > 10000)
- n = 10000; /* limit scan for free format */
-
-
-
- h->sync = 0;
- //if ((buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xF0))
- if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xF0))
- {
- mpeg25_flag = 0; // mpeg 1 & 2
-
- }
- else if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xE0))
- {
- mpeg25_flag = 1; // mpeg 2.5
-
- }
- else
- return 0; // sync fail
-
- h->sync = 1;
- if (mpeg25_flag)
- h->sync = 2; //low bit clear signals mpeg25 (as in 0xFFE)
-
- h->id = (buf[0+1] & 0x08) >> 3;
- h->option = (buf[0+1] & 0x06) >> 1;
- h->prot = (buf[0+1] & 0x01);
-
- h->br_index = (buf[0+2] & 0xf0) >> 4;
- h->sr_index = (buf[0+2] & 0x0c) >> 2;
- h->pad = (buf[0+2] & 0x02) >> 1;
- h->private_bit = (buf[0+2] & 0x01);
- h->mode = (buf[0+3] & 0xc0) >> 6;
- h->mode_ext = (buf[0+3] & 0x30) >> 4;
- h->cr = (buf[0+3] & 0x08) >> 3;
- h->original = (buf[0+3] & 0x04) >> 2;
- h->emphasis = (buf[0+3] & 0x03);
-
-
-// if( mpeg25_flag ) {
- // if( h->sr_index == 2 ) return 0; // fail 8khz
- //}
-
-
-/* compute framebytes for Layer I, II, III */
- if (h->option < 1)
- return 0;
- if (h->option > 3)
- return 0;
-
- framebytes = 0;
-
- if (h->br_index > 0)
- {
- if (h->option == 3)
- { /* layer I */
- framebytes =
- 240 * mp_br_tableL1[h->id][h->br_index]
- / mp_sr20_table[h->id][h->sr_index];
- framebytes = 4 * framebytes;
- }
- else if (h->option == 2)
- { /* layer II */
- framebytes =
- 2880 * mp_br_table[h->id][h->br_index]
- / mp_sr20_table[h->id][h->sr_index];
- }
- else if (h->option == 1)
- { /* layer III */
- if (h->id)
- { // mpeg1
-
- framebytes =
- 2880 * mp_br_tableL3[h->id][h->br_index]
- / mp_sr20_table[h->id][h->sr_index];
- }
- else
- { // mpeg2
-
- if (mpeg25_flag)
- { // mpeg2.2
-
- framebytes =
- 2880 * mp_br_tableL3[h->id][h->br_index]
- / mp_sr20_table[h->id][h->sr_index];
- }
- else
- {
- framebytes =
- 1440 * mp_br_tableL3[h->id][h->br_index]
- / mp_sr20_table[h->id][h->sr_index];
- }
- }
- }
- }
- else
- framebytes = find_sync(buf, n); /* free format */
-
- return framebytes;
-}
-
-int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int *br, unsigned int *searchForward) {
- unsigned int pBuf = 0;
- // jdw insertion...
- while ((pBuf < n) && !((buf[pBuf] == 0xFF) &&
- ((buf[pBuf+1] & 0xF0) == 0xF0 || (buf[pBuf+1] & 0xF0) == 0xE0)))
- {
- pBuf++;
- }
-
- if (pBuf == n) return 0;
-
- *searchForward = pBuf;
- return head_info2(&(buf[pBuf]),n,h,br);
-
-}
-
-/*--------------------------------------------------------------*/
-int head_info2(unsigned char *buf, unsigned int n, MPEG_HEAD * h, int *br)
-{
- int framebytes;
-
-/*--- return br (in bits/sec) in addition to frame bytes ---*/
-
- *br = 0;
-/*-- assume fail --*/
- framebytes = head_info(buf, n, h);
-
- if (framebytes == 0)
- return 0;
-
- if (h->option == 1)
- { /* layer III */
- if (h->br_index > 0)
- *br = 1000 * mp_br_tableL3[h->id][h->br_index];
- else
- {
- if (h->id) // mpeg1
-
- *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (144 * 20);
- else
- { // mpeg2
-
- if ((h->sync & 1) == 0) // flags mpeg25
-
- *br = 500 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
- else
- *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
- }
- }
- }
- if (h->option == 2)
- { /* layer II */
- if (h->br_index > 0)
- *br = 1000 * mp_br_table[h->id][h->br_index];
- else
- *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]
- / (144 * 20);
- }
- if (h->option == 3)
- { /* layer I */
- if (h->br_index > 0)
- *br = 1000 * mp_br_tableL1[h->id][h->br_index];
- else
- *br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]
- / (48 * 20);
- }
-
-
- return framebytes;
-}
-/*--------------------------------------------------------------*/
-static int compare(unsigned char *buf, unsigned char *buf2)
-{
- if (buf[0] != buf2[0])
- return 0;
- if (buf[1] != buf2[1])
- return 0;
- return 1;
-}
-/*----------------------------------------------------------*/
-/*-- does not scan for initial sync, initial sync assumed --*/
-static int find_sync(unsigned char *buf, int n)
-{
- int i0, isync, nmatch, pad;
- int padbytes, option;
-
-/* mod 4/12/95 i0 change from 72, allows as low as 8kbits for mpeg1 */
- i0 = 24;
- padbytes = 1;
- option = (buf[1] & 0x06) >> 1;
- if (option == 3)
- {
- padbytes = 4;
- i0 = 24; /* for shorter layer I frames */
- }
-
- pad = (buf[2] & 0x02) >> 1;
-
- n -= 3; /* need 3 bytes of header */
-
- while (i0 < 2000)
- {
- isync = sync_scan(buf, n, i0);
- i0 = isync + 1;
- isync -= pad;
- if (isync <= 0)
- return 0;
- nmatch = sync_test(buf, n, isync, padbytes);
- if (nmatch > 0)
- return isync;
- }
-
- return 0;
-}
-/*------------------------------------------------------*/
-/*---- scan for next sync, assume start is valid -------*/
-/*---- return number bytes to next sync ----------------*/
-static int sync_scan(unsigned char *buf, int n, int i0)
-{
- int i;
-
- for (i = i0; i < n; i++)
- if (compare(buf, buf + i))
- return i;
-
- return 0;
-}
-/*------------------------------------------------------*/
-/*- test consecutative syncs, input isync without pad --*/
-static int sync_test(unsigned char *buf, int n, int isync, int padbytes)
-{
- int i, nmatch, pad;
-
- nmatch = 0;
- for (i = 0;;)
- {
- pad = padbytes * ((buf[i + 2] & 0x02) >> 1);
- i += (pad + isync);
- if (i > n)
- break;
- if (!compare(buf, buf + i))
- return -nmatch;
- nmatch++;
- }
- return nmatch;
-}
diff --git a/codecs/mp3/src/msis.c b/codecs/mp3/src/msis.c
deleted file mode 100755
index a30e534b96..0000000000
--- a/codecs/mp3/src/msis.c
+++ /dev/null
@@ -1,300 +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$
-____________________________________________________________________________*/
-
-/**** msis.c ***************************************************
- Layer III
- antialias, ms and is stereo precessing
-
-**** is_process assumes never switch
- from short to long in is region *****
-
-is_process does ms or stereo in "forbidded sf regions"
- //ms_mode = 0
- lr[0][i][0] = 1.0f;
- lr[0][i][1] = 0.0f;
- // ms_mode = 1, in is bands is routine does ms processing
- lr[1][i][0] = 1.0f;
- lr[1][i][1] = 1.0f;
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "L3.h"
-#include "mhead.h"
-
-/* The functions are different than their prototypes, by design */
-
-typedef float ARRAY2[2];
-typedef float ARRAY8_2[8][2];
-
-
-/* nBand[0] = long, nBand[1] = short */
-
-/* intensity stereo */
-/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
- compensates */
-
-
-/* intensity stereo MPEG2 */
-/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
-typedef float ARRAY2_64_2[2][64][2];
-typedef float ARRAY64_2[64][2];
-
-#ifdef ASM_X86
-extern void antialias_asm(float x[], int n);
-#endif /* ASM_X86 */
-
-
-/*===============================================================*/
-ARRAY2 *alias_init_addr(MPEG *m)
-{
- return m->cupl.csa;
-}
-/*-----------------------------------------------------------*/
-ARRAY8_2 *msis_init_addr(MPEG *m)
-{
-/*-------
-pi = 4.0*atan(1.0);
-t = pi/12.0;
-for(i=0;i<7;i++) {
- s = sin(i*t);
- c = cos(i*t);
- // ms_mode = 0
- m->cupl.lr[0][i][0] = (float)(s/(s+c));
- m->cupl.lr[0][i][1] = (float)(c/(s+c));
- // ms_mode = 1
- m->cupl.lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
- m->cupl.lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
-}
-//sf = 7
-//ms_mode = 0
-m->cupl.lr[0][i][0] = 1.0f;
-m->cupl.lr[0][i][1] = 0.0f;
-// ms_mode = 1, in is bands is routine does ms processing
-m->cupl.lr[1][i][0] = 1.0f;
-m->cupl.lr[1][i][1] = 1.0f;
-------------*/
-
- return m->cupl.lr;
-}
-/*-------------------------------------------------------------*/
-ARRAY2_64_2 *msis_init_addr_MPEG2(MPEG *m)
-{
- return m->cupl.lr2;
-}
-/*===============================================================*/
-void antialias(MPEG *m, float x[], int n)
-{
-#ifdef ASM_X86
- antialias_asm(x, n);
-#else
- int i, k;
- float a, b;
-
- for (k = 0; k < n; k++)
- {
- for (i = 0; i < 8; i++)
- {
- a = x[17 - i];
- b = x[18 + i];
- x[17 - i] = a * m->cupl.csa[i][0] - b * m->cupl.csa[i][1];
- x[18 + i] = b * m->cupl.csa[i][0] + a * m->cupl.csa[i][1];
- }
- x += 18;
- }
-#endif
-}
-/*===============================================================*/
-void ms_process(float x[][1152], int n) /* sum-difference stereo */
-{
- int i;
- float xl, xr;
-
-/*-- note: sqrt(2) done scaling by dequant ---*/
- for (i = 0; i < n; i++)
- {
- xl = x[0][i] + x[1][i];
- xr = x[0][i] - x[1][i];
- x[0][i] = xl;
- x[1][i] = xr;
- }
- return;
-}
-/*===============================================================*/
-void is_process_MPEG1(MPEG *vm, float x[][1152], /* intensity stereo */
- SCALEFACT * sf,
- CB_INFO cb_info[2], /* [ch] */
- int nsamp, int ms_mode)
-{
- int i, j, n, cb, w;
- float fl, fr;
- int m;
- int isf;
- float fls[3], frs[3];
- int cb0;
-
-
- cb0 = cb_info[1].cbmax; /* start at end of right */
- i = vm->cupl.sfBandIndex[cb_info[1].cbtype][cb0];
- cb0++;
- m = nsamp - i; /* process to len of left */
-
- if (cb_info[1].cbtype)
- goto short_blocks;
-/*------------------------*/
-/* long_blocks: */
- for (cb = cb0; cb < 21; cb++)
- {
- isf = sf->l[cb];
- n = vm->cupl.nBand[0][cb];
- fl = vm->cupl.lr[ms_mode][isf][0];
- fr = vm->cupl.lr[ms_mode][isf][1];
- for (j = 0; j < n; j++, i++)
- {
- if (--m < 0)
- goto exit;
- x[1][i] = fr * x[0][i];
- x[0][i] = fl * x[0][i];
- }
- }
- return;
-/*------------------------*/
- short_blocks:
- for (cb = cb0; cb < 12; cb++)
- {
- for (w = 0; w < 3; w++)
- {
- isf = sf->s[w][cb];
- fls[w] = vm->cupl.lr[ms_mode][isf][0];
- frs[w] = vm->cupl.lr[ms_mode][isf][1];
- }
- n = vm->cupl.nBand[1][cb];
- for (j = 0; j < n; j++)
- {
- m -= 3;
- if (m < 0)
- goto exit;
- x[1][i] = frs[0] * x[0][i];
- x[0][i] = fls[0] * x[0][i];
- x[1][1 + i] = frs[1] * x[0][1 + i];
- x[0][1 + i] = fls[1] * x[0][1 + i];
- x[1][2 + i] = frs[2] * x[0][2 + i];
- x[0][2 + i] = fls[2] * x[0][2 + i];
- i += 3;
- }
- }
-
- exit:
- return;
-}
-/*===============================================================*/
-void is_process_MPEG2(MPEG *vm, float x[][1152], /* intensity stereo */
- SCALEFACT * sf,
- CB_INFO cb_info[2], /* [ch] */
- IS_SF_INFO * is_sf_info,
- int nsamp, int ms_mode)
-{
- int i, j, k, n, cb, w;
- float fl, fr;
- int m;
- int isf;
- int il[21];
- int tmp;
- int r;
- ARRAY2 *lr;
- int cb0, cb1;
-
- lr = vm->cupl.lr2[is_sf_info->intensity_scale][ms_mode];
-
- if (cb_info[1].cbtype)
- goto short_blocks;
-
-/*------------------------*/
-/* long_blocks: */
- cb0 = cb_info[1].cbmax; /* start at end of right */
- i = vm->cupl.sfBandIndex[0][cb0];
- m = nsamp - i; /* process to len of left */
-/* gen sf info */
- for (k = r = 0; r < 3; r++)
- {
- tmp = (1 << is_sf_info->slen[r]) - 1;
- for (j = 0; j < is_sf_info->nr[r]; j++, k++)
- il[k] = tmp;
- }
- for (cb = cb0 + 1; cb < 21; cb++)
- {
- isf = il[cb] + sf->l[cb];
- fl = lr[isf][0];
- fr = lr[isf][1];
- n = vm->cupl.nBand[0][cb];
- for (j = 0; j < n; j++, i++)
- {
- if (--m < 0)
- goto exit;
- x[1][i] = fr * x[0][i];
- x[0][i] = fl * x[0][i];
- }
- }
- return;
-/*------------------------*/
- short_blocks:
-
- for (k = r = 0; r < 3; r++)
- {
- tmp = (1 << is_sf_info->slen[r]) - 1;
- for (j = 0; j < is_sf_info->nr[r]; j++, k++)
- il[k] = tmp;
- }
-
- for (w = 0; w < 3; w++)
- {
- cb0 = cb_info[1].cbmax_s[w]; /* start at end of right */
- i = vm->cupl.sfBandIndex[1][cb0] + w;
- cb1 = cb_info[0].cbmax_s[w]; /* process to end of left */
-
- for (cb = cb0 + 1; cb <= cb1; cb++)
- {
- isf = il[cb] + sf->s[w][cb];
- fl = lr[isf][0];
- fr = lr[isf][1];
- n = vm->cupl.nBand[1][cb];
- for (j = 0; j < n; j++)
- {
- x[1][i] = fr * x[0][i];
- x[0][i] = fl * x[0][i];
- i += 3;
- }
- }
-
- }
-
- exit:
- return;
-}
-/*===============================================================*/
diff --git a/codecs/mp3/src/uph.c b/codecs/mp3/src/uph.c
deleted file mode 100755
index c3cab0a200..0000000000
--- a/codecs/mp3/src/uph.c
+++ /dev/null
@@ -1,505 +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$
-____________________________________________________________________________*/
-
-/**** uph.c ***************************************************
-
-Layer 3 audio
- huffman decode
-
-
-******************************************************************/
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-
-#include "L3.h"
-
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4505)
-#endif
-
-/*===============================================================*/
-
-/* max bits required for any lookup - change if htable changes */
-/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
-#define MAXBITS 9
-
-static HUFF_ELEMENT huff_table_0[4] =
-{{0}, {0}, {0}, {64}}; /* dummy must not use */
-
-#include "htable.h"
-
-/*-- 6 bit lookup (purgebits, value) --*/
-static unsigned char quad_table_a[][2] =
-{
- {6, 11}, {6, 15}, {6, 13}, {6, 14}, {6, 7}, {6, 5}, {5, 9},
- {5, 9}, {5, 6}, {5, 6}, {5, 3}, {5, 3}, {5, 10}, {5, 10},
- {5, 12}, {5, 12}, {4, 2}, {4, 2}, {4, 2}, {4, 2}, {4, 1},
- {4, 1}, {4, 1}, {4, 1}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
- {4, 8}, {4, 8}, {4, 8}, {4, 8}, {1, 0}, {1, 0}, {1, 0},
- {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
- {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
- {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
- {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
- {1, 0},
-};
-
-
-typedef struct
-{
- HUFF_ELEMENT *table;
- int linbits;
- int ncase;
-}
-HUFF_SETUP;
-
-#define no_bits 0
-#define one_shot 1
-#define no_linbits 2
-#define have_linbits 3
-#define quad_a 4
-#define quad_b 5
-
-
-static HUFF_SETUP table_look[] =
-{
- {huff_table_0, 0, no_bits},
- {huff_table_1, 0, one_shot},
- {huff_table_2, 0, one_shot},
- {huff_table_3, 0, one_shot},
- {huff_table_0, 0, no_bits},
- {huff_table_5, 0, one_shot},
- {huff_table_6, 0, one_shot},
- {huff_table_7, 0, no_linbits},
- {huff_table_8, 0, no_linbits},
- {huff_table_9, 0, no_linbits},
- {huff_table_10, 0, no_linbits},
- {huff_table_11, 0, no_linbits},
- {huff_table_12, 0, no_linbits},
- {huff_table_13, 0, no_linbits},
- {huff_table_0, 0, no_bits},
- {huff_table_15, 0, no_linbits},
- {huff_table_16, 1, have_linbits},
- {huff_table_16, 2, have_linbits},
- {huff_table_16, 3, have_linbits},
- {huff_table_16, 4, have_linbits},
- {huff_table_16, 6, have_linbits},
- {huff_table_16, 8, have_linbits},
- {huff_table_16, 10, have_linbits},
- {huff_table_16, 13, have_linbits},
- {huff_table_24, 4, have_linbits},
- {huff_table_24, 5, have_linbits},
- {huff_table_24, 6, have_linbits},
- {huff_table_24, 7, have_linbits},
- {huff_table_24, 8, have_linbits},
- {huff_table_24, 9, have_linbits},
- {huff_table_24, 11, have_linbits},
- {huff_table_24, 13, have_linbits},
- {huff_table_0, 0, quad_a},
- {huff_table_0, 0, quad_b},
-};
-
-/*========================================================*/
-extern BITDAT bitdat;
-
-/*------------- get n bits from bitstream -------------*/
-/* unused
-static unsigned int bitget(int n)
-{
- unsigned int x;
-
- if (bitdat.bits < n)
- { */ /* refill bit buf if necessary */
-/* while (bitdat.bits <= 24)
- {
- bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
- bitdat.bits += 8;
- }
- }
- bitdat.bits -= n;
- x = bitdat.bitbuf >> bitdat.bits;
- bitdat.bitbuf -= x << bitdat.bits;
- return x;
-}
-*/
-/*----- get n bits - checks for n+2 avail bits (linbits+sign) -----*/
-static unsigned int bitget_lb(int n)
-{
- unsigned int x;
-
- if (bitdat.bits < (n + 2))
- { /* refill bit buf if necessary */
- while (bitdat.bits <= 24)
- {
- bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
- bitdat.bits += 8;
- }
- }
- bitdat.bits -= n;
- x = bitdat.bitbuf >> bitdat.bits;
- bitdat.bitbuf -= x << bitdat.bits;
- return x;
-}
-
-
-
-
-/*------------- get n bits but DO NOT remove from bitstream --*/
-static unsigned int bitget2(int n)
-{
- unsigned int x;
-
- if (bitdat.bits < (MAXBITS + 2))
- { /* refill bit buf if necessary */
- while (bitdat.bits <= 24)
- {
- bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
- bitdat.bits += 8;
- }
- }
- x = bitdat.bitbuf >> (bitdat.bits - n);
- return x;
-}
-/*------------- remove n bits from bitstream ---------*/
-/* unused
-static void bitget_purge(int n)
-{
- bitdat.bits -= n;
- bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
-}
-*/
-/*------------- get 1 bit from bitstream NO CHECK -------------*/
-/* unused
-static unsigned int bitget_1bit()
-{
- unsigned int x;
-
- bitdat.bits--;
- x = bitdat.bitbuf >> bitdat.bits;
- bitdat.bitbuf -= x << bitdat.bits;
- return x;
-}
-*/
-/*========================================================*/
-/*========================================================*/
-#define mac_bitget_check(n) if( bitdat.bits < (n) ) { \
- while( bitdat.bits <= 24 ) { \
- bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++; \
- bitdat.bits += 8; \
- } \
-}
-/*---------------------------------------------------------*/
-#define mac_bitget2(n) (bitdat.bitbuf >> (bitdat.bits-n));
-/*---------------------------------------------------------*/
-#define mac_bitget(n) ( bitdat.bits -= n, \
- code = bitdat.bitbuf >> bitdat.bits, \
- bitdat.bitbuf -= code << bitdat.bits, \
- code )
-/*---------------------------------------------------------*/
-#define mac_bitget_purge(n) bitdat.bits -= n, \
- bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
-/*---------------------------------------------------------*/
-#define mac_bitget_1bit() ( bitdat.bits--, \
- code = bitdat.bitbuf >> bitdat.bits, \
- bitdat.bitbuf -= code << bitdat.bits, \
- code )
-/*========================================================*/
-/*========================================================*/
-void unpack_huff(int xy[][2], int n, int ntable)
-{
- int i;
- HUFF_ELEMENT *t;
- HUFF_ELEMENT *t0;
- int linbits;
- int bits;
- int code;
- int x, y;
-
- if (n <= 0)
- return;
- n = n >> 1; /* huff in pairs */
-/*-------------*/
- t0 = table_look[ntable].table;
- linbits = table_look[ntable].linbits;
- switch (table_look[ntable].ncase)
- {
- default:
-/*------------------------------------------*/
- case no_bits:
-/*- table 0, no data, x=y=0--*/
- for (i = 0; i < n; i++)
- {
- xy[i][0] = 0;
- xy[i][1] = 0;
- }
- return;
-/*------------------------------------------*/
- case one_shot:
-/*- single lookup, no escapes -*/
- for (i = 0; i < n; i++)
- {
- mac_bitget_check((MAXBITS + 2));
- bits = t0[0].b.signbits;
- code = mac_bitget2(bits);
- mac_bitget_purge(t0[1 + code].b.purgebits);
- x = t0[1 + code].b.x;
- y = t0[1 + code].b.y;
- if (x)
- if (mac_bitget_1bit())
- x = -x;
- if (y)
- if (mac_bitget_1bit())
- y = -y;
- xy[i][0] = x;
- xy[i][1] = y;
- if (bitdat.bs_ptr > bitdat.bs_ptr_end)
- break; // bad data protect
-
- }
- return;
-/*------------------------------------------*/
- case no_linbits:
- for (i = 0; i < n; i++)
- {
- t = t0;
- for (;;)
- {
- mac_bitget_check((MAXBITS + 2));
- bits = t[0].b.signbits;
- code = mac_bitget2(bits);
- if (t[1 + code].b.purgebits)
- break;
- t += t[1 + code].ptr; /* ptr include 1+code */
- mac_bitget_purge(bits);
- }
- mac_bitget_purge(t[1 + code].b.purgebits);
- x = t[1 + code].b.x;
- y = t[1 + code].b.y;
- if (x)
- if (mac_bitget_1bit())
- x = -x;
- if (y)
- if (mac_bitget_1bit())
- y = -y;
- xy[i][0] = x;
- xy[i][1] = y;
- if (bitdat.bs_ptr > bitdat.bs_ptr_end)
- break; // bad data protect
-
- }
- return;
-/*------------------------------------------*/
- case have_linbits:
- for (i = 0; i < n; i++)
- {
- t = t0;
- for (;;)
- {
- bits = t[0].b.signbits;
- code = bitget2(bits);
- if (t[1 + code].b.purgebits)
- break;
- t += t[1 + code].ptr; /* ptr includes 1+code */
- mac_bitget_purge(bits);
- }
- mac_bitget_purge(t[1 + code].b.purgebits);
- x = t[1 + code].b.x;
- y = t[1 + code].b.y;
- if (x == 15)
- x += bitget_lb(linbits);
- if (x)
- if (mac_bitget_1bit())
- x = -x;
- if (y == 15)
- y += bitget_lb(linbits);
- if (y)
- if (mac_bitget_1bit())
- y = -y;
- xy[i][0] = x;
- xy[i][1] = y;
- if (bitdat.bs_ptr > bitdat.bs_ptr_end)
- break; // bad data protect
-
- }
- return;
- }
-/*--- end switch ---*/
-
-}
-/*==========================================================*/
-int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable)
-{
- int i;
- int code;
- int x, y, v, w;
- int tmp;
- int i_non_zero, tmp_nz;
-
- tmp_nz = 15;
- i_non_zero = -1;
-
- n = n >> 2; /* huff in quads */
-
- if (ntable)
- goto case_quad_b;
-
-/* case_quad_a: */
- for (i = 0; i < n; i++)
- {
- if (nbits <= 0)
- break;
- mac_bitget_check(10);
- code = mac_bitget2(6);
- nbits -= quad_table_a[code][0];
- mac_bitget_purge(quad_table_a[code][0]);
- tmp = quad_table_a[code][1];
- if (tmp)
- {
- i_non_zero = i;
- tmp_nz = tmp;
- }
- v = (tmp >> 3) & 1;
- w = (tmp >> 2) & 1;
- x = (tmp >> 1) & 1;
- y = tmp & 1;
- if (v)
- {
- if (mac_bitget_1bit())
- v = -v;
- nbits--;
- }
- if (w)
- {
- if (mac_bitget_1bit())
- w = -w;
- nbits--;
- }
- if (x)
- {
- if (mac_bitget_1bit())
- x = -x;
- nbits--;
- }
- if (y)
- {
- if (mac_bitget_1bit())
- y = -y;
- nbits--;
- }
- vwxy[i][0] = v;
- vwxy[i][1] = w;
- vwxy[i][2] = x;
- vwxy[i][3] = y;
- if (bitdat.bs_ptr > bitdat.bs_ptr_end)
- break; // bad data protect
-
- }
- if (nbits < 0)
- {
- i--;
- vwxy[i][0] = 0;
- vwxy[i][1] = 0;
- vwxy[i][2] = 0;
- vwxy[i][3] = 0;
- }
-
- i_non_zero = (i_non_zero + 1) << 2;
-
- if ((tmp_nz & 3) == 0)
- i_non_zero -= 2;
-
- return i_non_zero;
-
-/*--------------------*/
- case_quad_b:
- for (i = 0; i < n; i++)
- {
- if (nbits < 4)
- break;
- nbits -= 4;
- mac_bitget_check(8);
- tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */
- if (tmp)
- {
- i_non_zero = i;
- tmp_nz = tmp;
- }
- v = (tmp >> 3) & 1;
- w = (tmp >> 2) & 1;
- x = (tmp >> 1) & 1;
- y = tmp & 1;
- if (v)
- {
- if (mac_bitget_1bit())
- v = -v;
- nbits--;
- }
- if (w)
- {
- if (mac_bitget_1bit())
- w = -w;
- nbits--;
- }
- if (x)
- {
- if (mac_bitget_1bit())
- x = -x;
- nbits--;
- }
- if (y)
- {
- if (mac_bitget_1bit())
- y = -y;
- nbits--;
- }
- vwxy[i][0] = v;
- vwxy[i][1] = w;
- vwxy[i][2] = x;
- vwxy[i][3] = y;
- if (bitdat.bs_ptr > bitdat.bs_ptr_end)
- break; // bad data protect
-
- }
- if (nbits < 0)
- {
- i--;
- vwxy[i][0] = 0;
- vwxy[i][1] = 0;
- vwxy[i][2] = 0;
- vwxy[i][3] = 0;
- }
-
- i_non_zero = (i_non_zero + 1) << 2;
-
- if ((tmp_nz & 3) == 0)
- i_non_zero -= 2;
-
- return i_non_zero; /* return non-zero sample (to nearest pair) */
-
-}
-/*-----------------------------------------------------*/
diff --git a/codecs/mp3/src/upsf.c b/codecs/mp3/src/upsf.c
deleted file mode 100755
index 1280620c2b..0000000000
--- a/codecs/mp3/src/upsf.c
+++ /dev/null
@@ -1,404 +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$
-____________________________________________________________________________*/
-
-/**** upsf.c ***************************************************
-
-Layer III
- unpack scale factors
-
-
-
-******************************************************************/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#include "L3.h"
-
-extern int iframe;
-
-unsigned int bitget(int n);
-
-/*------------------------------------------------------------*/
-static const int slen_table[16][2] =
-{
- {0, 0}, {0, 1},
- {0, 2}, {0, 3},
- {3, 0}, {1, 1},
- {1, 2}, {1, 3},
- {2, 1}, {2, 2},
- {2, 3}, {3, 1},
- {3, 2}, {3, 3},
- {4, 2}, {4, 3},
-};
-
-/* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
-/* for bt=2 nr is count for group of 3 */
-static const int nr_table[6][3][4] =
-{
- {{6, 5, 5, 5},
- {3, 3, 3, 3},
- {6, 3, 3, 3}},
-
- {{6, 5, 7, 3},
- {3, 3, 4, 2},
- {6, 3, 4, 2}},
-
- {{11, 10, 0, 0},
- {6, 6, 0, 0},
- {6, 3, 6, 0}}, /* adjusted *//* 15, 18, 0, 0, */
-/*-intensity stereo right chan--*/
- {{7, 7, 7, 0},
- {4, 4, 4, 0},
- {6, 5, 4, 0}},
-
- {{6, 6, 6, 3},
- {4, 3, 3, 2},
- {6, 4, 3, 2}},
-
- {{8, 8, 5, 0},
- {5, 4, 3, 0},
- {6, 6, 3, 0}},
-};
-
-/*=============================================================*/
-void unpack_sf_sub_MPEG1(SCALEFACT sf[],
- GR * grdat,
- int scfsi, /* bit flag */
- int gr)
-{
- int sfb;
- int slen0, slen1;
- int block_type, mixed_block_flag, scalefac_compress;
-
-
- block_type = grdat->block_type;
- mixed_block_flag = grdat->mixed_block_flag;
- scalefac_compress = grdat->scalefac_compress;
-
- slen0 = slen_table[scalefac_compress][0];
- slen1 = slen_table[scalefac_compress][1];
-
-
- if (block_type == 2)
- {
- if (mixed_block_flag)
- { /* mixed */
- for (sfb = 0; sfb < 8; sfb++)
- sf[0].l[sfb] = bitget(slen0);
- for (sfb = 3; sfb < 6; sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen0);
- sf[0].s[1][sfb] = bitget(slen0);
- sf[0].s[2][sfb] = bitget(slen0);
- }
- for (sfb = 6; sfb < 12; sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen1);
- sf[0].s[1][sfb] = bitget(slen1);
- sf[0].s[2][sfb] = bitget(slen1);
- }
- return;
- }
- for (sfb = 0; sfb < 6; sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen0);
- sf[0].s[1][sfb] = bitget(slen0);
- sf[0].s[2][sfb] = bitget(slen0);
- }
- for (; sfb < 12; sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen1);
- sf[0].s[1][sfb] = bitget(slen1);
- sf[0].s[2][sfb] = bitget(slen1);
- }
- return;
- }
-
-/* long blocks types 0 1 3, first granule */
- if (gr == 0)
- {
- for (sfb = 0; sfb < 11; sfb++)
- sf[0].l[sfb] = bitget(slen0);
- for (; sfb < 21; sfb++)
- sf[0].l[sfb] = bitget(slen1);
- return;
- }
-
-/* long blocks 0, 1, 3, second granule */
- sfb = 0;
- if (scfsi & 8)
- for (; sfb < 6; sfb++)
- sf[0].l[sfb] = sf[-2].l[sfb];
- else
- for (; sfb < 6; sfb++)
- sf[0].l[sfb] = bitget(slen0);
- if (scfsi & 4)
- for (; sfb < 11; sfb++)
- sf[0].l[sfb] = sf[-2].l[sfb];
- else
- for (; sfb < 11; sfb++)
- sf[0].l[sfb] = bitget(slen0);
- if (scfsi & 2)
- for (; sfb < 16; sfb++)
- sf[0].l[sfb] = sf[-2].l[sfb];
- else
- for (; sfb < 16; sfb++)
- sf[0].l[sfb] = bitget(slen1);
- if (scfsi & 1)
- for (; sfb < 21; sfb++)
- sf[0].l[sfb] = sf[-2].l[sfb];
- else
- for (; sfb < 21; sfb++)
- sf[0].l[sfb] = bitget(slen1);
-
-
-
- return;
-}
-/*=============================================================*/
-void unpack_sf_sub_MPEG2(SCALEFACT sf[],
- GR * grdat,
- int is_and_ch, IS_SF_INFO * sf_info)
-{
- int sfb;
- int slen1, slen2, slen3, slen4;
- int nr1, nr2, nr3, nr4;
- int i, k;
- int preflag, intensity_scale;
- int block_type, mixed_block_flag, scalefac_compress;
-
-
- block_type = grdat->block_type;
- mixed_block_flag = grdat->mixed_block_flag;
- scalefac_compress = grdat->scalefac_compress;
-
- preflag = 0;
- intensity_scale = 0; /* to avoid compiler warning */
- if (is_and_ch == 0)
- {
- if (scalefac_compress < 400)
- {
- slen2 = scalefac_compress >> 4;
- slen1 = slen2 / 5;
- slen2 = slen2 % 5;
- slen4 = scalefac_compress & 15;
- slen3 = slen4 >> 2;
- slen4 = slen4 & 3;
- k = 0;
- }
- else if (scalefac_compress < 500)
- {
- scalefac_compress -= 400;
- slen2 = scalefac_compress >> 2;
- slen1 = slen2 / 5;
- slen2 = slen2 % 5;
- slen3 = scalefac_compress & 3;
- slen4 = 0;
- k = 1;
- }
- else
- {
- scalefac_compress -= 500;
- slen1 = scalefac_compress / 3;
- slen2 = scalefac_compress % 3;
- slen3 = slen4 = 0;
- if (mixed_block_flag)
- {
- slen3 = slen2; /* adjust for long/short mix logic */
- slen2 = slen1;
- }
- preflag = 1;
- k = 2;
- }
- }
- else
- { /* intensity stereo ch = 1 (right) */
- intensity_scale = scalefac_compress & 1;
- scalefac_compress >>= 1;
- if (scalefac_compress < 180)
- {
- slen1 = scalefac_compress / 36;
- slen2 = scalefac_compress % 36;
- slen3 = slen2 % 6;
- slen2 = slen2 / 6;
- slen4 = 0;
- k = 3 + 0;
- }
- else if (scalefac_compress < 244)
- {
- scalefac_compress -= 180;
- slen3 = scalefac_compress & 3;
- scalefac_compress >>= 2;
- slen2 = scalefac_compress & 3;
- slen1 = scalefac_compress >> 2;
- slen4 = 0;
- k = 3 + 1;
- }
- else
- {
- scalefac_compress -= 244;
- slen1 = scalefac_compress / 3;
- slen2 = scalefac_compress % 3;
- slen3 = slen4 = 0;
- k = 3 + 2;
- }
- }
-
- i = 0;
- if (block_type == 2)
- i = (mixed_block_flag & 1) + 1;
- nr1 = nr_table[k][i][0];
- nr2 = nr_table[k][i][1];
- nr3 = nr_table[k][i][2];
- nr4 = nr_table[k][i][3];
-
-
-/* return is scale factor info (for right chan is mode) */
- if (is_and_ch)
- {
- sf_info->nr[0] = nr1;
- sf_info->nr[1] = nr2;
- sf_info->nr[2] = nr3;
- sf_info->slen[0] = slen1;
- sf_info->slen[1] = slen2;
- sf_info->slen[2] = slen3;
- sf_info->intensity_scale = intensity_scale;
- }
- grdat->preflag = preflag; /* return preflag */
-
-/*--------------------------------------*/
- if (block_type == 2)
- {
- if (mixed_block_flag)
- { /* mixed */
- if (slen1 != 0) /* long block portion */
- for (sfb = 0; sfb < 6; sfb++)
- sf[0].l[sfb] = bitget(slen1);
- else
- for (sfb = 0; sfb < 6; sfb++)
- sf[0].l[sfb] = 0;
- sfb = 3; /* start sfb for short */
- }
- else
- { /* all short, initial short blocks */
- sfb = 0;
- if (slen1 != 0)
- for (i = 0; i < nr1; i++, sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen1);
- sf[0].s[1][sfb] = bitget(slen1);
- sf[0].s[2][sfb] = bitget(slen1);
- }
- else
- for (i = 0; i < nr1; i++, sfb++)
- {
- sf[0].s[0][sfb] = 0;
- sf[0].s[1][sfb] = 0;
- sf[0].s[2][sfb] = 0;
- }
- }
-/* remaining short blocks */
- if (slen2 != 0)
- for (i = 0; i < nr2; i++, sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen2);
- sf[0].s[1][sfb] = bitget(slen2);
- sf[0].s[2][sfb] = bitget(slen2);
- }
- else
- for (i = 0; i < nr2; i++, sfb++)
- {
- sf[0].s[0][sfb] = 0;
- sf[0].s[1][sfb] = 0;
- sf[0].s[2][sfb] = 0;
- }
- if (slen3 != 0)
- for (i = 0; i < nr3; i++, sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen3);
- sf[0].s[1][sfb] = bitget(slen3);
- sf[0].s[2][sfb] = bitget(slen3);
- }
- else
- for (i = 0; i < nr3; i++, sfb++)
- {
- sf[0].s[0][sfb] = 0;
- sf[0].s[1][sfb] = 0;
- sf[0].s[2][sfb] = 0;
- }
- if (slen4 != 0)
- for (i = 0; i < nr4; i++, sfb++)
- {
- sf[0].s[0][sfb] = bitget(slen4);
- sf[0].s[1][sfb] = bitget(slen4);
- sf[0].s[2][sfb] = bitget(slen4);
- }
- else
- for (i = 0; i < nr4; i++, sfb++)
- {
- sf[0].s[0][sfb] = 0;
- sf[0].s[1][sfb] = 0;
- sf[0].s[2][sfb] = 0;
- }
- return;
- }
-
-
-/* long blocks types 0 1 3 */
- sfb = 0;
- if (slen1 != 0)
- for (i = 0; i < nr1; i++, sfb++)
- sf[0].l[sfb] = bitget(slen1);
- else
- for (i = 0; i < nr1; i++, sfb++)
- sf[0].l[sfb] = 0;
-
- if (slen2 != 0)
- for (i = 0; i < nr2; i++, sfb++)
- sf[0].l[sfb] = bitget(slen2);
- else
- for (i = 0; i < nr2; i++, sfb++)
- sf[0].l[sfb] = 0;
-
- if (slen3 != 0)
- for (i = 0; i < nr3; i++, sfb++)
- sf[0].l[sfb] = bitget(slen3);
- else
- for (i = 0; i < nr3; i++, sfb++)
- sf[0].l[sfb] = 0;
-
- if (slen4 != 0)
- for (i = 0; i < nr4; i++, sfb++)
- sf[0].l[sfb] = bitget(slen4);
- else
- for (i = 0; i < nr4; i++, sfb++)
- sf[0].l[sfb] = 0;
-
-
-}
-/*-------------------------------------------------*/
diff --git a/codecs/mp3/src/wavep.c b/codecs/mp3/src/wavep.c
deleted file mode 100755
index d6d282916f..0000000000
--- a/codecs/mp3/src/wavep.c
+++ /dev/null
@@ -1,165 +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$
-____________________________________________________________________________*/
-
-/*---- wavep.c --------------------------------------------
-
-WAVE FILE HEADER ROUTINES
-with conditional pcm conversion to MS wave format
-portable version
-
------------------------------------------------------------*/
-#include <stdlib.h>
-#include <stdio.h>
-#include <float.h>
-#include <math.h>
-#ifdef WIN32
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-#include "port.h"
-
-typedef struct
-{
- unsigned char riff[4];
- unsigned char size[4];
- unsigned char wave[4];
- unsigned char fmt[4];
- unsigned char fmtsize[4];
- unsigned char tag[2];
- unsigned char nChannels[2];
- unsigned char nSamplesPerSec[4];
- unsigned char nAvgBytesPerSec[4];
- unsigned char nBlockAlign[2];
- unsigned char nBitsPerSample[2];
- unsigned char data[4];
- unsigned char pcm_bytes[4];
-}
-BYTE_WAVE;
-
-static BYTE_WAVE wave =
-{
- "RIFF",
- {(sizeof(BYTE_WAVE) - 8), 0, 0, 0},
- "WAVE",
- "fmt ",
- {16, 0, 0, 0},
- {1, 0},
- {1, 0},
- {34, 86, 0, 0}, /* 86 * 256 + 34 = 22050 */
- {172, 68, 0, 0}, /* 172 * 256 + 68 = 44100 */
- {2, 0},
- {16, 0},
- "data",
- {0, 0, 0, 0}
-};
-
-/*---------------------------------------------------------*/
-static void set_wave(unsigned char w[], int n, long x)
-{
- int i;
-
- for (i = 0; i < n; i++)
- {
- w[i] = (unsigned char) (x & 0xff);
- x >>= 8;
- }
-}
-/*---------------------------------------------------------*/
-int write_pcm_header_wave(int handout,
- long samprate, int channels, int bits, int type)
-{
- int nwrite;
-
- if (type == 0)
- set_wave(wave.tag, sizeof(wave.tag), 1);
- else if (type == 10)
- set_wave(wave.tag, sizeof(wave.tag), 7);
- else
- return 0;
-
- set_wave(wave.size, sizeof(wave.size), sizeof(wave) - 8);
- set_wave(wave.nChannels, sizeof(wave.nChannels), channels);
- set_wave(wave.nSamplesPerSec, sizeof(wave.nSamplesPerSec), samprate);
- set_wave(wave.nAvgBytesPerSec, sizeof(wave.nAvgBytesPerSec),
- (channels * samprate * bits + 7) / 8);
- set_wave(wave.nBlockAlign, sizeof(wave.nBlockAlign), (channels * bits + 7) / 8);
- set_wave(wave.nBitsPerSample, sizeof(wave.nBitsPerSample), bits);
- set_wave(wave.pcm_bytes, sizeof(wave.pcm_bytes), 0);
-
- nwrite = write(handout, &wave, sizeof(wave));
- if (nwrite != sizeof(wave))
- return 0;
-
- return 1;
-}
-/*-----------------------------------------------*/
-int write_pcm_tailer_wave(int handout, unsigned long pcm_bytes)
-{
- unsigned long pos;
- int nwrite;
-
-
- set_wave(wave.size, sizeof(wave.size), sizeof(wave) - 8 + pcm_bytes);
- set_wave(wave.pcm_bytes, sizeof(wave.pcm_bytes), pcm_bytes);
-
-
- pos = lseek(handout, 0L, 2);
-/*-- save current position */
- lseek(handout, 0L, 0);
-/*-- pos to header --*/
- nwrite = write(handout, &wave, sizeof(wave));
- lseek(handout, pos, 0);
-/*-- restore pos --*/
-
- if (nwrite != sizeof(wave))
- return 0;
- return 1;
-}
-/*-----------------------------------------------*/
-/*----------------------------------------------------------------
- pcm conversion to wave format
-
- This conversion code required for big endian machine, or,
- if sizeof(short) != 16 bits.
- Conversion routines may be used on any machine, but if
- not required, the do nothing macros in port.h can be used instead
- to reduce overhead.
-
------------------------------------------------------------------*/
-#ifndef LITTLE_SHORT16
-#include "wcvt.c"
-#endif
-/*-----------------------------------------------*/
-int cvt_to_wave_test()
-{
-/*-- test for valid compile ---*/
-
- return sizeof(short) - 2;
-
-
-}
-/*-----------------------------------------------*/
diff --git a/codecs/mp3/src/wcvt.c b/codecs/mp3/src/wcvt.c
deleted file mode 100755
index d373cd6947..0000000000
--- a/codecs/mp3/src/wcvt.c
+++ /dev/null
@@ -1,92 +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$
-____________________________________________________________________________*/
-
-/*---- wcvt.c --------------------------------------------
-
-conditional inclusion to wavep.c
-
-pcm conversion to wave format
- for big endians or when sizeof(short) > 16 bits
-
-mod 1/9/97 warnings
-
------------------------------------------------------------*/
-static int bytes_per_samp = 1;
-static int big_ender;
-static int cvt_flag;
-
-/*-------------------------------------------------------*/
-void cvt_to_wave_init(int bits)
-{
-
- big_ender = 1;
- if ((*(unsigned char *) &big_ender) == 1)
- big_ender = 0;
-
-/*--- printf("\n big_ender = %d", big_ender ); ---*/
-
- if (bits == 8)
- bytes_per_samp = 1;
- else
- bytes_per_samp = sizeof(short);
-
-
- cvt_flag = 0;
- if (bits > 8)
- {
- if (big_ender)
- cvt_flag = 1;
- cvt_flag |= (sizeof(short) > 2);
- }
-
-}
-/*-------------------------------------------------------*/
-unsigned int cvt_to_wave(unsigned char *pcm, unsigned int bytes_in)
-{
- unsigned int i, k;
- unsigned int nsamp;
- short tmp;
- unsigned short *w;
-
-// printf("\n wave convert");
-
- if (cvt_flag == 0)
- return bytes_in;
-/*-- no conversion required --*/
-
- nsamp = bytes_in / bytes_per_samp;
- w = (unsigned short *) pcm;
- for (i = 0, k = 0; i < nsamp; i++, k += 2)
- {
- tmp = w[i];
- pcm[k] = (unsigned char) tmp;
- pcm[k + 1] = (unsigned char) (tmp >> 8);
- }
-
- return (nsamp << 1);
-/*--- return bytes out ---*/
-}
-/*-------------------------------------------------------*/
diff --git a/codecs/mp3/src/x86gas.s b/codecs/mp3/src/x86gas.s
deleted file mode 100755
index 9fe553703b..0000000000
--- a/codecs/mp3/src/x86gas.s
+++ /dev/null
@@ -1,393 +0,0 @@
-#
-# FreeAmp - The Free MP3 Player
-#
-# Based on MP3 decoder originally Copyright (C) 1995-1997
-# Xing Technology Corp. http://www.xingtech.com
-#
-# Copyright (C) 1999 Mark H. Weaver <mhw@netris.org>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# $Id$
-#
-
-#%% extern wincoef,dword
-#%% extern coef32,dword
-#%% ! extern float wincoef[264];
-#%% ! extern float coef32[31];
-
-.equ L_tmp, 0
-#%!.equ L_pcm, 4
-#%% if-not-inline
-.equ L_vbuf, 24
-.equ L_vb_ptr, 28
-.equ L_pcm, 32
-
-.globl window_dual
- .align 16
-#%% end-not-inline
-#%% ! void window_dual(float *vbuf, int vb_ptr, short *pcm)
-#%% ! {
-window_dual: #%% proc
-#%% if-not-inline
- pushl %ebp
- pushl %edi
- pushl %esi
- pushl %ebx
- subl $4,%esp
-
- movl L_vb_ptr(%esp),%esi
- movl L_vbuf(%esp),%edi
-#%% end-not-inline
-
-#%! movl vb_ptr,%esi
-#%! movl vbuf,%edi
-#%! movl pcm,%ecx
-#%! pushl %ebp
-#%! subl $8,%esp
-#%! movl %ecx,L_pcm(%esp)
-
- movl $511,%ebp # ebp = 511
- leal wincoef,%ecx # coef = wincoef
- addl $16,%esi # si = vb_ptr + 16
- movl %esi,%ebx
- addl $32,%ebx
- andl %ebp,%ebx # bx = (si + 32) & 511
-
-# First 16
- movb $16,%dh # i = 16
- .align 4
-.FirstOuter:
- fldz # sum = 0.0
- movb $2,%dl # j = 2
- .align 4
-.FirstInner:
-.rept 4 # Unrolled loop
- flds (%ecx) # Push *coef
- fmuls (%edi,%esi,4) # Multiply by vbuf[si]
- addl $64,%esi # si += 64
- addl $4,%ecx # Advance coef pointer
- andl %ebp,%esi # si &= 511
- faddp %st,%st(1) # Add to sum
-
- flds (%ecx) # Push *coef
- fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
- addl $64,%ebx # bx += 64
- addl $4,%ecx # Advance coef pointer
- andl %ebp,%ebx # bx &= 511
- fsubrp %st,%st(1) # Subtract from sum
-.endr
-
- decb %dl # --j
- jg .FirstInner # Jump back if j > 0
-
- fistpl L_tmp(%esp) # tmp = (long) round (sum)
- incl %esi # si++
- movl L_tmp(%esp),%eax
- decl %ebx # bx--
- movl %eax,%ebp
- sarl $15,%eax
- incl %eax
- sarl $1,%eax
- jz .FirstInRange # Jump if in range
-
- sarl $16,%eax # Out of range
- movl $32767,%ebp
- xorl %eax,%ebp
-.FirstInRange:
- movl L_pcm(%esp),%eax
- movw %bp,(%eax) # Store sample in *pcm
- addl $4,%eax # Increment pcm
- movl $511,%ebp # Reload ebp with 511
- movl %eax,L_pcm(%esp)
-
- decb %dh # --i
- jg .FirstOuter # Jump back if i > 0
-
-
-# Special case
- fldz # sum = 0.0
- movb $4,%dl # j = 4
- .align 4
-.SpecialInner:
-.rept 2 # Unrolled loop
- flds (%ecx) # Push *coef
- fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
- addl $64,%ebx # bx += 64
- addl $4,%ecx # Increment coef pointer
- andl %ebp,%ebx # bx &= 511
- faddp %st,%st(1) # Add to sum
-.endr
-
- decb %dl # --j
- jg .SpecialInner # Jump back if j > 0
-
- fistpl L_tmp(%esp) # tmp = (long) round (sum)
- decl %esi # si--
- movl L_tmp(%esp),%eax
- incl %ebx # bx++
- movl %eax,%ebp
- sarl $15,%eax
- incl %eax
- sarl $1,%eax
- jz .SpecialInRange # Jump if within range
-
- sarl $16,%eax # Out of range
- movl $32767,%ebp
- xorl %eax,%ebp
-.SpecialInRange:
- movl L_pcm(%esp),%eax
- subl $36,%ecx # Readjust coef pointer for last round
- movw %bp,(%eax) # Store sample in *pcm
- addl $4,%eax # Increment pcm
- movl $511,%ebp # Reload ebp with 511
- movl %eax,L_pcm(%esp)
-
-
-# Last 15
- movb $15,%dh # i = 15
- .align 4
-.LastOuter:
- fldz # sum = 0.0
- movb $2,%dl # j = 2
- .align 4
-.LastInner:
-.rept 4 # Unrolled loop
- flds (%ecx) # Push *coef
- fmuls (%edi,%esi,4) # Multiply by vbuf[si]
- addl $64,%esi # si += 64
- subl $4,%ecx # Back up coef pointer
- andl %ebp,%esi # si &= 511
- faddp %st,%st(1) # Add to sum
-
- flds (%ecx) # Push *coef
- fmuls (%edi,%ebx,4) # Multiply by vbuf[bx]
- addl $64,%ebx # bx += 64
- subl $4,%ecx # Back up coef pointer
- andl %ebp,%ebx # bx &= 511
- faddp %st,%st(1) # Add to sum
-.endr
-
- decb %dl # --j
- jg .LastInner # Jump back if j > 0
-
- fistpl L_tmp(%esp) # tmp = (long) round (sum)
- decl %esi # si--
- movl L_tmp(%esp),%eax
- incl %ebx # bx++
- movl %eax,%ebp
- sarl $15,%eax
- incl %eax
- sarl $1,%eax
- jz .LastInRange # Jump if in range
-
- sarl $16,%eax # Out of range
- movl $32767,%ebp
- xorl %eax,%ebp
-.LastInRange:
- movl L_pcm(%esp),%eax
- movw %bp,(%eax) # Store sample in *pcm
- addl $4,%eax # Increment pcm
- movl $511,%ebp # Reload ebp with 511
- movl %eax,L_pcm(%esp)
-
- decb %dh # --i
- jg .LastOuter # Jump back if i > 0
-
-#%! addl $8,%esp
-#%! popl %ebp
-
-#%% if-not-inline
-# Restore regs and return
- addl $4,%esp
- popl %ebx
- popl %esi
- popl %edi
- popl %ebp
- ret
-#%% end-not-inline
-#%% endp
-#%% ! }
-
-#---------------------------------------------------------------------------
-
-.equ L_mi, 0
-.equ L_m, 4
-.equ L_dummy, 8
-#%!.equ L_in, 12
-#%!.equ L_out, 16
-#%!.equ L_buf, 20 # Temporary buffer
-#%!.equ L_locals, 148 # Bytes used for locals
-#%% if-not-inline
-.equ L_buf, 12 # Temporary buffer
-.equ L_in, 160
-.equ L_out, 164
-.equ L_locals, 140 # Bytes used for locals
-
-.globl asm_fdct32
- .align 16
-#%% end-not-inline
-#%% ! void asm_fdct32(float in[], float out[])
-#%% ! {
-asm_fdct32: #%% proc
-#%% if-not-inline
- pushl %ebp
- pushl %edi
- pushl %esi
- pushl %ebx
- subl $L_locals,%esp
-
- movl L_in(%esp),%edi # edi = x
- movl L_out(%esp),%esi # esi = f
-#%% end-not-inline
-
-#%! movl in,%edi # edi = x
-#%! movl out,%esi # esi = f
-#%! pushl %ebp
-#%! subl $L_locals,%esp
-
- leal coef32-128,%ecx # coef = coef32 - (32 * 4)
- movl $1,4(%esp) # m = 1
- movl $16,%ebp # n = 32 / 2
-
- leal L_buf(%esp),%ebx
- movl %ebx,L_out(%esp) # From now on, use temp buf instead of orig x
- jmp .ForwardLoopStart
-
- .align 4
-.ForwardOuterLoop:
- movl L_in(%esp),%edi # edi = x
- movl L_out(%esp),%esi # esi = f
- movl %edi,L_out(%esp) # Exchange mem versions of f/x for next iter
-.ForwardLoopStart:
- movl %esi,L_in(%esp)
- movl L_m(%esp),%ebx # ebx = m (temporarily)
- movl %ebx,L_mi(%esp) # mi = m
- sall $1,%ebx # Double m for next iter
- leal (%ecx,%ebp,8),%ecx # coef += n * 8
- movl %ebx,L_m(%esp) # Store doubled m
- leal (%esi,%ebp,4),%ebx # ebx = f2 = f + n * 4
- sall $3,%ebp # n *= 8
-
- .align 4
-.ForwardMiddleLoop:
- movl %ebp,%eax # q = n
- xorl %edx,%edx # p = 0
- test $8,%eax
- jnz .ForwardInnerLoop1
-
- .align 4
-.ForwardInnerLoop:
- subl $4,%eax # q -= 4
- flds (%edi,%eax) # push x[q]
- flds (%edi,%edx) # push x[p]
- fld %st(1) # Duplicate top two stack entries
- fld %st(1)
- faddp %st,%st(1)
- fstps (%esi,%edx) # f[p] = x[p] + x[q]
- fsubp %st,%st(1)
- fmuls (%ecx,%edx)
- fstps (%ebx,%edx) # f2[p] = coef[p] * (x[p] - x[q])
- addl $4,%edx # p += 4
-
-.ForwardInnerLoop1:
- subl $4,%eax # q -= 4
- flds (%edi,%eax) # push x[q]
- flds (%edi,%edx) # push x[p]
- fld %st(1) # Duplicate top two stack entries
- fld %st(1)
- faddp %st,%st(1)
- fstps (%esi,%edx) # f[p] = x[p] + x[q]
- fsubp %st,%st(1)
- fmuls (%ecx,%edx)
- fstps (%ebx,%edx) # f2[p] = coef[p] * (x[p] - x[q])
- addl $4,%edx # p += 4
-
- cmpl %eax,%edx
- jb .ForwardInnerLoop # Jump back if (p < q)
-
- addl %ebp,%esi # f += n
- addl %ebp,%ebx # f2 += n
- addl %ebp,%edi # x += n
- decl L_mi(%esp) # mi--
- jg .ForwardMiddleLoop # Jump back if mi > 0
-
- sarl $4,%ebp # n /= 16
- jg .ForwardOuterLoop # Jump back if n > 0
-
-
-# Setup back loop
- movl $8,%ebx # ebx = m = 8 (temporarily)
- movl %ebx,%ebp # n = 4 * 2
-
- .align 4
-.BackOuterLoop:
- movl L_out(%esp),%esi # esi = f
- movl %ebx,L_mi(%esp) # mi = m
- movl L_in(%esp),%edi # edi = x
- movl %ebx,L_m(%esp) # Store m
- movl %esi,L_in(%esp) # Exchange mem versions of f/x for next iter
- movl %edi,%ebx
- movl %edi,L_out(%esp)
- subl %ebp,%ebx # ebx = x2 = x - n
- sall $1,%ebp # n *= 2
-
- .align 4
-.BackMiddleLoop:
- movl -4(%ebx,%ebp),%ecx
- movl %ecx,-8(%esi,%ebp) # f[n - 8] = x2[n - 4]
- flds -4(%edi,%ebp) # push x[n - 4]
- fsts -4(%esi,%ebp) # f[n - 4] = x[n - 4], without popping
- leal -8(%ebp),%eax # q = n - 8
- leal -16(%ebp),%edx # p = n - 16
-
- .align 4
-.BackInnerLoop:
- movl (%ebx,%eax),%ecx
- movl %ecx,(%esi,%edx) # f[p] = x2[q]
- flds (%edi,%eax) # push x[q]
- fadd %st,%st(1)
- fxch
- fstps 4(%esi,%edx) # f[p + 4] = x[q] + x[q + 4]
- subl $4,%eax # q -= 4
- subl $8,%edx # p -= 8
- jge .BackInnerLoop # Jump back if p >= 0
-
- fstps L_dummy(%esp) # Pop (XXX is there a better way to do this?)
- addl %ebp,%esi # f += n
- addl %ebp,%ebx # x2 += n
- addl %ebp,%edi # x += n
- decl L_mi(%esp) # mi--
- jg .BackMiddleLoop # Jump back if mi > 0
-
- movl L_m(%esp),%ebx # ebx = m (temporarily)
- sarl $1,%ebx # Halve m for next iter
- jg .BackOuterLoop # Jump back if m > 0
-
-#%! addl $L_locals,%esp
-#%! popl %ebp
-
-#%% if-not-inline
-# Restore regs and return
- addl $L_locals,%esp
- popl %ebx
- popl %esi
- popl %edi
- popl %ebp
- ret
-#%% end-not-inline
-#%% endp
-#%% ! }
-
diff --git a/codecs/mp3/src/x86intel.c b/codecs/mp3/src/x86intel.c
deleted file mode 100755
index d9f0e61254..0000000000
--- a/codecs/mp3/src/x86intel.c
+++ /dev/null
@@ -1,437 +0,0 @@
-/* *************************************************** */
-/* ************ DO NOT EDIT THIS FILE!!!! ************ */
-/* *************************************************** */
-/* This file was automatically generated by gas2intel. */
-/* Edit the original gas version instead. */
-
-
-/* FreeAmp - The Free MP3 Player */
-
-/* Based on MP3 decoder originally Copyright (C) 1995-1997 */
-/* Xing Technology Corp. http://www.xingtech.com */
-
-/* Copyright (C) 1999 Mark H. Weaver <mhw@netris.org> */
-
-/* This program is free software; you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation; either version 2 of the License, or */
-/* (at your option) any later version. */
-
-/* This program is distributed in the hope that it will be useful, */
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
-/* GNU General Public License for more details. */
-
-/* You should have received a copy of the GNU General Public License */
-/* along with this program; if not, write to the Free Software */
-/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/* $Id$ */
-/* Generated from Id: x86gas.s,v 1.9 1999/03/05 08:58:18 mhw Exp $ */
-
-
-extern float wincoef[264];
-extern float coef32[31];
-
-#define L_tmp 0
-#define L_pcm 4
-void window_dual(float *vbuf, int vb_ptr, short *pcm)
-{
-__asm {
-
- mov esi,vb_ptr
- mov edi,vbuf
- mov ecx,pcm
- push ebp
- sub esp,8
- mov DWORD PTR [esp+L_pcm],ecx
-
- mov ebp,511 ; ebp = 511
- lea ecx,wincoef ; coef = wincoef
- add esi,16 ; si = vb_ptr + 16
- mov ebx,esi
- add ebx,32
- and ebx,ebp ; bx = (si + 32) & 511
-
-; First 16
- mov dh,16 ; i = 16
- align 4
-FirstOuter:
- fldz ; sum = 0.0
- mov dl,2 ; j = 2
- align 4
-FirstInner:
-; REPEAT 4 ; Unrolled loop
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- add ecx,4 ; Advance coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Advance coef pointer
- and ebx,ebp ; bx &= 511
- fsubp st(1),st ; Subtract from sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- add ecx,4 ; Advance coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Advance coef pointer
- and ebx,ebp ; bx &= 511
- fsubp st(1),st ; Subtract from sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- add ecx,4 ; Advance coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Advance coef pointer
- and ebx,ebp ; bx &= 511
- fsubp st(1),st ; Subtract from sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- add ecx,4 ; Advance coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Advance coef pointer
- and ebx,ebp ; bx &= 511
- fsubp st(1),st ; Subtract from sum
-;--
-; END REPEAT
-
- dec dl ; --j
- jg FirstInner ; Jump back if j > 0
-
- fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
- inc esi ; si++
- mov eax,DWORD PTR [esp+L_tmp]
- dec ebx ; bx--
- mov ebp,eax
- sar eax,15
- inc eax
- sar eax,1
- jz FirstInRange ; Jump if in range
-
- sar eax,16 ; Out of range
- mov ebp,32767
- xor ebp,eax
-FirstInRange:
- mov eax,DWORD PTR [esp+L_pcm]
- mov WORD PTR [eax],bp ; Store sample in *pcm
- add eax,4 ; Increment pcm
- mov ebp,511 ; Reload ebp with 511
- mov DWORD PTR [esp+L_pcm],eax
-
- dec dh ; --i
- jg FirstOuter ; Jump back if i > 0
-
-
-; Special case
- fldz ; sum = 0.0
- mov dl,4 ; j = 4
- align 4
-SpecialInner:
-; REPEAT 2 ; Unrolled loop
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Increment coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- add ecx,4 ; Increment coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
-; END REPEAT
-
- dec dl ; --j
- jg SpecialInner ; Jump back if j > 0
-
- fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
- dec esi ; si--
- mov eax,DWORD PTR [esp+L_tmp]
- inc ebx ; bx++
- mov ebp,eax
- sar eax,15
- inc eax
- sar eax,1
- jz SpecialInRange ; Jump if within range
-
- sar eax,16 ; Out of range
- mov ebp,32767
- xor ebp,eax
-SpecialInRange:
- mov eax,DWORD PTR [esp+L_pcm]
- sub ecx,36 ; Readjust coef pointer for last round
- mov WORD PTR [eax],bp ; Store sample in *pcm
- add eax,4 ; Increment pcm
- mov ebp,511 ; Reload ebp with 511
- mov DWORD PTR [esp+L_pcm],eax
-
-
-; Last 15
- mov dh,15 ; i = 15
- align 4
-LastOuter:
- fldz ; sum = 0.0
- mov dl,2 ; j = 2
- align 4
-LastInner:
-; REPEAT 4 ; Unrolled loop
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- sub ecx,4 ; Back up coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- sub ecx,4 ; Back up coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- sub ecx,4 ; Back up coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- sub ecx,4 ; Back up coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- sub ecx,4 ; Back up coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- sub ecx,4 ; Back up coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+esi*4] ; Multiply by vbuf[si]
- add esi,64 ; si += 64
- sub ecx,4 ; Back up coef pointer
- and esi,ebp ; si &= 511
- faddp st(1),st ; Add to sum
-
- fld DWORD PTR [ecx] ; Push *coef
- fmul DWORD PTR [edi+ebx*4] ; Multiply by vbuf[bx]
- add ebx,64 ; bx += 64
- sub ecx,4 ; Back up coef pointer
- and ebx,ebp ; bx &= 511
- faddp st(1),st ; Add to sum
-;--
-; END REPEAT
-
- dec dl ; --j
- jg LastInner ; Jump back if j > 0
-
- fistp DWORD PTR [esp+L_tmp] ; tmp = (long) round (sum)
- dec esi ; si--
- mov eax,DWORD PTR [esp+L_tmp]
- inc ebx ; bx++
- mov ebp,eax
- sar eax,15
- inc eax
- sar eax,1
- jz LastInRange ; Jump if in range
-
- sar eax,16 ; Out of range
- mov ebp,32767
- xor ebp,eax
-LastInRange:
- mov eax,DWORD PTR [esp+L_pcm]
- mov WORD PTR [eax],bp ; Store sample in *pcm
- add eax,4 ; Increment pcm
- mov ebp,511 ; Reload ebp with 511
- mov DWORD PTR [esp+L_pcm],eax
-
- dec dh ; --i
- jg LastOuter ; Jump back if i > 0
-
- add esp,8
- pop ebp
-
- }
-}
-
-/*--------------------------------------------------------------------------- */
-
-#define L_mi 0
-#define L_m 4
-#define L_dummy 8
-#define L_in 12
-#define L_out 16
-#define L_buf 20 /* Temporary buffer */
-#define L_locals 148 /* Bytes used for locals */
-void asm_fdct32(float in[], float out[])
-{
-__asm {
-
- mov edi,in ; edi = x
- mov esi,out ; esi = f
- push ebp
- sub esp,L_locals
-
- lea ecx,coef32-128 ; coef = coef32 - (32 * 4)
- mov DWORD PTR [esp+4],1 ; m = 1
- mov ebp,16 ; n = 32 / 2
-
- lea ebx,DWORD PTR [esp+L_buf]
- mov DWORD PTR [esp+L_out],ebx ; From now on, use temp buf instead of orig x
- jmp ForwardLoopStart
-
- align 4
-ForwardOuterLoop:
- mov edi,DWORD PTR [esp+L_in] ; edi = x
- mov esi,DWORD PTR [esp+L_out] ; esi = f
- mov DWORD PTR [esp+L_out],edi ; Exchange mem versions of f/x for next iter
-ForwardLoopStart:
- mov DWORD PTR [esp+L_in],esi
- mov ebx,DWORD PTR [esp+L_m] ; ebx = m (temporarily)
- mov DWORD PTR [esp+L_mi],ebx ; mi = m
- sal ebx,1 ; Double m for next iter
- lea ecx,DWORD PTR [ecx+ebp*8] ; coef += n * 8
- mov DWORD PTR [esp+L_m],ebx ; Store doubled m
- lea ebx,DWORD PTR [esi+ebp*4] ; ebx = f2 = f + n * 4
- sal ebp,3 ; n *= 8
-
- align 4
-ForwardMiddleLoop:
- mov eax,ebp ; q = n
- xor edx,edx ; p = 0
- test eax,8
- jnz ForwardInnerLoop1
-
- align 4
-ForwardInnerLoop:
- sub eax,4 ; q -= 4
- fld DWORD PTR [edi+eax] ; push x[q]
- fld DWORD PTR [edi+edx] ; push x[p]
- fld st(1) ; Duplicate top two stack entries
- fld st(1)
- faddp st(1),st
- fstp DWORD PTR [esi+edx] ; f[p] = x[p] + x[q]
- fsubrp st(1),st
- fmul DWORD PTR [ecx+edx]
- fstp DWORD PTR [ebx+edx] ; f2[p] = coef[p] * (x[p] - x[q])
- add edx,4 ; p += 4
-
-ForwardInnerLoop1:
- sub eax,4 ; q -= 4
- fld DWORD PTR [edi+eax] ; push x[q]
- fld DWORD PTR [edi+edx] ; push x[p]
- fld st(1) ; Duplicate top two stack entries
- fld st(1)
- faddp st(1),st
- fstp DWORD PTR [esi+edx] ; f[p] = x[p] + x[q]
- fsubrp st(1),st
- fmul DWORD PTR [ecx+edx]
- fstp DWORD PTR [ebx+edx] ; f2[p] = coef[p] * (x[p] - x[q])
- add edx,4 ; p += 4
-
- cmp edx,eax
- jb ForwardInnerLoop ; Jump back if (p < q)
-
- add esi,ebp ; f += n
- add ebx,ebp ; f2 += n
- add edi,ebp ; x += n
- dec DWORD PTR [esp+L_mi] ; mi--
- jg ForwardMiddleLoop ; Jump back if mi > 0
-
- sar ebp,4 ; n /= 16
- jg ForwardOuterLoop ; Jump back if n > 0
-
-
-; Setup back loop
- mov ebx,8 ; ebx = m = 8 (temporarily)
- mov ebp,ebx ; n = 4 * 2
-
- align 4
-BackOuterLoop:
- mov esi,DWORD PTR [esp+L_out] ; esi = f
- mov DWORD PTR [esp+L_mi],ebx ; mi = m
- mov edi,DWORD PTR [esp+L_in] ; edi = x
- mov DWORD PTR [esp+L_m],ebx ; Store m
- mov DWORD PTR [esp+L_in],esi ; Exchange mem versions of f/x for next iter
- mov ebx,edi
- mov DWORD PTR [esp+L_out],edi
- sub ebx,ebp ; ebx = x2 = x - n
- sal ebp,1 ; n *= 2
-
- align 4
-BackMiddleLoop:
- mov ecx,DWORD PTR [ebx+ebp-4]
- mov DWORD PTR [esi+ebp-8],ecx ; f[n - 8] = x2[n - 4]
- fld DWORD PTR [edi+ebp-4] ; push x[n - 4]
- fst DWORD PTR [esi+ebp-4] ; f[n - 4] = x[n - 4], without popping
- lea eax,DWORD PTR [ebp-8] ; q = n - 8
- lea edx,DWORD PTR [ebp-16] ; p = n - 16
-
- align 4
-BackInnerLoop:
- mov ecx,DWORD PTR [ebx+eax]
- mov DWORD PTR [esi+edx],ecx ; f[p] = x2[q]
- fld DWORD PTR [edi+eax] ; push x[q]
- fadd st(1),st
- fxch
- fstp DWORD PTR [esi+edx+4] ; f[p + 4] = x[q] + x[q + 4]
- sub eax,4 ; q -= 4
- sub edx,8 ; p -= 8
- jge BackInnerLoop ; Jump back if p >= 0
-
- fstp DWORD PTR [esp+L_dummy] ; Pop (XXX is there a better way to do this?)
- add esi,ebp ; f += n
- add ebx,ebp ; x2 += n
- add edi,ebp ; x += n
- dec DWORD PTR [esp+L_mi] ; mi--
- jg BackMiddleLoop ; Jump back if mi > 0
-
- mov ebx,DWORD PTR [esp+L_m] ; ebx = m (temporarily)
- sar ebx,1 ; Halve m for next iter
- jg BackOuterLoop ; Jump back if m > 0
-
- add esp,L_locals
- pop ebp
-
- }
-}
-
diff --git a/codecs/mp3_slin_ex.h b/codecs/mp3_slin_ex.h
deleted file mode 100755
index d47b445eef..0000000000
--- a/codecs/mp3_slin_ex.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 8-bit raw data
- *
- * Source: ../sample.out
- *
- * Copyright (C) 1999, Mark Spencer
- *
- * Distributed under the terms of the GNU General Public License
- *
- */
-
-static unsigned char mp3_slin_ex[] = {
-0xff, 0xfb, 0x98, 0x4, 0x3, 000, 0x4, 0x1, 0x6f, 0x48,
-0x83, 0x46, 0x1a, 0xf0, 0x8a, 0xb, 0x19, 0x10, 0x75, 0x26,
-0x5c, 0x50, 0xc9, 0xc1, 0x20, 0xa, 0x18, 0xcb, 0xc2, 0xa,
-0xac, 0xe4, 0x81, 0x63, 0x2d, 0x71, 0x6d, 0xdf, 0xcb, 0xf1,
-0xb7, 0x89, 0x69, 0xcd, 0x86, 0x40, 0xd7, 0x2e, 0x6c, 0xc7,
-0x93, 0xa5, 0xf7, 0x1b, 0x19, 0xa, 0x28, 0xf9, 0xa1, 0xab,
-0x93, 0x67, 0xdc, 0xc3, 0x5e, 0x54, 0x75, 0xb1, 0xf8, 0x7e,
-0x3a, 0x80, 0xd1, 0xc3, 0x96, 0x18, 0x81, 0x11, 0x1d, 0x27,
-0x91, 0xdc, 0x5d, 0xb1, 0x94, 0x52, 0xae, 0x6e, 0x2c, 0x43,
-0xb, 0x47, 0x1a, 0xea, 0x45, 0x8, 0x23, 0x13, 0xc5, 0x39,
-0x61, 0xbb, 0xa8, 0x59, 0x8b, 0x84, 0xa4, 0x55, 0x1f, 0x56,
-0xa1, 0x3, 0x2a, 0xad, 0x86, 0xf, 0x27, 0xdc, 0xa1, 0x3a,
-0xa1, 0xb8, 0x47, 0xb, 0xc9, 0xe8, 0xa4, 0xc, 0xc7, 0x45,
-0x21, 0x4f, 0x30, 0xac, 0xf8, 0xb7, 0x23, 0x16, 0x81, 0x13,
-0x29, 0xe3, 0x77, 0x61, 0x68, 0xae, 0x85, 0x2d, 0x32, 0x77,
-0x63, 0x4a, 0x37, 0x34, 0xb3, 0x37, 0xe9, 0xb3, 0x9c, 0xde,
-000, 0x3e, 0xb4, 0x52, 0x99, 0xfc, 0xe4, 0x55, 0x28, 0xfe,
-0x97, 0xa1, 0x5d, 0x14, 0xa8, 0x86, 0xe7, 0xf2, 0xa6, 0x44,
-0x6c, 0x8a, 0xd3, 0x83, 0xe9, 0xc, 0xc5, 0x3, 0x24, 0x47,
-0xe0, 0x8d, 0xe8, 0x10, 0x1d, 0x46, 0x28, 0x13, 0x96, 0x14,
-0x58, 0x2e, 0x4e, 0x4d, 0x31, 0x40, 0xfa, 0x20, 0x60, 0x42,
-0x1, 0xa, 0x8b, 0xc6, 0x7a, 0x98, 0xd7, 0x45, 0x93, 0x67,
-0x42, 0x14, 0x7b, 0x95, 0x16, 0x5a, 0x48, 0x67, 0xc6, 0xde,
-0xd9, 0xde, 0xa2, 0x1e, 0x93, 0x29, 0x94, 0xe7, 0x35, 0xdc,
-0x49, 0x6e, 0x6f, 0xdb, 0x87, 0xc7, 0xdd, 0xec, 0x9f, 0xfa,
-0x81, 0x66, 0x69, 0xf4, 0xf7, 0x7e, 0x62, 0xb6, 0x1a, 0xa9,
-0xf7, 0x18, 0xa9, 0x78, 0x77, 0xad, 0x77, 0x86, 0xaf, 0xdd,
-0xdf, 0x35, 0xb4, 0xb5, 0x50, 0xe, 0x68, 0x73, 0xc9, 0x88,
-0x8f, 0xe9, 0x2e, 0xf0, 0x83, 0xb8, 0xf0, 0xe, 0x5f, 0x24,
-0x5c, 0x25, 0xc7, 0x2f, 0x7f, 0xf7, 0x83, 0x21, 0x95, 0x4c,
-0xcb, 0xa9, 0x4c, 0x94, 0x85, 0x29, 0x45, 0xf3, 0x4b, 0xed,
-0xd6, 0x38, 0x8c, 0xbe, 0xa5, 0x6e, 0xf9, 0xd0, 0x88, 0xa3,
-0x61, 0x15, 0x49, 0x33, 0xb, 0x77, 0x44, 0x86, 0xec, 0x3a,
-0x65, 0xc1, 0xfd, 0xcb, 0x4f, 0xd3, 0xfd, 0xf6, 0x85, 0x4c,
-0xe1, 0x39, 0x64, 0x1c, 0xef, 0x52, 0x96, 0x6e, 0x36, 0x17,
-0x4a, 0xc6, 0xb3, 0xac, 0x43, 0x5f, 0xf0, 0x6c, 0x59, 0x94,
-0xc4, 0x69, 0xea, 0x75, 0x4f, 0x3e, 0xce, 0xa5, 0xa7, 0x56,
-0x2a, 0x1a, 0x5c, 0xb9, 0xd6, 0x69, 0xbd, 0x3b, 0xc9, 0x53,
-0x55, 0x9d, 0x17, 0x63, 0xf9, 0xf0, 0xec, 0x77, 0xef, 0x5d,
-0x98, 0xa2, 0x9b, 0x7e, 0x4d, 0xe6, 0xed, 0x32, 0xb, 0x3d,
-0x1a, 0x6d, 0x86, 0x3f, 0x31, 0x24, 0x2a, 0x7b, 0xba, 0x5c,
-0xd8, 0xb2, 0x47, 0xfc, 0xfa, 0x66, 0x6d, 0xdd, 0x7e, 0x8d,
-0x7f, 0xbb, 0x33, 0xd0, 0x22, 0xe1, 0x50, 0xcd, 0x74, 0xa5,
-0x80, 0xe8, 0x4c, 0x9a, 0x26, 0xb4, 0x1d, 0x5, 0xa6, 0x71,
-0x6, 0xd2, 0xfd, 0x97, 0xf2, 0xe8, 0xb6, 0xda, 0xfe, 0x2d,
-0xee, 0x19, 0x52, 0x2d, 0xc, 0x22, 0x89, 0xde, 0xcd, 0x31,
-0x93, 0xc, 0x69, 0x22, 0x58, 0xf3, 0x46, 0x80, 0xe8, 0xa4,
-0x14, 0x10, 0x21, 0xed, 0x33, 0x12, 0xb4, 0xe, 0x38, 0xea,
-0x2b, 0x45, 0x5b, 0x25, 0x87, 0x16, 0xab, 0x96, 0xb9, 0xad,
-0x88, 0xfa, 0x62, 0x71, 0x75, 0x28, 0x42, 0xd7, 0x3c, 0x9a,
-0xdc, 0x34, 0xe3, 0xe2, 0x66, 0xdb, 0xe, 0x39, 0x9c, 0x98,
-0xb4, 0xa1, 0xd2, 0xe6, 0xec, 0x5f, 0x7f, 0xd6, 0xd8, 0xa3,
-0xb2, 0x75, 0x6a, 0x77, 0x72, 0xf7, 0x5b, 0x2b, 0x98, 0xfe,
-0x2f, 0x88, 0xb7, 0xd7, 0xb2, 0x5d, 0xe, 0x65, 0xf2, 0xa0,
-0x14, 0xec, 0x2d, 0x9b, 0x98, 0x67, 0x20, 0x63, 0x7c, 0x52,
-0x95, 0x8d, 0x62, 0xd9, 0x54, 0xa7, 0xe9, 0x8d, 0x7f, 0xdb,
-0xcf, 0x11, 0x24, 0xe2, 0x81, 0xc1, 0x3e, 0xab, 0xf4, 0x86,
-0xc8, 0x4c, 0xc5, 0x8d, 0xf0, 0x58 };
diff --git a/codecs/mp3anal.h b/codecs/mp3anal.h
deleted file mode 100755
index 263e8520ce..0000000000
--- a/codecs/mp3anal.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Asterisk -- A telephony toolkit for Linux.
- *
- * MP3 Header Analysis Routines. Thanks to Robert Kaye for the logic!
- *
- * 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
- */
-
-static int bitrates1[] = { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 };
-static int bitrates2[] = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 };
-
-static int samplerates1[] = { 44100, 48000, 32000 };
-static int samplerates2[] = { 22050, 24000, 16000 };
-
-static int outputsamples[] = { 576, 1152 };
-
-static int mp3_samples(unsigned char *header)
-{
- int ver = (header[1] & 0x8) >> 3;
- return outputsamples[ver];
-}
-
-static int mp3_bitrate(unsigned char *header)
-{
- int ver = (header[1] & 0x8) >> 3;
- int br = (header[2] >> 4);
-
- if (ver > 14) {
- ast_log(LOG_WARNING, "Invalid bit rate\n");
- return -1;
- }
- if (ver)
- return bitrates1[br];
- else {
- return bitrates2[br];
- }
-}
-
-static int mp3_samplerate(unsigned char *header)
-{
- int ver = (header[1] & 0x8) >> 3;
- int sr = (header[2] >> 2) & 0x3;
-
- if (ver > 2) {
- ast_log(LOG_WARNING, "Invalid sample rate\n");
- return -1;
- }
-
- if (ver)
- return samplerates1[sr];
- else
- return samplerates2[sr];
-}
-
-static int mp3_padding(unsigned char *header)
-{
- return (header[2] >> 1) & 0x1;
-}
-
-static int mp3_badheader(unsigned char *header)
-{
- if ((header[0] != 0xFF) || ((header[1] & 0xF0) != 0xF0))
- return -1;
- return 0;
-}
-
-static int mp3_framelen(unsigned char *header)
-{
- int br = mp3_bitrate(header);
- int sr = mp3_samplerate(header);
- int size;
-
- if ((br < 0) || (sr < 0))
- return -1;
- size = 144000 * br / sr + mp3_padding(header);
- return size;
-}
-
diff --git a/formats/Makefile b/formats/Makefile
index 58c649ba79..c3714e9fc5 100755
--- a/formats/Makefile
+++ b/formats/Makefile
@@ -11,7 +11,7 @@
# the GNU General Public License
#
-FORMAT_LIBS=format_gsm.so format_wav.so format_mp3.so \
+FORMAT_LIBS=format_gsm.so format_wav.so \
format_wav_gsm.so format_vox.so format_pcm.so format_g729.so \
format_pcm_alaw.so format_h263.so
FORMAT_LIBS+=format_jpeg.so
diff --git a/formats/format_mp3.c b/formats/format_mp3.c
deleted file mode 100755
index 2a45245d3c..0000000000
--- a/formats/format_mp3.c
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Asterisk -- A telephony toolkit for Linux.
- *
- * Everybody's favorite format: MP3 Files! Yay!
- *
- * 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/channel.h>
-#include <asterisk/file.h>
-#include <asterisk/logger.h>
-#include <asterisk/sched.h>
-#include <asterisk/module.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <pthread.h>
-#include <sys/time.h>
-#include "../channels/adtranvofr.h"
-
-#define MAX_FRAME_SIZE 1441
-
-struct ast_filestream {
- /* First entry MUST be reserved for the channel type */
- void *reserved[AST_RESERVED_POINTERS];
- /* This is what a filestream means to us */
- int fd; /* Descriptor */
- struct ast_frame fr; /* Frame representation of buf */
- char offset[AST_FRIENDLY_OFFSET];
- unsigned char buf[MAX_FRAME_SIZE * 2];
- int pos;
- struct timeval last;
-};
-
-#if 0
-static struct ast_filestream *glist = NULL;
-#endif
-static ast_mutex_t mp3_lock = AST_MUTEX_INITIALIZER;
-static int glistcnt = 0;
-
-static char *name = "mp3";
-static char *desc = "MPEG-1,2 Layer 3 File Format Support";
-static char *exts = "mp3|mpeg3";
-
-#include "../codecs/mp3anal.h"
-
-static struct ast_filestream *mp3_open(int fd)
-{
- /* We don't have any header to read or anything really, but
- if we did, it would go here. We also might want to check
- and be sure it's a valid file. */
- struct ast_filestream *tmp;
- if ((tmp = malloc(sizeof(struct ast_filestream)))) {
- if (ast_mutex_lock(&mp3_lock)) {
- ast_log(LOG_WARNING, "Unable to lock mp3 list\n");
- free(tmp);
- return NULL;
- }
- tmp->fd = fd;
- tmp->last.tv_usec = 0;
- tmp->last.tv_sec = 0;
- glistcnt++;
- ast_mutex_unlock(&mp3_lock);
- ast_update_use_count();
- }
- return tmp;
-}
-
-static struct ast_filestream *mp3_rewrite(int fd, char *comment)
-{
- /* We don't have any header to read or anything really, but
- if we did, it would go here. We also might want to check
- and be sure it's a valid file. */
- struct ast_filestream *tmp;
- if ((tmp = malloc(sizeof(struct ast_filestream)))) {
- if (ast_mutex_lock(&mp3_lock)) {
- ast_log(LOG_WARNING, "Unable to lock mp3 list\n");
- free(tmp);
- return NULL;
- }
- tmp->fd = fd;
- glistcnt++;
- ast_mutex_unlock(&mp3_lock);
- ast_update_use_count();
- } else
- ast_log(LOG_WARNING, "Out of memory\n");
- return tmp;
-}
-
-static void mp3_close(struct ast_filestream *s)
-{
- if (ast_mutex_lock(&mp3_lock)) {
- ast_log(LOG_WARNING, "Unable to lock mp3 list\n");
- return;
- }
- glistcnt--;
- ast_mutex_unlock(&mp3_lock);
- ast_update_use_count();
- close(s->fd);
- free(s);
-}
-
-static struct ast_frame *mp3_read(struct ast_filestream *s, int *whennext)
-{
- /* XXX Don't assume frames are this size XXX */
- u_int32_t delay = -1;
- int res;
- int size;
- if ((res = read(s->fd, s->buf , 4)) != 4) {
- ast_log(LOG_WARNING, "Short read (%d of 4 bytes) (%s)!\n", res, strerror(errno));
- return NULL;
- }
- if (mp3_badheader(s->buf)) {
- ast_log(LOG_WARNING, "Bad mp3 header\n");
- return NULL;
- }
- if ((size = mp3_framelen(s->buf)) < 0) {
- ast_log(LOG_WARNING, "Unable to calculate frame size\n");
- return NULL;
- }
- if ((res = read(s->fd, s->buf + 4 , size - 4)) != size - 4) {
- ast_log(LOG_WARNING, "Short read (%d of %d bytes) (%s)!\n", res, size - 4, strerror(errno));
- return NULL;
- }
- /* Send a frame from the file to the appropriate channel */
- /* Read the data into the buffer */
- s->fr.offset = AST_FRIENDLY_OFFSET;
- s->fr.frametype = AST_FRAME_VOICE;
- s->fr.subclass = AST_FORMAT_MP3;
- s->fr.mallocd = 0;
- s->fr.src = name;
- s->fr.datalen = size;
- s->fr.data = s->buf;
- delay = mp3_samples(s->buf) * 1000 / mp3_samplerate(s->buf);
- s->fr.samples = delay * 8;
-#if 0
- ast_log(LOG_DEBUG, "delay is %d, adjusting by %d, as last was %d\n", delay, s->adj, ms);
-#endif
- delay *= 8;
- if (delay < 1)
- delay = 1;
- *whennext = delay;
- return &s->fr;
-}
-
-static int mp3_write(struct ast_filestream *fs, struct ast_frame *f)
-{
- int res;
- if (f->frametype != AST_FRAME_VOICE) {
- ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
- return -1;
- }
- if (f->subclass != AST_FORMAT_MP3) {
- ast_log(LOG_WARNING, "Asked to write non-mp3 frame!\n");
- return -1;
- }
- if ((res = write(fs->fd, f->data, f->datalen)) != f->datalen) {
- ast_log(LOG_WARNING, "Unable to write frame: res=%d (%s)\n", res, strerror(errno));
- return -1;
- }
- return 0;
-}
-
-static int mp3_seek(struct ast_filestream *fs, long sample_offset, int whence)
-{
- return -1;
-}
-
-static int mp3_trunc(struct ast_filestream *fs)
-{
- return -1;
-}
-
-static long mp3_tell(struct ast_filestream *fs)
-{
- return -1;
-}
-
-static char *mp3_getcomment(struct ast_filestream *s)
-{
- return NULL;
-}
-
-int load_module()
-{
- return ast_format_register(name, exts, AST_FORMAT_MP3,
- mp3_open,
- mp3_rewrite,
- mp3_write,
- mp3_seek,
- mp3_trunc,
- mp3_tell,
- mp3_read,
- mp3_close,
- mp3_getcomment);
-
-
-}
-
-int unload_module()
-{
- return ast_format_unregister(name);
-}
-
-int usecount()
-{
- int res;
- if (ast_mutex_lock(&mp3_lock)) {
- ast_log(LOG_WARNING, "Unable to lock mp3 list\n");
- return -1;
- }
- res = glistcnt;
- ast_mutex_unlock(&mp3_lock);
- return res;
-}
-
-char *description()
-{
- return desc;
-}
-
-
-char *key()
-{
- return ASTERISK_GPL_KEY;
-}
diff --git a/frame.c b/frame.c
index 0ff9d2a1e0..5d7d8bde12 100755
--- a/frame.c
+++ b/frame.c
@@ -353,8 +353,8 @@ char* ast_getformatname(int format)
return "ULAW";
else if (format == AST_FORMAT_ALAW)
return "ALAW";
- else if (format == AST_FORMAT_MP3)
- return "MP3";
+ else if (format == AST_FORMAT_G726)
+ return "G726";
else if (format == AST_FORMAT_SLINEAR)
return "SLINR";
else if (format == AST_FORMAT_LPC10)
@@ -388,8 +388,8 @@ int ast_getformatbyname(char *name)
return AST_FORMAT_ULAW;
else if (!strcasecmp(name, "alaw"))
return AST_FORMAT_ALAW;
- else if (!strcasecmp(name, "mp3"))
- return AST_FORMAT_MP3;
+ else if (!strcasecmp(name, "g726"))
+ return AST_FORMAT_G726;
else if (!strcasecmp(name, "slinear"))
return AST_FORMAT_SLINEAR;
else if (!strcasecmp(name, "lpc10"))
diff --git a/include/asterisk/frame.h b/include/asterisk/frame.h
index 9c5ba203ef..95b1f64051 100755
--- a/include/asterisk/frame.h
+++ b/include/asterisk/frame.h
@@ -150,9 +150,9 @@ struct ast_frame_chain {
#define AST_FORMAT_ULAW (1 << 2)
/*! Raw A-law data (G.711) */
#define AST_FORMAT_ALAW (1 << 3)
-/*! MPEG-2 layer 3 */
-#define AST_FORMAT_MP3 (1 << 4)
-/*! ADPCM (whose?) */
+/*! ADPCM (G.726, 32kbps) */
+#define AST_FORMAT_G726 (1 << 4)
+/*! ADPCM (IMA) */
#define AST_FORMAT_ADPCM (1 << 5)
/*! Raw 16-bit Signed Linear (8000 Hz) PCM */
#define AST_FORMAT_SLINEAR (1 << 6)
diff --git a/rtp.c b/rtp.c
index cb66ea9e84..4025b5105b 100755
--- a/rtp.c
+++ b/rtp.c
@@ -508,7 +508,7 @@ static struct {
{{1, AST_FORMAT_GSM}, "audio", "GSM"},
{{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
{{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
- {{1, AST_FORMAT_MP3}, "audio", "MPA"},
+ {{1, AST_FORMAT_G726}, "audio", "G726-32"},
{{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
{{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
{{1, AST_FORMAT_LPC10}, "audio", "LPC"},
@@ -529,6 +529,7 @@ static struct {
table for transmission */
static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
[0] = {1, AST_FORMAT_ULAW},
+ [2] = {1, AST_FORMAT_G726}, // Technically this is G.721, but if Cisco can do it, so can we...
[3] = {1, AST_FORMAT_GSM},
[4] = {1, AST_FORMAT_G723_1},
[5] = {1, AST_FORMAT_ADPCM}, // 8 kHz
@@ -538,7 +539,6 @@ static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
[10] = {1, AST_FORMAT_SLINEAR}, // 2 channels
[11] = {1, AST_FORMAT_SLINEAR}, // 1 channel
[13] = {0, AST_RTP_CN},
- [14] = {1, AST_FORMAT_MP3},
[16] = {1, AST_FORMAT_ADPCM}, // 11.025 kHz
[17] = {1, AST_FORMAT_ADPCM}, // 22.050 kHz
[18] = {1, AST_FORMAT_G729A},
--
GitLab