remove mpg123
This commit is contained in:
David Rose
parent
19abb2d844
commit
bbe5517c6b
|
|
@ -1 +0,0 @@
|
|||
This is ripped directly out of the mpg123 sources. See http://mpg123.org/
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
//#define DIRECTORY_IF_MPG123 yes
|
||||
//
|
||||
//#begin static_lib_target
|
||||
// #define TARGET mpg123
|
||||
// #define SOURCES \
|
||||
// audio.c dct64.c decode.c decode_2to1.c decode_4to1.c decode_ntom.c \
|
||||
// layer1.c layer2.c layer3.c tabinit.c vbrhead.c xfermem.c common.c \
|
||||
// getbits.c mpgbuffer.c equalizer.c httpget.c readers.c
|
||||
// #define CFLAGS -DGENERIC -DNOXFERMEM
|
||||
//
|
||||
// #define INSTALL_HEADERS \
|
||||
// mpg123.h xfermem.h mpgaudio.h
|
||||
//
|
||||
//#end static_lib_target
|
||||
//
|
||||
|
|
@ -1,270 +0,0 @@
|
|||
|
||||
#include "mpg123.h"
|
||||
#ifdef WIN32
|
||||
#include <io.h>
|
||||
#endif
|
||||
#include <stdlib.h>
|
||||
|
||||
void audio_info_struct_init(struct audio_info_struct *ai)
|
||||
{
|
||||
#ifdef AUDIO_USES_FD
|
||||
ai->fn = -1;
|
||||
#endif
|
||||
#ifdef SGI
|
||||
#if 0
|
||||
ALconfig config;
|
||||
ALport port;
|
||||
#endif
|
||||
#endif
|
||||
ai->rate = -1;
|
||||
ai->gain = -1;
|
||||
ai->output = -1;
|
||||
#ifdef ALSA
|
||||
ai->handle = NULL;
|
||||
ai->alsa_format.format = -1;
|
||||
ai->alsa_format.rate = -1;
|
||||
ai->alsa_format.channels = -1;
|
||||
#endif
|
||||
ai->device = NULL;
|
||||
ai->channels = -1;
|
||||
ai->format = -1;
|
||||
}
|
||||
|
||||
#define NUM_CHANNELS 2
|
||||
#define NUM_ENCODINGS 6
|
||||
#define NUM_RATES 10
|
||||
|
||||
struct audio_name audio_val2name[NUM_ENCODINGS+1] = {
|
||||
{ AUDIO_FORMAT_SIGNED_16 , "signed 16 bit" , "s16 " } ,
|
||||
{ AUDIO_FORMAT_UNSIGNED_16, "unsigned 16 bit" , "u16 " } ,
|
||||
{ AUDIO_FORMAT_UNSIGNED_8 , "unsigned 8 bit" , "u8 " } ,
|
||||
{ AUDIO_FORMAT_SIGNED_8 , "signed 8 bit" , "s8 " } ,
|
||||
{ AUDIO_FORMAT_ULAW_8 , "mu-law (8 bit)" , "ulaw " } ,
|
||||
{ AUDIO_FORMAT_ALAW_8 , "a-law (8 bit)" , "alaw " } ,
|
||||
{ -1 , NULL }
|
||||
};
|
||||
|
||||
#if 0
|
||||
static char *channel_name[NUM_CHANNELS] =
|
||||
{ "mono" , "stereo" };
|
||||
#endif
|
||||
|
||||
static int channels[NUM_CHANNELS] = { 1 , 2 };
|
||||
static int rates[NUM_RATES] = {
|
||||
8000, 11025, 12000,
|
||||
16000, 22050, 24000,
|
||||
32000, 44100, 48000,
|
||||
8000 /* 8000 = dummy for user forced */
|
||||
|
||||
};
|
||||
static int encodings[NUM_ENCODINGS] = {
|
||||
AUDIO_FORMAT_SIGNED_16,
|
||||
AUDIO_FORMAT_UNSIGNED_16,
|
||||
AUDIO_FORMAT_UNSIGNED_8,
|
||||
AUDIO_FORMAT_SIGNED_8,
|
||||
AUDIO_FORMAT_ULAW_8,
|
||||
AUDIO_FORMAT_ALAW_8
|
||||
};
|
||||
|
||||
static char capabilities[NUM_CHANNELS][NUM_ENCODINGS][NUM_RATES];
|
||||
|
||||
void audio_capabilities(struct audio_info_struct *ai)
|
||||
{
|
||||
int fmts;
|
||||
int i,j,k,k1=NUM_RATES-1;
|
||||
struct audio_info_struct ai1 = *ai;
|
||||
|
||||
if (param.outmode != DECODE_AUDIO) {
|
||||
memset(capabilities,1,sizeof(capabilities));
|
||||
return;
|
||||
}
|
||||
|
||||
memset(capabilities,0,sizeof(capabilities));
|
||||
if(param.force_rate) {
|
||||
rates[NUM_RATES-1] = param.force_rate;
|
||||
k1 = NUM_RATES;
|
||||
}
|
||||
|
||||
if(audio_open(&ai1) < 0) {
|
||||
perror("audio");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
for(i=0;i<NUM_CHANNELS;i++) {
|
||||
for(j=0;j<NUM_RATES;j++) {
|
||||
ai1.channels = channels[i];
|
||||
ai1.rate = rates[j];
|
||||
fmts = audio_get_formats(&ai1);
|
||||
if(fmts < 0)
|
||||
continue;
|
||||
for(k=0;k<NUM_ENCODINGS;k++) {
|
||||
if((fmts & encodings[k]) == encodings[k])
|
||||
capabilities[i][k][j] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
audio_close(&ai1);
|
||||
|
||||
if(param.verbose > 1) {
|
||||
fprintf(stderr,"\nAudio capabilities:\n |");
|
||||
for(j=0;j<NUM_ENCODINGS;j++) {
|
||||
fprintf(stderr," %5s |",audio_val2name[j].sname);
|
||||
}
|
||||
fprintf(stderr,"\n --------------------------------------------------------\n");
|
||||
for(k=0;k<k1;k++) {
|
||||
fprintf(stderr," %5d |",rates[k]);
|
||||
for(j=0;j<NUM_ENCODINGS;j++) {
|
||||
if(capabilities[0][j][k]) {
|
||||
if(capabilities[1][j][k])
|
||||
fprintf(stderr," M/S |");
|
||||
else
|
||||
fprintf(stderr," M |");
|
||||
}
|
||||
else if(capabilities[1][j][k])
|
||||
fprintf(stderr," S |");
|
||||
else
|
||||
fprintf(stderr," |");
|
||||
}
|
||||
fprintf(stderr,"\n");
|
||||
}
|
||||
fprintf(stderr,"\n");
|
||||
}
|
||||
}
|
||||
|
||||
static int rate2num(int r)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<NUM_RATES;i++)
|
||||
if(rates[i] == r)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static int audio_fit_cap_helper(struct audio_info_struct *ai,int rn,int f0,int f2,int c)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(rn >= 0) {
|
||||
for(i=f0;i<f2;i++) {
|
||||
if(capabilities[c][i][rn]) {
|
||||
ai->rate = rates[rn];
|
||||
ai->format = encodings[i];
|
||||
ai->channels = channels[c];
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* c=num of channels of stream
|
||||
* r=rate of stream
|
||||
*/
|
||||
void audio_fit_capabilities(struct audio_info_struct *ai,int c,int r)
|
||||
{
|
||||
int rn;
|
||||
int f0=0;
|
||||
|
||||
if(param.force_8bit) {
|
||||
f0 = 2;
|
||||
}
|
||||
|
||||
c--; /* stereo=1 ,mono=0 */
|
||||
|
||||
if(param.force_mono >= 0)
|
||||
c = 0;
|
||||
if(param.force_stereo)
|
||||
c = 1;
|
||||
|
||||
if(param.force_rate) {
|
||||
rn = rate2num(param.force_rate);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
|
||||
if(c == 1 && !param.force_stereo)
|
||||
c = 0;
|
||||
else if(c == 0 && !param.force_mono)
|
||||
c = 1;
|
||||
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
|
||||
fprintf(stderr,"No supported rate found!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
rn = rate2num(r>>0);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
rn = rate2num(r>>1);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
rn = rate2num(r>>2);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
|
||||
rn = rate2num(r>>0);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
rn = rate2num(r>>1);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
rn = rate2num(r>>2);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
|
||||
|
||||
if(c == 1 && !param.force_stereo)
|
||||
c = 0;
|
||||
else if(c == 0 && !param.force_mono)
|
||||
c = 1;
|
||||
|
||||
rn = rate2num(r>>0);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
rn = rate2num(r>>1);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
rn = rate2num(r>>2);
|
||||
if(audio_fit_cap_helper(ai,rn,f0,2,c))
|
||||
return;
|
||||
|
||||
rn = rate2num(r>>0);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
rn = rate2num(r>>1);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
rn = rate2num(r>>2);
|
||||
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
|
||||
return;
|
||||
|
||||
fprintf(stderr,"No supported rate found!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
char *audio_encoding_name(int format)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i=0;i<NUM_ENCODINGS;i++) {
|
||||
if(audio_val2name[i].val == format)
|
||||
return audio_val2name[i].name;
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
#if !defined(SOLARIS) && !defined(__NetBSD__) || defined(NAS)
|
||||
void audio_queueflush(struct audio_info_struct *ai)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -1,727 +0,0 @@
|
|||
/* GPL clean */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#ifndef WIN32
|
||||
#include <sys/time.h>
|
||||
#endif /* WIN32 */
|
||||
|
||||
#ifdef WIN32
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef READ_MMAP
|
||||
#include <sys/mman.h>
|
||||
#ifndef MAP_FAILED
|
||||
#define MAP_FAILED ( (void *) -1 )
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "mpg123.h"
|
||||
#include "genre.h"
|
||||
#include "common.h"
|
||||
|
||||
int tabsel_123[2][3][16] = {
|
||||
{ {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
|
||||
{0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
|
||||
{0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} },
|
||||
|
||||
{ {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
|
||||
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
|
||||
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} }
|
||||
};
|
||||
|
||||
long freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
|
||||
|
||||
struct bitstream_info bsi;
|
||||
|
||||
static int fsizeold=0,ssize;
|
||||
static unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
|
||||
static unsigned char *bsbuf=bsspace[1],*bsbufold;
|
||||
static int bsnum=0;
|
||||
|
||||
static unsigned long oldhead = 0;
|
||||
unsigned long firsthead=0;
|
||||
|
||||
unsigned char *pcm_sample;
|
||||
int pcm_point = 0;
|
||||
int audiobufsize = AUDIOBUFSIZE;
|
||||
|
||||
static int decode_header(struct frame *fr,unsigned long newhead);
|
||||
|
||||
void audio_flush(int outmode, struct audio_info_struct *ai)
|
||||
{
|
||||
if (pcm_point) {
|
||||
switch (outmode) {
|
||||
case DECODE_FILE:
|
||||
write (OutputDescriptor, pcm_sample, pcm_point);
|
||||
break;
|
||||
case DECODE_AUDIO:
|
||||
audio_play_samples (ai, pcm_sample, pcm_point);
|
||||
break;
|
||||
case DECODE_BUFFER:
|
||||
write (buffer_fd[1], pcm_sample, pcm_point);
|
||||
break;
|
||||
case DECODE_WAV:
|
||||
case DECODE_CDR:
|
||||
case DECODE_AU:
|
||||
wav_write(pcm_sample, pcm_point);
|
||||
break;
|
||||
}
|
||||
pcm_point = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(WIN32) && !defined(GENERIC)
|
||||
void (*catchsignal(int signum, void(*handler)()))()
|
||||
{
|
||||
struct sigaction new_sa;
|
||||
struct sigaction old_sa;
|
||||
|
||||
#ifdef DONT_CATCH_SIGNALS
|
||||
printf ("Not catching any signals.\n");
|
||||
return ((void (*)()) -1);
|
||||
#endif
|
||||
|
||||
new_sa.sa_handler = handler;
|
||||
sigemptyset(&new_sa.sa_mask);
|
||||
new_sa.sa_flags = 0;
|
||||
if (sigaction(signum, &new_sa, &old_sa) == -1)
|
||||
return ((void (*)()) -1);
|
||||
return (old_sa.sa_handler);
|
||||
}
|
||||
#endif
|
||||
|
||||
void read_frame_init (void)
|
||||
{
|
||||
oldhead = 0;
|
||||
firsthead = 0;
|
||||
}
|
||||
|
||||
int head_check(unsigned long head)
|
||||
{
|
||||
/* fprintf(stderr,"HC"); */
|
||||
if( (head & 0xffe00000) != 0xffe00000)
|
||||
return FALSE;
|
||||
if(!((head>>17)&3))
|
||||
return FALSE;
|
||||
if( ((head>>12)&0xf) == 0xf)
|
||||
return FALSE;
|
||||
if( ((head>>10)&0x3) == 0x3 )
|
||||
return FALSE;
|
||||
#if 0
|
||||
/* this would match on MPEG1/Layer1 streams with CRC = off */
|
||||
if ((head & 0xffff0000) == 0xffff0000)
|
||||
return FALSE;
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*****************************************************************
|
||||
* read next frame
|
||||
*/
|
||||
int read_frame(struct frame *fr)
|
||||
{
|
||||
unsigned long newhead;
|
||||
static unsigned char ssave[34];
|
||||
|
||||
fsizeold=fr->framesize; /* for Layer3 */
|
||||
|
||||
if (param.halfspeed) {
|
||||
static int halfphase = 0;
|
||||
if (halfphase--) {
|
||||
bsi.bitindex = 0;
|
||||
bsi.wordpointer = (unsigned char *) bsbuf;
|
||||
if (fr->lay == 3)
|
||||
memcpy (bsbuf, ssave, ssize);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
halfphase = param.halfspeed - 1;
|
||||
}
|
||||
|
||||
read_again:
|
||||
if(!rd->head_read(rd,&newhead))
|
||||
return FALSE;
|
||||
|
||||
if(1 || oldhead != newhead || !oldhead) {
|
||||
|
||||
init_resync:
|
||||
|
||||
fr->header_change = 2;
|
||||
if(oldhead) {
|
||||
if((oldhead & 0xc00) == (newhead & 0xc00)) {
|
||||
if( (oldhead & 0xc0) == 0 && (newhead & 0xc0) == 0)
|
||||
fr->header_change = 1;
|
||||
else if( (oldhead & 0xc0) > 0 && (newhead & 0xc0) > 0)
|
||||
fr->header_change = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef SKIP_JUNK
|
||||
if(!firsthead && !head_check(newhead) ) {
|
||||
int i;
|
||||
|
||||
fprintf(stderr,"Junk at the beginning %08lx\n",newhead);
|
||||
|
||||
/* I even saw RIFF headers at the beginning of MPEG streams ;( */
|
||||
if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F') {
|
||||
if(!rd->head_read(rd,&newhead))
|
||||
return 0;
|
||||
while(newhead != ('d'<<24)+('a'<<16)+('t'<<8)+'a') {
|
||||
if(!rd->head_shift(rd,&newhead))
|
||||
return 0;
|
||||
}
|
||||
if(!rd->head_read(rd,&newhead))
|
||||
return 0;
|
||||
/* fprintf(stderr,"Skipped RIFF header!\n"); */
|
||||
goto read_again;
|
||||
}
|
||||
{
|
||||
/* step in byte steps through next 64K */
|
||||
for(i=0;i<65536;i++) {
|
||||
if(!rd->head_shift(rd,&newhead))
|
||||
return 0;
|
||||
if(head_check(newhead))
|
||||
break;
|
||||
}
|
||||
if(i == 65536) {
|
||||
fprintf(stderr,"Giving up searching valid MPEG header\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* should we additionaly check, whether a new frame starts at
|
||||
* the next expected position? (some kind of read ahead)
|
||||
* We could implement this easily, at least for files.
|
||||
*/
|
||||
}
|
||||
#endif
|
||||
|
||||
if( (newhead & 0xffe00000) != 0xffe00000) {
|
||||
if (!param.quiet)
|
||||
fprintf(stderr,"Illegal Audio-MPEG-Header 0x%08lx at offset 0x%lx.\n",
|
||||
newhead,rd->tell(rd)-4);
|
||||
/* and those ugly ID3 tags */
|
||||
if((newhead & 0xffffff00) == ('T'<<24)+('A'<<16)+('G'<<8)) {
|
||||
rd->skip_bytes(rd,124);
|
||||
fprintf(stderr,"Skipped ID3 Tag!\n");
|
||||
goto read_again;
|
||||
}
|
||||
if (param.tryresync) {
|
||||
int try = 0;
|
||||
/* Read more bytes until we find something that looks
|
||||
reasonably like a valid header. This is not a
|
||||
perfect strategy, but it should get us back on the
|
||||
track within a short time (and hopefully without
|
||||
too much distortion in the audio output). */
|
||||
do {
|
||||
try++;
|
||||
if(!rd->head_shift(rd,&newhead))
|
||||
return 0;
|
||||
if (!oldhead)
|
||||
goto init_resync; /* "considered harmful", eh? */
|
||||
|
||||
} while ((newhead & HDRCMPMASK) != (oldhead & HDRCMPMASK)
|
||||
&& (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK));
|
||||
if (!param.quiet)
|
||||
fprintf (stderr, "Skipped %d bytes in input.\n", try);
|
||||
}
|
||||
else
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* fprintf(stderr,"+"); */
|
||||
|
||||
if (!firsthead) {
|
||||
if(!decode_header(fr,newhead)) {
|
||||
/* fprintf(stderr,"A"); */
|
||||
goto read_again;
|
||||
}
|
||||
firsthead = newhead;
|
||||
|
||||
}
|
||||
else if(!decode_header(fr,newhead)) {
|
||||
/* fprintf(stderr,"B: %08lx\n",newhead); */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* fprintf(stderr,"-"); */
|
||||
}
|
||||
else
|
||||
fr->header_change = 0;
|
||||
|
||||
/* fprintf(stderr,"FS: %d\n",fr->framesize); */
|
||||
|
||||
/* flip/init buffer for Layer 3 */
|
||||
bsbufold = bsbuf;
|
||||
bsbuf = bsspace[bsnum]+512;
|
||||
bsnum = (bsnum + 1) & 1;
|
||||
|
||||
/* read main data into memory */
|
||||
if(!rd->read_frame_body(rd,bsbuf,fr->framesize))
|
||||
return 0;
|
||||
|
||||
{
|
||||
/* Test */
|
||||
static struct vbrHeader head;
|
||||
static int vbr = 0;
|
||||
if(!vbr) {
|
||||
getVBRHeader(&head,bsbuf,fr);
|
||||
vbr = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* fprintf(stderr,"Got it\n"); */
|
||||
|
||||
bsi.bitindex = 0;
|
||||
bsi.wordpointer = (unsigned char *) bsbuf;
|
||||
|
||||
if (param.halfspeed && fr->lay == 3)
|
||||
memcpy (ssave, bsbuf, ssize);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/****************************************
|
||||
* HACK,HACK,HACK: step back <num> frames
|
||||
* can only work if the 'stream' isn't a real stream but a file
|
||||
*/
|
||||
int back_frame(struct reader *rds,struct frame *fr,int num)
|
||||
{
|
||||
long bytes;
|
||||
unsigned long newhead;
|
||||
|
||||
if(!firsthead)
|
||||
return 0;
|
||||
|
||||
bytes = (fr->framesize+8)*(num+2);
|
||||
|
||||
if(rds->back_bytes(rds,bytes) < 0)
|
||||
return -1;
|
||||
if(!rds->head_read(rds,&newhead))
|
||||
return -1;
|
||||
|
||||
while( (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK) ) {
|
||||
if(!rds->head_shift(rds,&newhead))
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(rds->back_bytes(rds,4) <0)
|
||||
return -1;
|
||||
|
||||
read_frame(fr);
|
||||
read_frame(fr);
|
||||
|
||||
if(fr->lay == 3) {
|
||||
set_pointer(512);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* decode a header and write the information
|
||||
* into the frame structure
|
||||
*/
|
||||
static int decode_header(struct frame *fr,unsigned long newhead)
|
||||
{
|
||||
if(!head_check(newhead)) {
|
||||
fprintf(stderr,"Oopps header is wrong\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if( newhead & (1<<20) ) {
|
||||
fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1;
|
||||
fr->mpeg25 = 0;
|
||||
}
|
||||
else {
|
||||
fr->lsf = 1;
|
||||
fr->mpeg25 = 1;
|
||||
}
|
||||
|
||||
if (!param.tryresync || !oldhead) {
|
||||
/* If "tryresync" is true, assume that certain
|
||||
parameters do not change within the stream! */
|
||||
fr->lay = 4-((newhead>>17)&3);
|
||||
if( ((newhead>>10)&0x3) == 0x3) {
|
||||
fprintf(stderr,"Stream error\n");
|
||||
exit(1);
|
||||
}
|
||||
if(fr->mpeg25) {
|
||||
fr->sampling_frequency = 6 + ((newhead>>10)&0x3);
|
||||
}
|
||||
else
|
||||
fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3);
|
||||
fr->error_protection = ((newhead>>16)&0x1)^0x1;
|
||||
}
|
||||
|
||||
fr->bitrate_index = ((newhead>>12)&0xf);
|
||||
fr->padding = ((newhead>>9)&0x1);
|
||||
fr->extension = ((newhead>>8)&0x1);
|
||||
fr->mode = ((newhead>>6)&0x3);
|
||||
fr->mode_ext = ((newhead>>4)&0x3);
|
||||
fr->copyright = ((newhead>>3)&0x1);
|
||||
fr->original = ((newhead>>2)&0x1);
|
||||
fr->emphasis = newhead & 0x3;
|
||||
|
||||
fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2;
|
||||
|
||||
oldhead = newhead;
|
||||
|
||||
if(!fr->bitrate_index) {
|
||||
fprintf(stderr,"Free format not supported: (head %08lx)\n",newhead);
|
||||
return (0);
|
||||
}
|
||||
|
||||
switch(fr->lay) {
|
||||
case 1:
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency];
|
||||
fr->framesize = ((fr->framesize+fr->padding)<<2)-4;
|
||||
break;
|
||||
case 2:
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency];
|
||||
fr->framesize += fr->padding - 4;
|
||||
break;
|
||||
case 3:
|
||||
if(fr->lsf)
|
||||
ssize = (fr->stereo == 1) ? 9 : 17;
|
||||
else
|
||||
ssize = (fr->stereo == 1) ? 17 : 32;
|
||||
if(fr->error_protection)
|
||||
ssize += 2;
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf);
|
||||
fr->framesize = fr->framesize + fr->padding - 4;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr,"Sorry, unknown layer type.\n");
|
||||
return (0);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifdef MPG123_REMOTE
|
||||
void print_rheader(struct frame *fr)
|
||||
{
|
||||
static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" };
|
||||
static char *layers[4] = { "Unknown" , "I", "II", "III" };
|
||||
static char *mpeg_type[2] = { "1.0" , "2.0" };
|
||||
|
||||
/* version, layer, freq, mode, channels, bitrate, BPF */
|
||||
fprintf(stderr,"@I %s %s %ld %s %d %d %d\n",
|
||||
mpeg_type[fr->lsf],layers[fr->lay],freqs[fr->sampling_frequency],
|
||||
modes[fr->mode],fr->stereo,
|
||||
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],
|
||||
fr->framesize+4);
|
||||
}
|
||||
#endif
|
||||
|
||||
void print_header(struct frame *fr)
|
||||
{
|
||||
static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" };
|
||||
static char *layers[4] = { "Unknown" , "I", "II", "III" };
|
||||
|
||||
fprintf(stderr,"MPEG %s, Layer: %s, Freq: %ld, mode: %s, modext: %d, BPF : %d\n",
|
||||
fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"),
|
||||
layers[fr->lay],freqs[fr->sampling_frequency],
|
||||
modes[fr->mode],fr->mode_ext,fr->framesize+4);
|
||||
fprintf(stderr,"Channels: %d, copyright: %s, original: %s, CRC: %s, emphasis: %d.\n",
|
||||
fr->stereo,fr->copyright?"Yes":"No",
|
||||
fr->original?"Yes":"No",fr->error_protection?"Yes":"No",
|
||||
fr->emphasis);
|
||||
fprintf(stderr,"Bitrate: %d Kbits/s, Extension value: %d\n",
|
||||
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],fr->extension);
|
||||
}
|
||||
|
||||
void print_header_compact(struct frame *fr)
|
||||
{
|
||||
static char *modes[4] = { "stereo", "joint-stereo", "dual-channel", "mono" };
|
||||
static char *layers[4] = { "Unknown" , "I", "II", "III" };
|
||||
|
||||
fprintf(stderr,"MPEG %s layer %s, %d kbit/s, %ld Hz %s\n",
|
||||
fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"),
|
||||
layers[fr->lay],
|
||||
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],
|
||||
freqs[fr->sampling_frequency], modes[fr->mode]);
|
||||
}
|
||||
|
||||
void print_id3_tag(unsigned char *buf)
|
||||
{
|
||||
struct id3tag {
|
||||
char tag[3];
|
||||
char title[30];
|
||||
char artist[30];
|
||||
char album[30];
|
||||
char year[4];
|
||||
char comment[30];
|
||||
unsigned char genre;
|
||||
};
|
||||
struct id3tag *tag = (struct id3tag *) buf;
|
||||
char title[31]={0,};
|
||||
char artist[31]={0,};
|
||||
char album[31]={0,};
|
||||
char year[5]={0,};
|
||||
char comment[31]={0,};
|
||||
char genre[31]={0,};
|
||||
|
||||
if(param.quiet)
|
||||
return;
|
||||
|
||||
strncpy(title,tag->title,30);
|
||||
strncpy(artist,tag->artist,30);
|
||||
strncpy(album,tag->album,30);
|
||||
strncpy(year,tag->year,4);
|
||||
strncpy(comment,tag->comment,30);
|
||||
|
||||
if ( tag->genre < sizeof(genre_table)/sizeof(*genre_table) ) {
|
||||
strncpy(genre, genre_table[tag->genre], 30);
|
||||
} else {
|
||||
strncpy(genre,"Unknown",30);
|
||||
}
|
||||
|
||||
fprintf(stderr,"Title : %-30s Artist: %s\n",title,artist);
|
||||
fprintf(stderr,"Album : %-30s Year : %4s\n",album,year);
|
||||
fprintf(stderr,"Comment: %-30s Genre : %s\n",comment,genre);
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* removed the strndup for better portability */
|
||||
/*
|
||||
* Allocate space for a new string containing the first
|
||||
* "num" characters of "src". The resulting string is
|
||||
* always zero-terminated. Returns NULL if malloc fails.
|
||||
*/
|
||||
char *strndup (const char *src, int num)
|
||||
{
|
||||
char *dst;
|
||||
|
||||
if (!(dst = (char *) malloc(num+1)))
|
||||
return (NULL);
|
||||
dst[num] = '\0';
|
||||
return (strncpy(dst, src, num));
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Split "path" into directory and filename components.
|
||||
*
|
||||
* Return value is 0 if no directory was specified (i.e.
|
||||
* "path" does not contain a '/'), OR if the directory
|
||||
* is the same as on the previous call to this function.
|
||||
*
|
||||
* Return value is 1 if a directory was specified AND it
|
||||
* is different from the previous one (if any).
|
||||
*/
|
||||
|
||||
int split_dir_file (const char *path, char **dname, char **fname)
|
||||
{
|
||||
static char *lastdir = NULL;
|
||||
char *slashpos;
|
||||
|
||||
if ((slashpos = strrchr(path, '/'))) {
|
||||
*fname = slashpos + 1;
|
||||
*dname = strdup(path); /* , 1 + slashpos - path); */
|
||||
if(!(*dname)) {
|
||||
perror("memory");
|
||||
exit(1);
|
||||
}
|
||||
(*dname)[1 + slashpos - path] = 0;
|
||||
if (lastdir && !strcmp(lastdir, *dname)) {
|
||||
/*** same as previous directory ***/
|
||||
free (*dname);
|
||||
*dname = lastdir;
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
/*** different directory ***/
|
||||
if (lastdir)
|
||||
free (lastdir);
|
||||
lastdir = *dname;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/*** no directory specified ***/
|
||||
if (lastdir) {
|
||||
free (lastdir);
|
||||
lastdir = NULL;
|
||||
};
|
||||
*dname = NULL;
|
||||
*fname = (char *)path;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void set_pointer(long backstep)
|
||||
{
|
||||
bsi.wordpointer = bsbuf + ssize - backstep;
|
||||
if (backstep)
|
||||
memcpy(bsi.wordpointer,bsbufold+fsizeold-backstep,backstep);
|
||||
bsi.bitindex = 0;
|
||||
}
|
||||
|
||||
/********************************/
|
||||
|
||||
double compute_bpf(struct frame *fr)
|
||||
{
|
||||
double bpf;
|
||||
|
||||
switch(fr->lay) {
|
||||
case 1:
|
||||
bpf = tabsel_123[fr->lsf][0][fr->bitrate_index];
|
||||
bpf *= 12000.0 * 4.0;
|
||||
bpf /= freqs[fr->sampling_frequency] <<(fr->lsf);
|
||||
break;
|
||||
case 2:
|
||||
case 3:
|
||||
bpf = tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
|
||||
bpf *= 144000;
|
||||
bpf /= freqs[fr->sampling_frequency] << (fr->lsf);
|
||||
break;
|
||||
default:
|
||||
bpf = 1.0;
|
||||
}
|
||||
|
||||
return bpf;
|
||||
}
|
||||
|
||||
double compute_tpf(struct frame *fr)
|
||||
{
|
||||
static int bs[4] = { 0,384,1152,1152 };
|
||||
double tpf;
|
||||
|
||||
tpf = (double) bs[fr->lay];
|
||||
tpf /= freqs[fr->sampling_frequency] << (fr->lsf);
|
||||
return tpf;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns number of frames queued up in output buffer, i.e.
|
||||
* offset between currently played and currently decoded frame.
|
||||
*/
|
||||
|
||||
long compute_buffer_offset(struct frame *fr)
|
||||
{
|
||||
long bufsize;
|
||||
|
||||
/*
|
||||
* buffermem->buf[0] holds output sampling rate,
|
||||
* buffermem->buf[1] holds number of channels,
|
||||
* buffermem->buf[2] holds audio format of output.
|
||||
*/
|
||||
|
||||
if(!param.usebuffer || !(bufsize=xfermem_get_usedspace(buffermem))
|
||||
|| !buffermem->buf[0] || !buffermem->buf[1])
|
||||
return 0;
|
||||
|
||||
bufsize = (long)((double) bufsize / buffermem->buf[0] /
|
||||
buffermem->buf[1] / compute_tpf(fr));
|
||||
|
||||
if((buffermem->buf[2] & AUDIO_FORMAT_MASK) == AUDIO_FORMAT_16)
|
||||
return bufsize/2;
|
||||
else
|
||||
return bufsize;
|
||||
}
|
||||
|
||||
void print_stat(struct frame *fr,int no,long buffsize,struct audio_info_struct *ai)
|
||||
{
|
||||
double bpf,tpf,tim1,tim2;
|
||||
double dt = 0.0;
|
||||
int sno,rno;
|
||||
char outbuf[256];
|
||||
|
||||
if(!rd || !fr)
|
||||
return;
|
||||
|
||||
outbuf[0] = 0;
|
||||
|
||||
#ifndef GENERIC
|
||||
{
|
||||
struct timeval t;
|
||||
fd_set serr;
|
||||
int n,errfd = fileno(stderr);
|
||||
|
||||
t.tv_sec=t.tv_usec=0;
|
||||
|
||||
FD_ZERO(&serr);
|
||||
FD_SET(errfd,&serr);
|
||||
n = select(errfd+1,NULL,&serr,NULL,&t);
|
||||
if(n <= 0)
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
bpf = compute_bpf(fr);
|
||||
tpf = compute_tpf(fr);
|
||||
|
||||
if(buffsize > 0 && ai && ai->rate > 0 && ai->channels > 0) {
|
||||
dt = (double) buffsize / ai->rate / ai->channels;
|
||||
if( (ai->format & AUDIO_FORMAT_MASK) == AUDIO_FORMAT_16)
|
||||
dt *= 0.5;
|
||||
}
|
||||
|
||||
rno = 0;
|
||||
sno = no;
|
||||
if(rd->filelen >= 0) {
|
||||
long t = rd->tell(rd);
|
||||
rno = (int)((double)(rd->filelen-t)/bpf);
|
||||
sno = (int)((double)t/bpf);
|
||||
}
|
||||
|
||||
sprintf(outbuf+strlen(outbuf),"\rFrame# %5d [%5d], ",sno,rno);
|
||||
|
||||
tim1 = sno*tpf-dt;
|
||||
tim2 = rno*tpf+dt;
|
||||
#if 0
|
||||
tim1 = tim1 < 0 ? 0.0 : tim1;
|
||||
#endif
|
||||
tim2 = tim2 < 0 ? 0.0 : tim2;
|
||||
|
||||
sprintf(outbuf+strlen(outbuf),"Time: %02u:%02u.%02u [%02u:%02u.%02u], ",
|
||||
(unsigned int)tim1/60,
|
||||
(unsigned int)tim1%60,
|
||||
(unsigned int)(tim1*100)%100,
|
||||
(unsigned int)tim2/60,
|
||||
(unsigned int)tim2%60,
|
||||
(unsigned int)(tim2*100)%100);
|
||||
|
||||
if(param.usebuffer)
|
||||
sprintf(outbuf+strlen(outbuf),"[%8ld] ",(long)buffsize);
|
||||
write(fileno(stderr),outbuf,strlen(outbuf));
|
||||
#if 0
|
||||
fflush(out); /* hmm not really nec. */
|
||||
#endif
|
||||
}
|
||||
|
||||
int get_songlen(struct frame *fr,int no)
|
||||
{
|
||||
double tpf;
|
||||
|
||||
if(!fr)
|
||||
return 0;
|
||||
|
||||
if(no < 0) {
|
||||
if(!rd || rd->filelen < 0)
|
||||
return 0;
|
||||
no = (double) rd->filelen / compute_bpf(fr);
|
||||
}
|
||||
|
||||
tpf = compute_tpf(fr);
|
||||
return no*tpf;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
/*
|
||||
* common.h
|
||||
*/
|
||||
|
||||
extern void print_id3_tag(unsigned char *buf);
|
||||
extern unsigned long firsthead;
|
||||
extern int tabsel_123[2][3][16];
|
||||
extern double compute_tpf(struct frame *fr);
|
||||
extern double compute_bpf(struct frame *fr);
|
||||
extern long compute_buffer_offset(struct frame *fr);
|
||||
|
||||
/*
|
||||
struct bitstream_info {
|
||||
int bitindex;
|
||||
unsigned char *wordpointer;
|
||||
};
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -1,168 +0,0 @@
|
|||
|
||||
/*
|
||||
* Discrete Cosine Tansform (DCT) for subband synthesis
|
||||
*
|
||||
* -funroll-loops (for gcc) will remove the loops for better performance
|
||||
* using loops in the source-code enhances readabillity
|
||||
*/
|
||||
|
||||
/*
|
||||
* TODO: write an optimized version for the down-sampling modes
|
||||
* (in these modes the bands 16-31 (2:1) or 8-31 (4:1) are zero
|
||||
*/
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
void dct64(real *out0,real *out1,real *samples)
|
||||
{
|
||||
real bufs[64];
|
||||
|
||||
{
|
||||
register int i,j;
|
||||
register real *b1,*b2,*bs,*costab;
|
||||
|
||||
b1 = samples;
|
||||
bs = bufs;
|
||||
costab = pnts[0]+16;
|
||||
b2 = b1 + 32;
|
||||
|
||||
for(i=15;i>=0;i--)
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
for(i=15;i>=0;i--)
|
||||
*bs++ = (*--b2 - *b1++) * *--costab;
|
||||
|
||||
b1 = bufs;
|
||||
costab = pnts[1]+8;
|
||||
b2 = b1 + 16;
|
||||
|
||||
{
|
||||
for(i=7;i>=0;i--)
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
for(i=7;i>=0;i--)
|
||||
*bs++ = (*--b2 - *b1++) * *--costab;
|
||||
b2 += 32;
|
||||
costab += 8;
|
||||
for(i=7;i>=0;i--)
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
for(i=7;i>=0;i--)
|
||||
*bs++ = (*b1++ - *--b2) * *--costab;
|
||||
b2 += 32;
|
||||
}
|
||||
|
||||
bs = bufs;
|
||||
costab = pnts[2];
|
||||
b2 = b1 + 8;
|
||||
|
||||
for(j=2;j;j--)
|
||||
{
|
||||
for(i=3;i>=0;i--)
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
for(i=3;i>=0;i--)
|
||||
*bs++ = (*--b2 - *b1++) * costab[i];
|
||||
b2 += 16;
|
||||
for(i=3;i>=0;i--)
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
for(i=3;i>=0;i--)
|
||||
*bs++ = (*b1++ - *--b2) * costab[i];
|
||||
b2 += 16;
|
||||
}
|
||||
|
||||
b1 = bufs;
|
||||
costab = pnts[3];
|
||||
b2 = b1 + 4;
|
||||
|
||||
for(j=4;j;j--)
|
||||
{
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
*bs++ = (*--b2 - *b1++) * costab[1];
|
||||
*bs++ = (*--b2 - *b1++) * costab[0];
|
||||
b2 += 8;
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
*bs++ = (*b1++ + *--b2);
|
||||
*bs++ = (*b1++ - *--b2) * costab[1];
|
||||
*bs++ = (*b1++ - *--b2) * costab[0];
|
||||
b2 += 8;
|
||||
}
|
||||
bs = bufs;
|
||||
costab = pnts[4];
|
||||
|
||||
for(j=8;j;j--)
|
||||
{
|
||||
real v0,v1;
|
||||
v0=*b1++; v1 = *b1++;
|
||||
*bs++ = (v0 + v1);
|
||||
*bs++ = (v0 - v1) * (*costab);
|
||||
v0=*b1++; v1 = *b1++;
|
||||
*bs++ = (v0 + v1);
|
||||
*bs++ = (v1 - v0) * (*costab);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
register real *b1;
|
||||
register int i;
|
||||
|
||||
for(b1=bufs,i=8;i;i--,b1+=4)
|
||||
b1[2] += b1[3];
|
||||
|
||||
for(b1=bufs,i=4;i;i--,b1+=8)
|
||||
{
|
||||
b1[4] += b1[6];
|
||||
b1[6] += b1[5];
|
||||
b1[5] += b1[7];
|
||||
}
|
||||
|
||||
for(b1=bufs,i=2;i;i--,b1+=16)
|
||||
{
|
||||
b1[8] += b1[12];
|
||||
b1[12] += b1[10];
|
||||
b1[10] += b1[14];
|
||||
b1[14] += b1[9];
|
||||
b1[9] += b1[13];
|
||||
b1[13] += b1[11];
|
||||
b1[11] += b1[15];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
out0[0x10*16] = bufs[0];
|
||||
out0[0x10*15] = bufs[16+0] + bufs[16+8];
|
||||
out0[0x10*14] = bufs[8];
|
||||
out0[0x10*13] = bufs[16+8] + bufs[16+4];
|
||||
out0[0x10*12] = bufs[4];
|
||||
out0[0x10*11] = bufs[16+4] + bufs[16+12];
|
||||
out0[0x10*10] = bufs[12];
|
||||
out0[0x10* 9] = bufs[16+12] + bufs[16+2];
|
||||
out0[0x10* 8] = bufs[2];
|
||||
out0[0x10* 7] = bufs[16+2] + bufs[16+10];
|
||||
out0[0x10* 6] = bufs[10];
|
||||
out0[0x10* 5] = bufs[16+10] + bufs[16+6];
|
||||
out0[0x10* 4] = bufs[6];
|
||||
out0[0x10* 3] = bufs[16+6] + bufs[16+14];
|
||||
out0[0x10* 2] = bufs[14];
|
||||
out0[0x10* 1] = bufs[16+14] + bufs[16+1];
|
||||
out0[0x10* 0] = bufs[1];
|
||||
|
||||
out1[0x10* 0] = bufs[1];
|
||||
out1[0x10* 1] = bufs[16+1] + bufs[16+9];
|
||||
out1[0x10* 2] = bufs[9];
|
||||
out1[0x10* 3] = bufs[16+9] + bufs[16+5];
|
||||
out1[0x10* 4] = bufs[5];
|
||||
out1[0x10* 5] = bufs[16+5] + bufs[16+13];
|
||||
out1[0x10* 6] = bufs[13];
|
||||
out1[0x10* 7] = bufs[16+13] + bufs[16+3];
|
||||
out1[0x10* 8] = bufs[3];
|
||||
out1[0x10* 9] = bufs[16+3] + bufs[16+11];
|
||||
out1[0x10*10] = bufs[11];
|
||||
out1[0x10*11] = bufs[16+11] + bufs[16+7];
|
||||
out1[0x10*12] = bufs[7];
|
||||
out1[0x10*13] = bufs[16+7] + bufs[16+15];
|
||||
out1[0x10*14] = bufs[15];
|
||||
out1[0x10*15] = bufs[16+15];
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,223 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-1,2,3 audio decoder
|
||||
* ------------------------------
|
||||
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
|
||||
* See also 'README'
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#define WRITE_SAMPLE(samples,sum,clip) \
|
||||
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
|
||||
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
|
||||
else { *(samples) = sum; }
|
||||
|
||||
int synth_1to1_8bit(real *bandPtr,int channel,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[64];
|
||||
short *tmp1 = samples_tmp + channel;
|
||||
int i,ret;
|
||||
int pnt1=0;
|
||||
|
||||
ret = synth_1to1(bandPtr,channel,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += channel + *pnt;
|
||||
|
||||
for(i=0;i<32;i++) {
|
||||
*samples = conv16to8[*tmp1>>AUSHIFT];
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 64;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_1to1_8bit_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<32;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 32;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_1to1_8bit_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<32;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 64;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_1to1_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<32;i++) {
|
||||
*( (short *)samples) = *tmp1;
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 64;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_1to1_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
int i,ret;
|
||||
|
||||
ret = synth_1to1(bandPtr,0,samples,pnt);
|
||||
samples = samples + *pnt - 128;
|
||||
|
||||
for(i=0;i<32;i++) {
|
||||
((short *)samples)[1] = ((short *)samples)[0];
|
||||
samples+=4;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_1to1(real *bandPtr,int channel,unsigned char *out,int *pnt)
|
||||
{
|
||||
static real buffs[2][2][0x110];
|
||||
static const int step = 2;
|
||||
static int bo = 1;
|
||||
short *samples = (short *) (out+*pnt);
|
||||
|
||||
real *b0,(*buf)[0x110];
|
||||
int clip = 0;
|
||||
int bo1;
|
||||
|
||||
if(param.enable_equalizer)
|
||||
do_equalizer(bandPtr,channel);
|
||||
|
||||
if(!channel) {
|
||||
bo--;
|
||||
bo &= 0xf;
|
||||
buf = buffs[0];
|
||||
}
|
||||
else {
|
||||
samples++;
|
||||
buf = buffs[1];
|
||||
}
|
||||
|
||||
if(bo & 0x1) {
|
||||
b0 = buf[0];
|
||||
bo1 = bo;
|
||||
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
|
||||
}
|
||||
else {
|
||||
b0 = buf[1];
|
||||
bo1 = bo+1;
|
||||
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
register int j;
|
||||
real *window = decwin + 16 - bo1;
|
||||
|
||||
for (j=16;j;j--,window+=0x10,samples+=step)
|
||||
{
|
||||
real sum;
|
||||
sum = *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
}
|
||||
|
||||
{
|
||||
real sum;
|
||||
sum = window[0x0] * b0[0x0];
|
||||
sum += window[0x2] * b0[0x2];
|
||||
sum += window[0x4] * b0[0x4];
|
||||
sum += window[0x6] * b0[0x6];
|
||||
sum += window[0x8] * b0[0x8];
|
||||
sum += window[0xA] * b0[0xA];
|
||||
sum += window[0xC] * b0[0xC];
|
||||
sum += window[0xE] * b0[0xE];
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
b0-=0x10,window-=0x20,samples+=step;
|
||||
}
|
||||
window += bo1<<1;
|
||||
|
||||
for (j=15;j;j--,b0-=0x20,window-=0x10,samples+=step)
|
||||
{
|
||||
real sum;
|
||||
sum = -*(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
}
|
||||
}
|
||||
|
||||
*pnt += 128;
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,231 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-1,2,3 audio decoder
|
||||
* ------------------------------
|
||||
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README'
|
||||
* version for slower machines .. decodes only every second sample
|
||||
* sounds like 24000,22050 or 16000 kHz .. (depending on original sample freq.)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#define WRITE_SAMPLE(samples,sum,clip) \
|
||||
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
|
||||
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
|
||||
else { *(samples) = sum; }
|
||||
|
||||
int synth_2to1_8bit(real *bandPtr,int channel,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[32];
|
||||
short *tmp1 = samples_tmp + channel;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_2to1(bandPtr,channel,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += channel + *pnt;
|
||||
|
||||
for(i=0;i<16;i++) {
|
||||
*samples = conv16to8[*tmp1>>AUSHIFT];
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 32;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_2to1_8bit_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[32];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_2to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<16;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 16;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_2to1_8bit_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[32];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_2to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<16;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 32;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_2to1_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[32];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1=0;
|
||||
|
||||
ret = synth_2to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<16;i++) {
|
||||
*( (short *) samples) = *tmp1;
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 32;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_2to1_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
int i,ret;
|
||||
|
||||
ret = synth_2to1(bandPtr,0,samples,pnt);
|
||||
samples = samples + *pnt - 64;
|
||||
|
||||
for(i=0;i<16;i++) {
|
||||
((short *)samples)[1] = ((short *)samples)[0];
|
||||
samples+=4;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_2to1(real *bandPtr,int channel,unsigned char *out,int *pnt)
|
||||
{
|
||||
static real buffs[2][2][0x110];
|
||||
static const int step = 2;
|
||||
static int bo = 1;
|
||||
short *samples = (short *) (out + *pnt);
|
||||
|
||||
real *b0,(*buf)[0x110];
|
||||
int clip = 0;
|
||||
int bo1;
|
||||
|
||||
if(param.enable_equalizer)
|
||||
do_equalizer(bandPtr,channel);
|
||||
|
||||
if(!channel) {
|
||||
bo--;
|
||||
bo &= 0xf;
|
||||
buf = buffs[0];
|
||||
}
|
||||
else {
|
||||
samples++;
|
||||
buf = buffs[1];
|
||||
}
|
||||
|
||||
if(bo & 0x1) {
|
||||
b0 = buf[0];
|
||||
bo1 = bo;
|
||||
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
|
||||
}
|
||||
else {
|
||||
b0 = buf[1];
|
||||
bo1 = bo+1;
|
||||
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
|
||||
}
|
||||
|
||||
{
|
||||
register int j;
|
||||
real *window = decwin + 16 - bo1;
|
||||
|
||||
for (j=8;j;j--,b0+=0x10,window+=0x30)
|
||||
{
|
||||
real sum;
|
||||
sum = *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
real sum;
|
||||
sum = window[0x0] * b0[0x0];
|
||||
sum += window[0x2] * b0[0x2];
|
||||
sum += window[0x4] * b0[0x4];
|
||||
sum += window[0x6] * b0[0x6];
|
||||
sum += window[0x8] * b0[0x8];
|
||||
sum += window[0xA] * b0[0xA];
|
||||
sum += window[0xC] * b0[0xC];
|
||||
sum += window[0xE] * b0[0xE];
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
b0-=0x20,window-=0x40;
|
||||
}
|
||||
window += bo1<<1;
|
||||
|
||||
for (j=7;j;j--,b0-=0x30,window-=0x30)
|
||||
{
|
||||
real sum;
|
||||
sum = -*(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
*pnt += 64;
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,238 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-1,2,3 audio decoder
|
||||
* ------------------------------
|
||||
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
|
||||
* See also 'README'
|
||||
* version for slower machines .. decodes only every fourth sample
|
||||
* dunno why it sounds THIS annoying (maybe we should adapt the window?)
|
||||
* absolutely not optimized for this operation
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#define WRITE_SAMPLE(samples,sum,clip) \
|
||||
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
|
||||
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
|
||||
else { *(samples) = sum; }
|
||||
|
||||
int synth_4to1_8bit(real *bandPtr,int channel,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[16];
|
||||
short *tmp1 = samples_tmp + channel;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_4to1(bandPtr,channel,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += channel + *pnt;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
*samples = conv16to8[*tmp1>>AUSHIFT];
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 16;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_4to1_8bit_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[16];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_4to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 8;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_4to1_8bit_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[16];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_4to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 16;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_4to1_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[16];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_4to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
*( (short *)samples) = *tmp1;
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += 16;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_4to1_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
int i,ret;
|
||||
|
||||
ret = synth_4to1(bandPtr,0,samples,pnt);
|
||||
samples = samples + *pnt - 32;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
((short *)samples)[1] = ((short *)samples)[0];
|
||||
samples+=4;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_4to1(real *bandPtr,int channel,unsigned char *out,int *pnt)
|
||||
{
|
||||
static real buffs[2][2][0x110];
|
||||
static const int step = 2;
|
||||
static int bo = 1;
|
||||
short *samples = (short *) (out + *pnt);
|
||||
|
||||
real *b0,(*buf)[0x110];
|
||||
int clip = 0;
|
||||
int bo1;
|
||||
|
||||
if(param.enable_equalizer)
|
||||
do_equalizer(bandPtr,channel);
|
||||
|
||||
if(!channel) {
|
||||
bo--;
|
||||
bo &= 0xf;
|
||||
buf = buffs[0];
|
||||
}
|
||||
else {
|
||||
samples++;
|
||||
buf = buffs[1];
|
||||
}
|
||||
|
||||
if(bo & 0x1) {
|
||||
b0 = buf[0];
|
||||
bo1 = bo;
|
||||
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
|
||||
}
|
||||
else {
|
||||
b0 = buf[1];
|
||||
bo1 = bo+1;
|
||||
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
|
||||
}
|
||||
|
||||
{
|
||||
register int j;
|
||||
real *window = decwin + 16 - bo1;
|
||||
|
||||
for (j=4;j;j--,b0+=0x30,window+=0x70)
|
||||
{
|
||||
real sum;
|
||||
sum = *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
real sum;
|
||||
sum = window[0x0] * b0[0x0];
|
||||
sum += window[0x2] * b0[0x2];
|
||||
sum += window[0x4] * b0[0x4];
|
||||
sum += window[0x6] * b0[0x6];
|
||||
sum += window[0x8] * b0[0x8];
|
||||
sum += window[0xA] * b0[0xA];
|
||||
sum += window[0xC] * b0[0xC];
|
||||
sum += window[0xE] * b0[0xE];
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
b0-=0x40,window-=0x80;
|
||||
}
|
||||
window += bo1<<1;
|
||||
|
||||
for (j=3;j;j--,b0-=0x50,window-=0x70)
|
||||
{
|
||||
real sum;
|
||||
sum = -*(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#if 0
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
WRITE_SAMPLE(samples,sum,clip); samples += step;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
*pnt += 32;
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,288 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-1,2,3 audio decoder
|
||||
* ------------------------------
|
||||
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
|
||||
* See also 'README'
|
||||
*
|
||||
* N->M down/up sampling. Not optimized for speed.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#define WRITE_SAMPLE(samples,sum,clip) \
|
||||
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
|
||||
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
|
||||
else { *(samples) = sum; }
|
||||
|
||||
#define NTOM_MUL (32768)
|
||||
static unsigned long ntom_val[2] = { NTOM_MUL>>1,NTOM_MUL>>1 };
|
||||
static unsigned long ntom_step = NTOM_MUL;
|
||||
|
||||
|
||||
void synth_ntom_set_step(long m,long n)
|
||||
{
|
||||
if(param.verbose > 1)
|
||||
fprintf(stderr,"Init rate converter: %ld->%ld\n",m,n);
|
||||
|
||||
if(n >= 96000 || m >= 96000 || m == 0 || n == 0) {
|
||||
fprintf(stderr,"NtoM converter: illegal rates\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
n *= NTOM_MUL;
|
||||
ntom_step = n / m;
|
||||
|
||||
if(ntom_step > 8*NTOM_MUL) {
|
||||
fprintf(stderr,"max. 1:8 conversion allowed!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
ntom_val[0] = ntom_val[1] = NTOM_MUL>>1;
|
||||
}
|
||||
|
||||
int synth_ntom_8bit(real *bandPtr,int channel,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[8*64];
|
||||
short *tmp1 = samples_tmp + channel;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_ntom(bandPtr,channel,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += channel + *pnt;
|
||||
|
||||
for(i=0;i<(pnt1>>2);i++) {
|
||||
*samples = conv16to8[*tmp1>>AUSHIFT];
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += pnt1>>1;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_ntom_8bit_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[8*64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_ntom(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<(pnt1>>2);i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += pnt1 >> 2;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_ntom_8bit_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[8*64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_ntom(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<(pnt1>>2);i++) {
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
*samples++ = conv16to8[*tmp1>>AUSHIFT];
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += pnt1 >> 1;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int synth_ntom_mono(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
short samples_tmp[8*64];
|
||||
short *tmp1 = samples_tmp;
|
||||
int i,ret;
|
||||
int pnt1 = 0;
|
||||
|
||||
ret = synth_ntom(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
|
||||
samples += *pnt;
|
||||
|
||||
for(i=0;i<(pnt1>>2);i++) {
|
||||
*( (short *)samples) = *tmp1;
|
||||
samples += 2;
|
||||
tmp1 += 2;
|
||||
}
|
||||
*pnt += pnt1 >> 1;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_ntom_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
|
||||
{
|
||||
int i,ret;
|
||||
int pnt1 = *pnt;
|
||||
|
||||
ret = synth_ntom(bandPtr,0,samples,pnt);
|
||||
samples += pnt1;
|
||||
|
||||
for(i=0;i<((*pnt-pnt1)>>2);i++) {
|
||||
((short *)samples)[1] = ((short *)samples)[0];
|
||||
samples+=4;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int synth_ntom(real *bandPtr,int channel,unsigned char *out,int *pnt)
|
||||
{
|
||||
static real buffs[2][2][0x110];
|
||||
static const int step = 2;
|
||||
static int bo = 1;
|
||||
short *samples = (short *) (out + *pnt);
|
||||
|
||||
real *b0,(*buf)[0x110];
|
||||
int clip = 0;
|
||||
int bo1;
|
||||
int ntom;
|
||||
|
||||
if(param.enable_equalizer)
|
||||
do_equalizer(bandPtr,channel);
|
||||
|
||||
if(!channel) {
|
||||
bo--;
|
||||
bo &= 0xf;
|
||||
buf = buffs[0];
|
||||
ntom = ntom_val[1] = ntom_val[0];
|
||||
}
|
||||
else {
|
||||
samples++;
|
||||
out += 2; /* to compute the right *pnt value */
|
||||
buf = buffs[1];
|
||||
ntom = ntom_val[1];
|
||||
}
|
||||
|
||||
if(bo & 0x1) {
|
||||
b0 = buf[0];
|
||||
bo1 = bo;
|
||||
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
|
||||
}
|
||||
else {
|
||||
b0 = buf[1];
|
||||
bo1 = bo+1;
|
||||
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
register int j;
|
||||
real *window = decwin + 16 - bo1;
|
||||
|
||||
for (j=16;j;j--,window+=0x10)
|
||||
{
|
||||
real sum;
|
||||
|
||||
ntom += ntom_step;
|
||||
if(ntom < NTOM_MUL) {
|
||||
window += 16;
|
||||
b0 += 16;
|
||||
continue;
|
||||
}
|
||||
|
||||
sum = *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
sum += *window++ * *b0++;
|
||||
sum -= *window++ * *b0++;
|
||||
|
||||
while(ntom >= NTOM_MUL) {
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
samples += step;
|
||||
ntom -= NTOM_MUL;
|
||||
}
|
||||
}
|
||||
|
||||
ntom += ntom_step;
|
||||
if(ntom >= NTOM_MUL)
|
||||
{
|
||||
real sum;
|
||||
sum = window[0x0] * b0[0x0];
|
||||
sum += window[0x2] * b0[0x2];
|
||||
sum += window[0x4] * b0[0x4];
|
||||
sum += window[0x6] * b0[0x6];
|
||||
sum += window[0x8] * b0[0x8];
|
||||
sum += window[0xA] * b0[0xA];
|
||||
sum += window[0xC] * b0[0xC];
|
||||
sum += window[0xE] * b0[0xE];
|
||||
|
||||
while(ntom >= NTOM_MUL) {
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
samples += step;
|
||||
ntom -= NTOM_MUL;
|
||||
}
|
||||
}
|
||||
|
||||
b0-=0x10,window-=0x20;
|
||||
window += bo1<<1;
|
||||
|
||||
for (j=15;j;j--,b0-=0x20,window-=0x10)
|
||||
{
|
||||
real sum;
|
||||
|
||||
ntom += ntom_step;
|
||||
if(ntom < NTOM_MUL) {
|
||||
window -= 16;
|
||||
b0 += 16;
|
||||
continue;
|
||||
}
|
||||
|
||||
sum = -*(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
sum -= *(--window) * *b0++;
|
||||
|
||||
while(ntom >= NTOM_MUL) {
|
||||
WRITE_SAMPLE(samples,sum,clip);
|
||||
samples += step;
|
||||
ntom -= NTOM_MUL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ntom_val[channel] = ntom;
|
||||
*pnt = ((unsigned char *) samples - out);
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
|
||||
#include "mpg123.h"
|
||||
|
||||
real equalizer[2][32];
|
||||
real equalizer_sum[2][32];
|
||||
int equalizer_cnt;
|
||||
|
||||
real equalizerband[2][SBLIMIT*SSLIMIT];
|
||||
|
||||
void do_equalizer(real *bandPtr,int channel)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(param.enable_equalizer) {
|
||||
for(i=0;i<32;i++)
|
||||
bandPtr[i] *= equalizer[channel][i];
|
||||
}
|
||||
|
||||
/* if(param.equalizer & 0x2) {
|
||||
|
||||
for(i=0;i<32;i++)
|
||||
equalizer_sum[channel][i] += bandPtr[i];
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
void do_equalizerband(real *bandPtr,int channel)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<576;i++) {
|
||||
bandPtr[i] *= equalizerband[channel][i];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,263 +0,0 @@
|
|||
char *genre_table[] =
|
||||
{
|
||||
"Blues",
|
||||
"Classic Rock",
|
||||
"Country",
|
||||
"Dance",
|
||||
"Disco",
|
||||
"Funk",
|
||||
"Grunge",
|
||||
"Hip-Hop",
|
||||
"Jazz",
|
||||
"Metal",
|
||||
"New Age",
|
||||
"Oldies",
|
||||
"Other",
|
||||
"Pop",
|
||||
"R&B",
|
||||
"Rap",
|
||||
"Reggae",
|
||||
"Rock",
|
||||
"Techno",
|
||||
"Industrial",
|
||||
"Alternative",
|
||||
"Ska",
|
||||
"Death Metal",
|
||||
"Pranks",
|
||||
"Soundtrack",
|
||||
"Euro-Techno",
|
||||
"Ambient",
|
||||
"Trip-Hop",
|
||||
"Vocal",
|
||||
"Jazz+Funk",
|
||||
"Fusion",
|
||||
"Trance",
|
||||
"Classical",
|
||||
"Instrumental",
|
||||
"Acid",
|
||||
"House",
|
||||
"Game",
|
||||
"Sound Clip",
|
||||
"Gospel",
|
||||
"Noise",
|
||||
"AlternRock",
|
||||
"Bass",
|
||||
"Soul",
|
||||
"Punk",
|
||||
"Space",
|
||||
"Meditative",
|
||||
"Instrumental Pop",
|
||||
"Instrumental Rock",
|
||||
"Ethnic",
|
||||
"Gothic",
|
||||
"Darkwave",
|
||||
"Techno-Industrial",
|
||||
"Electronic",
|
||||
"Pop-Folk",
|
||||
"Eurodance",
|
||||
"Dream",
|
||||
"Southern Rock",
|
||||
"Comedy",
|
||||
"Cult",
|
||||
"Gangsta",
|
||||
"Top 40",
|
||||
"Christian Rap",
|
||||
"Pop/Funk",
|
||||
"Jungle",
|
||||
"Native American",
|
||||
"Cabaret",
|
||||
"New Wave",
|
||||
"Psychadelic",
|
||||
"Rave",
|
||||
"Showtunes",
|
||||
"Trailer",
|
||||
"Lo-Fi",
|
||||
"Tribal",
|
||||
"Acid Punk",
|
||||
"Acid Jazz",
|
||||
"Polka",
|
||||
"Retro",
|
||||
"Musical",
|
||||
"Rock & Roll",
|
||||
"Hard Rock",
|
||||
"Folk",
|
||||
"Folk/Rock",
|
||||
"National folk",
|
||||
"Swing",
|
||||
"Fast-fusion",
|
||||
"Bebob",
|
||||
"Latin",
|
||||
"Revival",
|
||||
"Celtic",
|
||||
"Bluegrass",
|
||||
"Avantgarde",
|
||||
"Gothic Rock",
|
||||
"Progressive Rock",
|
||||
"Psychedelic Rock",
|
||||
"Symphonic Rock",
|
||||
"Slow Rock",
|
||||
"Big Band",
|
||||
"Chorus",
|
||||
"Easy Listening",
|
||||
"Acoustic",
|
||||
"Humour",
|
||||
"Speech",
|
||||
"Chanson",
|
||||
"Opera",
|
||||
"Chamber Music",
|
||||
"Sonata",
|
||||
"Symphony",
|
||||
"Booty Bass",
|
||||
"Primus",
|
||||
"Porn Groove",
|
||||
"Satire",
|
||||
"Slow Jam",
|
||||
"Club",
|
||||
"Tango",
|
||||
"Samba",
|
||||
"Folklore",
|
||||
"Ballad",
|
||||
"Powder Ballad",
|
||||
"Rhythmic Soul",
|
||||
"Freestyle",
|
||||
"Duet",
|
||||
"Punk Rock",
|
||||
"Drum Solo",
|
||||
"A Capella",
|
||||
"Euro-House",
|
||||
"Dance Hall",
|
||||
"Goa",
|
||||
"Drum & Bass",
|
||||
"Club House",
|
||||
"Hardcore",
|
||||
"Terror",
|
||||
"Indie",
|
||||
"BritPop",
|
||||
"NegerPunk",
|
||||
"Polsk Punk",
|
||||
"Beat",
|
||||
"Christian Gangsta",
|
||||
"Heavy Metal",
|
||||
"Black Metal",
|
||||
"Crossover",
|
||||
"Contemporary C",
|
||||
"Christian Rock",
|
||||
"Merengue",
|
||||
"Salsa",
|
||||
"Thrash Metal",
|
||||
"Anime",
|
||||
"JPop",
|
||||
"SynthPop"
|
||||
/* ,
|
||||
"Unknown",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
""
|
||||
*/
|
||||
};
|
||||
|
||||
const int genre_count = ((int)(sizeof(genre_table)/sizeof(char*))-1);
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
#include "mpg123.h"
|
||||
#include "common.h"
|
||||
|
||||
#if 0
|
||||
static void check_buffer_range(int size)
|
||||
{
|
||||
int pos = (bsi->wordpointer-bsbuf) + (size>>3);
|
||||
|
||||
if( pos >= fsizeold) {
|
||||
fprintf(stderr,"Pointer out of range (%d,%d)!\n",pos,fsizeold);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void backbits(struct bitstream_info *bsi,int number_of_bits)
|
||||
{
|
||||
bsi->bitindex -= number_of_bits;
|
||||
bsi->wordpointer += (bsi->bitindex>>3);
|
||||
bsi->bitindex &= 0x7;
|
||||
}
|
||||
|
||||
int getbitoffset(struct bitstream_info *bsi)
|
||||
{
|
||||
return (-bsi->bitindex)&0x7;
|
||||
}
|
||||
|
||||
int getbyte(struct bitstream_info *bsi)
|
||||
{
|
||||
#ifdef DEBUG_GETBITS
|
||||
if(bsi->bitindex)
|
||||
fprintf(stderr,"getbyte called unsynched!\n");
|
||||
#endif
|
||||
return *bsi->wordpointer++;
|
||||
}
|
||||
|
||||
unsigned int getbits(struct bitstream_info *bsi,int number_of_bits)
|
||||
{
|
||||
unsigned long rval;
|
||||
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,"g%d",number_of_bits);
|
||||
#endif
|
||||
|
||||
if(!number_of_bits)
|
||||
return 0;
|
||||
|
||||
#if 0
|
||||
check_buffer_range(number_of_bits+bsi->bitindex);
|
||||
#endif
|
||||
|
||||
{
|
||||
rval = bsi->wordpointer[0];
|
||||
rval <<= 8;
|
||||
rval |= bsi->wordpointer[1];
|
||||
rval <<= 8;
|
||||
rval |= bsi->wordpointer[2];
|
||||
|
||||
rval <<= bsi->bitindex;
|
||||
rval &= 0xffffff;
|
||||
|
||||
bsi->bitindex += number_of_bits;
|
||||
|
||||
rval >>= (24-number_of_bits);
|
||||
|
||||
bsi->wordpointer += (bsi->bitindex>>3);
|
||||
bsi->bitindex &= 7;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,":%x ",rval);
|
||||
#endif
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
unsigned int getbits_fast(struct bitstream_info *bsi,int number_of_bits)
|
||||
{
|
||||
unsigned int rval;
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,"g%d",number_of_bits);
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
check_buffer_range(number_of_bits+bsi->bitindex);
|
||||
#endif
|
||||
|
||||
rval = (unsigned char) (bsi->wordpointer[0] << bsi->bitindex);
|
||||
rval |= ((unsigned int) bsi->wordpointer[1]<<bsi->bitindex)>>8;
|
||||
rval <<= number_of_bits;
|
||||
rval >>= 8;
|
||||
|
||||
bsi->bitindex += number_of_bits;
|
||||
|
||||
bsi->wordpointer += (bsi->bitindex>>3);
|
||||
bsi->bitindex &= 7;
|
||||
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,":%x ",rval);
|
||||
#endif
|
||||
return rval;
|
||||
}
|
||||
|
||||
unsigned int get1bit(struct bitstream_info *bsi)
|
||||
{
|
||||
unsigned char rval;
|
||||
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,"g%d",1);
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
check_buffer_range(1+bsi->bitindex);
|
||||
#endif
|
||||
|
||||
rval = *(bsi->wordpointer) << bsi->bitindex;
|
||||
|
||||
bsi->bitindex++;
|
||||
bsi->wordpointer += (bsi->bitindex>>3);
|
||||
bsi->bitindex &= 7;
|
||||
|
||||
#ifdef DEBUG_GETBITS
|
||||
fprintf(stderr,":%d ",rval>>7);
|
||||
#endif
|
||||
|
||||
return rval>>7;
|
||||
}
|
||||
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
|
||||
/* that's the same file as getits.c but with defines to
|
||||
force inlining */
|
||||
|
||||
static unsigned long rval;
|
||||
static unsigned char rval_uc;
|
||||
|
||||
#define backbits(nob) ((void)( \
|
||||
bsi.bitindex -= (nob), \
|
||||
bsi.wordpointer += (bsi.bitindex>>3), \
|
||||
bsi.bitindex &= 0x7 ))
|
||||
|
||||
#define getbitoffset() ((-bsi.bitindex)&0x7)
|
||||
#define getbyte() (*bsi.wordpointer++)
|
||||
|
||||
#define getbits(nob) ( \
|
||||
rval = bsi.wordpointer[0], rval <<= 8, rval |= bsi.wordpointer[1], \
|
||||
rval <<= 8, rval |= bsi.wordpointer[2], rval <<= bsi.bitindex, \
|
||||
rval &= 0xffffff, bsi.bitindex += (nob), \
|
||||
rval >>= (24-(nob)), bsi.wordpointer += (bsi.bitindex>>3), \
|
||||
bsi.bitindex &= 7,rval)
|
||||
|
||||
#define getbits_fast(nob) ( \
|
||||
rval = (unsigned char) (bsi.wordpointer[0] << bsi.bitindex), \
|
||||
rval |= ((unsigned long) bsi.wordpointer[1]<<bsi.bitindex)>>8, \
|
||||
rval <<= (nob), rval >>= 8, \
|
||||
bsi.bitindex += (nob), bsi.wordpointer += (bsi.bitindex>>3), \
|
||||
bsi.bitindex &= 7, rval )
|
||||
|
||||
#define get1bit() ( \
|
||||
rval_uc = *bsi.wordpointer << bsi.bitindex, bsi.bitindex++, \
|
||||
bsi.wordpointer += (bsi.bitindex>>3), bsi.bitindex &= 7, rval_uc>>7 )
|
||||
|
||||
|
|
@ -1,440 +0,0 @@
|
|||
/*
|
||||
* httpget.c
|
||||
*
|
||||
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de>
|
||||
* Wed Apr 9 20:57:47 MET DST 1997
|
||||
*/
|
||||
|
||||
#undef ALSA
|
||||
|
||||
#if !defined(WIN32) && !defined(GENERIC)
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <netdb.h>
|
||||
#include <sys/param.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <sys/errno.h>
|
||||
#include <ctype.h>
|
||||
|
||||
extern int errno;
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#ifndef INADDR_NONE
|
||||
#define INADDR_NONE 0xffffffff
|
||||
#endif
|
||||
|
||||
void writestring (int fd, char *string)
|
||||
{
|
||||
int result, bytes = strlen(string);
|
||||
|
||||
while (bytes) {
|
||||
if ((result = write(fd, string, bytes)) < 0 && errno != EINTR) {
|
||||
perror ("write");
|
||||
exit (1);
|
||||
}
|
||||
else if (result == 0) {
|
||||
fprintf (stderr, "write: %s\n",
|
||||
"socket closed unexpectedly");
|
||||
exit (1);
|
||||
}
|
||||
string += result;
|
||||
bytes -= result;
|
||||
}
|
||||
}
|
||||
|
||||
void readstring (char *string, int maxlen, FILE *f)
|
||||
{
|
||||
#if 0
|
||||
char *result;
|
||||
#endif
|
||||
int pos = 0;
|
||||
|
||||
while(1) {
|
||||
if( read(fileno(f),string+pos,1) == 1) {
|
||||
pos++;
|
||||
if(string[pos-1] == '\n') {
|
||||
string[pos] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if(errno != EINTR) {
|
||||
fprintf (stderr, "Error reading from socket or unexpected EOF.\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
do {
|
||||
result = fgets(string, maxlen, f);
|
||||
} while (!result && errno == EINTR);
|
||||
if (!result) {
|
||||
fprintf (stderr, "Error reading from socket or unexpected EOF.\n");
|
||||
exit (1);
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void encode64 (char *source,char *destination)
|
||||
{
|
||||
static char *Base64Digits =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
int n = 0;
|
||||
int ssiz=strlen(source);
|
||||
int i;
|
||||
|
||||
for (i = 0 ; i < ssiz ; i += 3) {
|
||||
unsigned int buf;
|
||||
buf = ((unsigned char *)source)[i] << 16;
|
||||
if (i+1 < ssiz)
|
||||
buf |= ((unsigned char *)source)[i+1] << 8;
|
||||
if (i+2 < ssiz)
|
||||
buf |= ((unsigned char *)source)[i+2];
|
||||
|
||||
destination[n++] = Base64Digits[(buf >> 18) % 64];
|
||||
destination[n++] = Base64Digits[(buf >> 12) % 64];
|
||||
if (i+1 < ssiz)
|
||||
destination[n++] = Base64Digits[(buf >> 6) % 64];
|
||||
else
|
||||
destination[n++] = '=';
|
||||
if (i+2 < ssiz)
|
||||
destination[n++] = Base64Digits[buf % 64];
|
||||
else
|
||||
destination[n++] = '=';
|
||||
}
|
||||
destination[n++] = 0;
|
||||
}
|
||||
|
||||
/* VERY simple auth-from-URL grabber */
|
||||
int getauthfromURL(char *url,char *auth)
|
||||
{
|
||||
char *pos;
|
||||
|
||||
*auth = 0;
|
||||
|
||||
if (!(strncmp(url, "http://", 7)))
|
||||
url += 7;
|
||||
|
||||
if( (pos = strchr(url,'@')) ) {
|
||||
int i;
|
||||
for(i=0;i<pos-url;i++) {
|
||||
if( url[i] == '/' )
|
||||
return 0;
|
||||
}
|
||||
strncpy(auth,url,pos-url);
|
||||
auth[pos-url] = 0;
|
||||
strcpy(url,pos+1);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char *defaultportstr = "80";
|
||||
|
||||
char *url2hostport (char *url, char **hname, unsigned long *hip, unsigned char **port)
|
||||
{
|
||||
char *h, *p;
|
||||
char *hostptr;
|
||||
char *r_hostptr;
|
||||
char *pathptr;
|
||||
char *portptr;
|
||||
char *p0;
|
||||
size_t stringlength;
|
||||
|
||||
p = url;
|
||||
if (strncmp(p, "http://", 7) == 0)
|
||||
p += 7;
|
||||
hostptr = p;
|
||||
while (*p && *p != '/')
|
||||
p++;
|
||||
pathptr = p;
|
||||
|
||||
r_hostptr = --p;
|
||||
while (*p && hostptr < p && *p != ':' && *p != ']')
|
||||
p--;
|
||||
|
||||
if (!*p || p < hostptr || *p != ':') {
|
||||
portptr = NULL;
|
||||
}
|
||||
else{
|
||||
portptr = p + 1;
|
||||
r_hostptr = p - 1;
|
||||
}
|
||||
if (*hostptr == '[' && *r_hostptr == ']') {
|
||||
hostptr++;
|
||||
r_hostptr--;
|
||||
}
|
||||
|
||||
stringlength = r_hostptr - hostptr + 1;
|
||||
h = malloc(stringlength + 1); /* removed the strndup for better portability */
|
||||
if (h == NULL) {
|
||||
*hname = NULL;
|
||||
*port = NULL;
|
||||
return NULL;
|
||||
}
|
||||
strncpy(h, hostptr, stringlength);
|
||||
*(h+stringlength) = '\0';
|
||||
*hname = h;
|
||||
|
||||
if (portptr) {
|
||||
stringlength = (pathptr - portptr);
|
||||
if(!stringlength) portptr = NULL;
|
||||
}
|
||||
if (portptr == NULL) {
|
||||
portptr = defaultportstr;
|
||||
stringlength = strlen(defaultportstr);
|
||||
}
|
||||
p0 = malloc(stringlength + 1);
|
||||
if (p0 == NULL) {
|
||||
free(h);
|
||||
*hname = NULL;
|
||||
*port = NULL;
|
||||
return NULL;
|
||||
}
|
||||
strncpy(p0, portptr, stringlength);
|
||||
*(p0 + stringlength) = '\0';
|
||||
|
||||
for (p = p0; *p && isdigit((unsigned char) *p); p++) ;
|
||||
|
||||
*p = '\0';
|
||||
*port = (unsigned char *) p0;
|
||||
|
||||
return pathptr;
|
||||
}
|
||||
|
||||
char *proxyurl = NULL;
|
||||
unsigned long proxyip = 0;
|
||||
unsigned char *proxyport;
|
||||
|
||||
#define ACCEPT_HEAD "Accept: audio/mpeg, audio/x-mpegurl, */*\r\n"
|
||||
|
||||
char *httpauth = NULL;
|
||||
char httpauth1[256];
|
||||
|
||||
int http_open (char *url)
|
||||
{
|
||||
char *purl, *host, *request, *sptr;
|
||||
int linelength;
|
||||
unsigned long myip;
|
||||
unsigned char *myport;
|
||||
int sock;
|
||||
int relocate, numrelocs = 0;
|
||||
FILE *myfile;
|
||||
#ifdef INET6
|
||||
struct addrinfo hints, *res, *res0;
|
||||
int error;
|
||||
#else
|
||||
struct hostent *hp;
|
||||
struct sockaddr_in sin;
|
||||
#endif
|
||||
|
||||
host = NULL;
|
||||
proxyport = NULL;
|
||||
myport = NULL;
|
||||
if (!proxyip) {
|
||||
if (!proxyurl)
|
||||
if (!(proxyurl = getenv("MP3_HTTP_PROXY")))
|
||||
if (!(proxyurl = getenv("http_proxy")))
|
||||
proxyurl = getenv("HTTP_PROXY");
|
||||
if (proxyurl && proxyurl[0] && strcmp(proxyurl, "none")) {
|
||||
if (!(url2hostport(proxyurl, &host, &proxyip, &proxyport))) {
|
||||
fprintf (stderr, "Unknown proxy host \"%s\".\n",
|
||||
host ? host : "");
|
||||
exit (1);
|
||||
}
|
||||
#if 0
|
||||
if (host)
|
||||
free (host);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
proxyip = INADDR_NONE;
|
||||
}
|
||||
|
||||
if ((linelength = strlen(url)+200) < 1024)
|
||||
linelength = 1024;
|
||||
if (!(request = malloc(linelength)) || !(purl = malloc(1024))) {
|
||||
fprintf (stderr, "malloc() failed, out of memory.\n");
|
||||
exit (1);
|
||||
}
|
||||
strncpy (purl, url, 1023);
|
||||
purl[1023] = '\0';
|
||||
|
||||
getauthfromURL(purl,httpauth1);
|
||||
|
||||
do {
|
||||
strcpy (request, "GET ");
|
||||
if (proxyip != INADDR_NONE) {
|
||||
if (strncmp(url, "http://", 7))
|
||||
strcat (request, "http://");
|
||||
strcat (request, purl);
|
||||
myport = proxyport;
|
||||
myip = proxyip;
|
||||
}
|
||||
else {
|
||||
if (host) {
|
||||
free(host);
|
||||
host=NULL;
|
||||
}
|
||||
if (proxyport) {
|
||||
free(proxyport);
|
||||
proxyport=NULL;
|
||||
}
|
||||
if (!(sptr = url2hostport(purl, &host, &myip, &myport))) {
|
||||
fprintf (stderr, "Unknown host \"%s\".\n",
|
||||
host ? host : "");
|
||||
exit (1);
|
||||
}
|
||||
strcat (request, sptr);
|
||||
}
|
||||
sprintf (request + strlen(request),
|
||||
" HTTP/1.0\r\nUser-Agent: %s/%s\r\n",
|
||||
prgName, prgVersion);
|
||||
if (host) {
|
||||
sprintf(request + strlen(request),
|
||||
"Host: %s:%s\r\n", host, myport);
|
||||
#if 0
|
||||
free (host);
|
||||
#endif
|
||||
}
|
||||
strcat (request, ACCEPT_HEAD);
|
||||
|
||||
#ifdef INET6
|
||||
memset(&hints, 0, sizeof(hints));
|
||||
hints.ai_socktype = SOCK_STREAM;
|
||||
error = getaddrinfo(host, (char *)myport, &hints, &res0);
|
||||
if (error) {
|
||||
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(error));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
sock = -1;
|
||||
for (res = res0; res; res = res->ai_next) {
|
||||
if ((sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) < 0) {
|
||||
continue;
|
||||
}
|
||||
if (connect(sock, res->ai_addr, res->ai_addrlen)) {
|
||||
close(sock);
|
||||
sock = -1;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
freeaddrinfo(res0);
|
||||
#else
|
||||
sock = -1;
|
||||
hp = gethostbyname(host);
|
||||
if (!hp)
|
||||
goto fail;
|
||||
if (hp->h_length != sizeof(sin.sin_addr))
|
||||
goto fail;
|
||||
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (sock < 0)
|
||||
goto fail;
|
||||
memset(&sin, 0, sizeof(sin));
|
||||
sin.sin_family = AF_INET;
|
||||
/* sin.sin_len = sizeof(struct sockaddr_in); */
|
||||
memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);
|
||||
if (connect(sock, (struct sockaddr *)&sin, sizeof(struct sockaddr_in) ) < 0) {
|
||||
close(sock);
|
||||
sock = -1;
|
||||
}
|
||||
fail:
|
||||
#endif
|
||||
|
||||
if (sock < 0) {
|
||||
perror("socket");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (strlen(httpauth1) || httpauth) {
|
||||
char buf[1023];
|
||||
strcat (request,"Authorization: Basic ");
|
||||
if(strlen(httpauth1))
|
||||
encode64(httpauth1,buf);
|
||||
else
|
||||
encode64(httpauth,buf);
|
||||
strcat (request,buf);
|
||||
strcat (request,"\r\n");
|
||||
}
|
||||
strcat (request, "\r\n");
|
||||
|
||||
writestring (sock, request);
|
||||
if (!(myfile = fdopen(sock, "rb"))) {
|
||||
perror ("fdopen");
|
||||
exit (1);
|
||||
};
|
||||
relocate = FALSE;
|
||||
purl[0] = '\0';
|
||||
readstring (request, linelength-1, myfile);
|
||||
if ((sptr = strchr(request, ' '))) {
|
||||
switch (sptr[1]) {
|
||||
case '3':
|
||||
relocate = TRUE;
|
||||
case '2':
|
||||
break;
|
||||
default:
|
||||
fprintf (stderr, "HTTP request failed: %s",
|
||||
sptr+1); /* '\n' is included */
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
do {
|
||||
readstring (request, linelength-1, myfile);
|
||||
if (!strncmp(request, "Location:", 9))
|
||||
strncpy (purl, request+10, 1023);
|
||||
} while (request[0] != '\r' && request[0] != '\n');
|
||||
} while (relocate && purl[0] && numrelocs++ < 5);
|
||||
if (relocate) {
|
||||
fprintf (stderr, "Too many HTTP relocations.\n");
|
||||
exit (1);
|
||||
}
|
||||
free (purl);
|
||||
free (request);
|
||||
free(host);
|
||||
free(proxyport);
|
||||
free(myport);
|
||||
|
||||
return sock;
|
||||
}
|
||||
|
||||
#else
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
extern int errno;
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
void writestring (int fd, char *string)
|
||||
{
|
||||
}
|
||||
|
||||
void readstring (char *string, int maxlen, FILE *f)
|
||||
{
|
||||
}
|
||||
|
||||
char *url2hostport (char *url, char **hname, unsigned long *hip, unsigned int *port)
|
||||
{
|
||||
}
|
||||
|
||||
char *proxyurl = NULL;
|
||||
unsigned long proxyip = 0;
|
||||
unsigned int proxyport;
|
||||
|
||||
#define ACCEPT_HEAD "Accept: audio/mpeg, audio/x-mpegurl, */*\r\n"
|
||||
|
||||
int http_open (char *url)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
/* EOF */
|
||||
|
||||
|
|
@ -1,332 +0,0 @@
|
|||
/*
|
||||
* huffman tables ... recalcualted to work with my optimzed
|
||||
* decoder scheme (MH)
|
||||
*
|
||||
* probably we could save a few bytes of memory, because the
|
||||
* smaller tables are often the part of a bigger table
|
||||
*/
|
||||
|
||||
struct newhuff
|
||||
{
|
||||
unsigned int linbits;
|
||||
short *table;
|
||||
};
|
||||
|
||||
static short tab0[] =
|
||||
{
|
||||
0
|
||||
};
|
||||
|
||||
static short tab1[] =
|
||||
{
|
||||
-5, -3, -1, 17, 1, 16, 0
|
||||
};
|
||||
|
||||
static short tab2[] =
|
||||
{
|
||||
-15, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 17, -1, 1,
|
||||
16, 0
|
||||
};
|
||||
|
||||
static short tab3[] =
|
||||
{
|
||||
-13, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 16, 17, -1,
|
||||
1, 0
|
||||
};
|
||||
|
||||
static short tab5[] =
|
||||
{
|
||||
-29, -25, -23, -15, -7, -5, -3, -1, 51, 35, 50, 49, -3, -1, 19,
|
||||
3, -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, 17, -1, 1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab6[] =
|
||||
{
|
||||
-25, -19, -13, -9, -5, -3, -1, 51, 3, 35, -1, 50, 48, -1, 19,
|
||||
49, -3, -1, 34, 2, 18, -3, -1, 33, 32, 1, -1, 17, -1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab7[] =
|
||||
{
|
||||
-69, -65, -57, -39, -29, -17, -11, -7, -3, -1, 85, 69, -1, 84, 83,
|
||||
-1, 53, 68, -3, -1, 37, 82, 21, -5, -1, 81, -1, 5, 52, -1,
|
||||
80, -1, 67, 51, -5, -3, -1, 36, 66, 20, -1, 65, 64, -11, -7,
|
||||
-3, -1, 4, 35, -1, 50, 3, -1, 19, 49, -3, -1, 48, 34, 18,
|
||||
-5, -1, 33, -1, 2, 32, 17, -1, 1, 16, 0
|
||||
};
|
||||
|
||||
static short tab8[] =
|
||||
{
|
||||
-65, -63, -59, -45, -31, -19, -13, -7, -5, -3, -1, 85, 84, 69, 83,
|
||||
-3, -1, 53, 68, 37, -3, -1, 82, 5, 21, -5, -1, 81, -1, 52,
|
||||
67, -3, -1, 80, 51, 36, -5, -3, -1, 66, 20, 65, -3, -1, 4,
|
||||
64, -1, 35, 50, -9, -7, -3, -1, 19, 49, -1, 3, 48, 34, -1,
|
||||
2, 32, -1, 18, 33, 17, -3, -1, 1, 16, 0
|
||||
};
|
||||
|
||||
static short tab9[] =
|
||||
{
|
||||
-63, -53, -41, -29, -19, -11, -5, -3, -1, 85, 69, 53, -1, 83, -1,
|
||||
84, 5, -3, -1, 68, 37, -1, 82, 21, -3, -1, 81, 52, -1, 67,
|
||||
-1, 80, 4, -7, -3, -1, 36, 66, -1, 51, 64, -1, 20, 65, -5,
|
||||
-3, -1, 35, 50, 19, -1, 49, -1, 3, 48, -5, -3, -1, 34, 2,
|
||||
18, -1, 33, 32, -3, -1, 17, 1, -1, 16, 0
|
||||
};
|
||||
|
||||
static short tab10[] =
|
||||
{
|
||||
-125,-121,-111, -83, -55, -35, -21, -13, -7, -3, -1, 119, 103, -1, 118,
|
||||
87, -3, -1, 117, 102, 71, -3, -1, 116, 86, -1, 101, 55, -9, -3,
|
||||
-1, 115, 70, -3, -1, 85, 84, 99, -1, 39, 114, -11, -5, -3, -1,
|
||||
100, 7, 112, -1, 98, -1, 69, 53, -5, -1, 6, -1, 83, 68, 23,
|
||||
-17, -5, -1, 113, -1, 54, 38, -5, -3, -1, 37, 82, 21, -1, 81,
|
||||
-1, 52, 67, -3, -1, 22, 97, -1, 96, -1, 5, 80, -19, -11, -7,
|
||||
-3, -1, 36, 66, -1, 51, 4, -1, 20, 65, -3, -1, 64, 35, -1,
|
||||
50, 3, -3, -1, 19, 49, -1, 48, 34, -7, -3, -1, 18, 33, -1,
|
||||
2, 32, 17, -1, 1, 16, 0
|
||||
};
|
||||
|
||||
static short tab11[] =
|
||||
{
|
||||
-121,-113, -89, -59, -43, -27, -17, -7, -3, -1, 119, 103, -1, 118, 117,
|
||||
-3, -1, 102, 71, -1, 116, -1, 87, 85, -5, -3, -1, 86, 101, 55,
|
||||
-1, 115, 70, -9, -7, -3, -1, 69, 84, -1, 53, 83, 39, -1, 114,
|
||||
-1, 100, 7, -5, -1, 113, -1, 23, 112, -3, -1, 54, 99, -1, 96,
|
||||
-1, 68, 37, -13, -7, -5, -3, -1, 82, 5, 21, 98, -3, -1, 38,
|
||||
6, 22, -5, -1, 97, -1, 81, 52, -5, -1, 80, -1, 67, 51, -1,
|
||||
36, 66, -15, -11, -7, -3, -1, 20, 65, -1, 4, 64, -1, 35, 50,
|
||||
-1, 19, 49, -5, -3, -1, 3, 48, 34, 33, -5, -1, 18, -1, 2,
|
||||
32, 17, -3, -1, 1, 16, 0
|
||||
};
|
||||
|
||||
static short tab12[] =
|
||||
{
|
||||
-115, -99, -73, -45, -27, -17, -9, -5, -3, -1, 119, 103, 118, -1, 87,
|
||||
117, -3, -1, 102, 71, -1, 116, 101, -3, -1, 86, 55, -3, -1, 115,
|
||||
85, 39, -7, -3, -1, 114, 70, -1, 100, 23, -5, -1, 113, -1, 7,
|
||||
112, -1, 54, 99, -13, -9, -3, -1, 69, 84, -1, 68, -1, 6, 5,
|
||||
-1, 38, 98, -5, -1, 97, -1, 22, 96, -3, -1, 53, 83, -1, 37,
|
||||
82, -17, -7, -3, -1, 21, 81, -1, 52, 67, -5, -3, -1, 80, 4,
|
||||
36, -1, 66, 20, -3, -1, 51, 65, -1, 35, 50, -11, -7, -5, -3,
|
||||
-1, 64, 3, 48, 19, -1, 49, 34, -1, 18, 33, -7, -5, -3, -1,
|
||||
2, 32, 0, 17, -1, 1, 16
|
||||
};
|
||||
|
||||
static short tab13[] =
|
||||
{
|
||||
-509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13, -9,
|
||||
-7, -5, -3, -1, 254, 252, 253, 237, 255, -1, 239, 223, -3, -1, 238,
|
||||
207, -1, 222, 191, -9, -3, -1, 251, 206, -1, 220, -1, 175, 233, -1,
|
||||
236, 221, -9, -5, -3, -1, 250, 205, 190, -1, 235, 159, -3, -1, 249,
|
||||
234, -1, 189, 219, -17, -9, -3, -1, 143, 248, -1, 204, -1, 174, 158,
|
||||
-5, -1, 142, -1, 127, 126, 247, -5, -1, 218, -1, 173, 188, -3, -1,
|
||||
203, 246, 111, -15, -7, -3, -1, 232, 95, -1, 157, 217, -3, -1, 245,
|
||||
231, -1, 172, 187, -9, -3, -1, 79, 244, -3, -1, 202, 230, 243, -1,
|
||||
63, -1, 141, 216, -21, -9, -3, -1, 47, 242, -3, -1, 110, 156, 15,
|
||||
-5, -3, -1, 201, 94, 171, -3, -1, 125, 215, 78, -11, -5, -3, -1,
|
||||
200, 214, 62, -1, 185, -1, 155, 170, -1, 31, 241, -23, -13, -5, -1,
|
||||
240, -1, 186, 229, -3, -1, 228, 140, -1, 109, 227, -5, -1, 226, -1,
|
||||
46, 14, -1, 30, 225, -15, -7, -3, -1, 224, 93, -1, 213, 124, -3,
|
||||
-1, 199, 77, -1, 139, 184, -7, -3, -1, 212, 154, -1, 169, 108, -1,
|
||||
198, 61, -37, -21, -9, -5, -3, -1, 211, 123, 45, -1, 210, 29, -5,
|
||||
-1, 183, -1, 92, 197, -3, -1, 153, 122, 195, -7, -5, -3, -1, 167,
|
||||
151, 75, 209, -3, -1, 13, 208, -1, 138, 168, -11, -7, -3, -1, 76,
|
||||
196, -1, 107, 182, -1, 60, 44, -3, -1, 194, 91, -3, -1, 181, 137,
|
||||
28, -43, -23, -11, -5, -1, 193, -1, 152, 12, -1, 192, -1, 180, 106,
|
||||
-5, -3, -1, 166, 121, 59, -1, 179, -1, 136, 90, -11, -5, -1, 43,
|
||||
-1, 165, 105, -1, 164, -1, 120, 135, -5, -1, 148, -1, 119, 118, 178,
|
||||
-11, -3, -1, 27, 177, -3, -1, 11, 176, -1, 150, 74, -7, -3, -1,
|
||||
58, 163, -1, 89, 149, -1, 42, 162, -47, -23, -9, -3, -1, 26, 161,
|
||||
-3, -1, 10, 104, 160, -5, -3, -1, 134, 73, 147, -3, -1, 57, 88,
|
||||
-1, 133, 103, -9, -3, -1, 41, 146, -3, -1, 87, 117, 56, -5, -1,
|
||||
131, -1, 102, 71, -3, -1, 116, 86, -1, 101, 115, -11, -3, -1, 25,
|
||||
145, -3, -1, 9, 144, -1, 72, 132, -7, -5, -1, 114, -1, 70, 100,
|
||||
40, -1, 130, 24, -41, -27, -11, -5, -3, -1, 55, 39, 23, -1, 113,
|
||||
-1, 85, 7, -7, -3, -1, 112, 54, -1, 99, 69, -3, -1, 84, 38,
|
||||
-1, 98, 53, -5, -1, 129, -1, 8, 128, -3, -1, 22, 97, -1, 6,
|
||||
96, -13, -9, -5, -3, -1, 83, 68, 37, -1, 82, 5, -1, 21, 81,
|
||||
-7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, -19, -11,
|
||||
-5, -1, 65, -1, 4, 64, -3, -1, 35, 50, 19, -3, -1, 49, 3,
|
||||
-1, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab15[] =
|
||||
{
|
||||
-495,-445,-355,-263,-183,-115, -77, -43, -27, -13, -7, -3, -1, 255, 239,
|
||||
-1, 254, 223, -1, 238, -1, 253, 207, -7, -3, -1, 252, 222, -1, 237,
|
||||
191, -1, 251, -1, 206, 236, -7, -3, -1, 221, 175, -1, 250, 190, -3,
|
||||
-1, 235, 205, -1, 220, 159, -15, -7, -3, -1, 249, 234, -1, 189, 219,
|
||||
-3, -1, 143, 248, -1, 204, 158, -7, -3, -1, 233, 127, -1, 247, 173,
|
||||
-3, -1, 218, 188, -1, 111, -1, 174, 15, -19, -11, -3, -1, 203, 246,
|
||||
-3, -1, 142, 232, -1, 95, 157, -3, -1, 245, 126, -1, 231, 172, -9,
|
||||
-3, -1, 202, 187, -3, -1, 217, 141, 79, -3, -1, 244, 63, -1, 243,
|
||||
216, -33, -17, -9, -3, -1, 230, 47, -1, 242, -1, 110, 240, -3, -1,
|
||||
31, 241, -1, 156, 201, -7, -3, -1, 94, 171, -1, 186, 229, -3, -1,
|
||||
125, 215, -1, 78, 228, -15, -7, -3, -1, 140, 200, -1, 62, 109, -3,
|
||||
-1, 214, 227, -1, 155, 185, -7, -3, -1, 46, 170, -1, 226, 30, -5,
|
||||
-1, 225, -1, 14, 224, -1, 93, 213, -45, -25, -13, -7, -3, -1, 124,
|
||||
199, -1, 77, 139, -1, 212, -1, 184, 154, -7, -3, -1, 169, 108, -1,
|
||||
198, 61, -1, 211, 210, -9, -5, -3, -1, 45, 13, 29, -1, 123, 183,
|
||||
-5, -1, 209, -1, 92, 208, -1, 197, 138, -17, -7, -3, -1, 168, 76,
|
||||
-1, 196, 107, -5, -1, 182, -1, 153, 12, -1, 60, 195, -9, -3, -1,
|
||||
122, 167, -1, 166, -1, 192, 11, -1, 194, -1, 44, 91, -55, -29, -15,
|
||||
-7, -3, -1, 181, 28, -1, 137, 152, -3, -1, 193, 75, -1, 180, 106,
|
||||
-5, -3, -1, 59, 121, 179, -3, -1, 151, 136, -1, 43, 90, -11, -5,
|
||||
-1, 178, -1, 165, 27, -1, 177, -1, 176, 105, -7, -3, -1, 150, 74,
|
||||
-1, 164, 120, -3, -1, 135, 58, 163, -17, -7, -3, -1, 89, 149, -1,
|
||||
42, 162, -3, -1, 26, 161, -3, -1, 10, 160, 104, -7, -3, -1, 134,
|
||||
73, -1, 148, 57, -5, -1, 147, -1, 119, 9, -1, 88, 133, -53, -29,
|
||||
-13, -7, -3, -1, 41, 103, -1, 118, 146, -1, 145, -1, 25, 144, -7,
|
||||
-3, -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 71, -7,
|
||||
-3, -1, 40, 130, -1, 24, 129, -7, -3, -1, 116, 8, -1, 128, 86,
|
||||
-3, -1, 101, 55, -1, 115, 70, -17, -7, -3, -1, 39, 114, -1, 100,
|
||||
23, -3, -1, 85, 113, -3, -1, 7, 112, 54, -7, -3, -1, 99, 69,
|
||||
-1, 84, 38, -3, -1, 98, 22, -3, -1, 6, 96, 53, -33, -19, -9,
|
||||
-5, -1, 97, -1, 83, 68, -1, 37, 82, -3, -1, 21, 81, -3, -1,
|
||||
5, 80, 52, -7, -3, -1, 67, 36, -1, 66, 51, -1, 65, -1, 20,
|
||||
4, -9, -3, -1, 35, 50, -3, -1, 64, 3, 19, -3, -1, 49, 48,
|
||||
34, -9, -7, -3, -1, 18, 33, -1, 2, 32, 17, -3, -1, 1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab16[] =
|
||||
{
|
||||
-509,-503,-461,-323,-103, -37, -27, -15, -7, -3, -1, 239, 254, -1, 223,
|
||||
253, -3, -1, 207, 252, -1, 191, 251, -5, -1, 175, -1, 250, 159, -3,
|
||||
-1, 249, 248, 143, -7, -3, -1, 127, 247, -1, 111, 246, 255, -9, -5,
|
||||
-3, -1, 95, 245, 79, -1, 244, 243, -53, -1, 240, -1, 63, -29, -19,
|
||||
-13, -7, -5, -1, 206, -1, 236, 221, 222, -1, 233, -1, 234, 217, -1,
|
||||
238, -1, 237, 235, -3, -1, 190, 205, -3, -1, 220, 219, 174, -11, -5,
|
||||
-1, 204, -1, 173, 218, -3, -1, 126, 172, 202, -5, -3, -1, 201, 125,
|
||||
94, 189, 242, -93, -5, -3, -1, 47, 15, 31, -1, 241, -49, -25, -13,
|
||||
-5, -1, 158, -1, 188, 203, -3, -1, 142, 232, -1, 157, 231, -7, -3,
|
||||
-1, 187, 141, -1, 216, 110, -1, 230, 156, -13, -7, -3, -1, 171, 186,
|
||||
-1, 229, 215, -1, 78, -1, 228, 140, -3, -1, 200, 62, -1, 109, -1,
|
||||
214, 155, -19, -11, -5, -3, -1, 185, 170, 225, -1, 212, -1, 184, 169,
|
||||
-5, -1, 123, -1, 183, 208, 227, -7, -3, -1, 14, 224, -1, 93, 213,
|
||||
-3, -1, 124, 199, -1, 77, 139, -75, -45, -27, -13, -7, -3, -1, 154,
|
||||
108, -1, 198, 61, -3, -1, 92, 197, 13, -7, -3, -1, 138, 168, -1,
|
||||
153, 76, -3, -1, 182, 122, 60, -11, -5, -3, -1, 91, 137, 28, -1,
|
||||
192, -1, 152, 121, -1, 226, -1, 46, 30, -15, -7, -3, -1, 211, 45,
|
||||
-1, 210, 209, -5, -1, 59, -1, 151, 136, 29, -7, -3, -1, 196, 107,
|
||||
-1, 195, 167, -1, 44, -1, 194, 181, -23, -13, -7, -3, -1, 193, 12,
|
||||
-1, 75, 180, -3, -1, 106, 166, 179, -5, -3, -1, 90, 165, 43, -1,
|
||||
178, 27, -13, -5, -1, 177, -1, 11, 176, -3, -1, 105, 150, -1, 74,
|
||||
164, -5, -3, -1, 120, 135, 163, -3, -1, 58, 89, 42, -97, -57, -33,
|
||||
-19, -11, -5, -3, -1, 149, 104, 161, -3, -1, 134, 119, 148, -5, -3,
|
||||
-1, 73, 87, 103, 162, -5, -1, 26, -1, 10, 160, -3, -1, 57, 147,
|
||||
-1, 88, 133, -9, -3, -1, 41, 146, -3, -1, 118, 9, 25, -5, -1,
|
||||
145, -1, 144, 72, -3, -1, 132, 117, -1, 56, 131, -21, -11, -5, -3,
|
||||
-1, 102, 40, 130, -3, -1, 71, 116, 24, -3, -1, 129, 128, -3, -1,
|
||||
8, 86, 55, -9, -5, -1, 115, -1, 101, 70, -1, 39, 114, -5, -3,
|
||||
-1, 100, 85, 7, 23, -23, -13, -5, -1, 113, -1, 112, 54, -3, -1,
|
||||
99, 69, -1, 84, 38, -3, -1, 98, 22, -1, 97, -1, 6, 96, -9,
|
||||
-5, -1, 83, -1, 53, 68, -1, 37, 82, -1, 81, -1, 21, 5, -33,
|
||||
-23, -13, -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20,
|
||||
-5, -1, 65, -1, 4, 64, -1, 35, 50, -3, -1, 19, 49, -3, -1,
|
||||
3, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab24[] =
|
||||
{
|
||||
-451,-117, -43, -25, -15, -7, -3, -1, 239, 254, -1, 223, 253, -3, -1,
|
||||
207, 252, -1, 191, 251, -5, -1, 250, -1, 175, 159, -1, 249, 248, -9,
|
||||
-5, -3, -1, 143, 127, 247, -1, 111, 246, -3, -1, 95, 245, -1, 79,
|
||||
244, -71, -7, -3, -1, 63, 243, -1, 47, 242, -5, -1, 241, -1, 31,
|
||||
240, -25, -9, -1, 15, -3, -1, 238, 222, -1, 237, 206, -7, -3, -1,
|
||||
236, 221, -1, 190, 235, -3, -1, 205, 220, -1, 174, 234, -15, -7, -3,
|
||||
-1, 189, 219, -1, 204, 158, -3, -1, 233, 173, -1, 218, 188, -7, -3,
|
||||
-1, 203, 142, -1, 232, 157, -3, -1, 217, 126, -1, 231, 172, 255,-235,
|
||||
-143, -77, -45, -25, -15, -7, -3, -1, 202, 187, -1, 141, 216, -5, -3,
|
||||
-1, 14, 224, 13, 230, -5, -3, -1, 110, 156, 201, -1, 94, 186, -9,
|
||||
-5, -1, 229, -1, 171, 125, -1, 215, 228, -3, -1, 140, 200, -3, -1,
|
||||
78, 46, 62, -15, -7, -3, -1, 109, 214, -1, 227, 155, -3, -1, 185,
|
||||
170, -1, 226, 30, -7, -3, -1, 225, 93, -1, 213, 124, -3, -1, 199,
|
||||
77, -1, 139, 184, -31, -15, -7, -3, -1, 212, 154, -1, 169, 108, -3,
|
||||
-1, 198, 61, -1, 211, 45, -7, -3, -1, 210, 29, -1, 123, 183, -3,
|
||||
-1, 209, 92, -1, 197, 138, -17, -7, -3, -1, 168, 153, -1, 76, 196,
|
||||
-3, -1, 107, 182, -3, -1, 208, 12, 60, -7, -3, -1, 195, 122, -1,
|
||||
167, 44, -3, -1, 194, 91, -1, 181, 28, -57, -35, -19, -7, -3, -1,
|
||||
137, 152, -1, 193, 75, -5, -3, -1, 192, 11, 59, -3, -1, 176, 10,
|
||||
26, -5, -1, 180, -1, 106, 166, -3, -1, 121, 151, -3, -1, 160, 9,
|
||||
144, -9, -3, -1, 179, 136, -3, -1, 43, 90, 178, -7, -3, -1, 165,
|
||||
27, -1, 177, 105, -1, 150, 164, -17, -9, -5, -3, -1, 74, 120, 135,
|
||||
-1, 58, 163, -3, -1, 89, 149, -1, 42, 162, -7, -3, -1, 161, 104,
|
||||
-1, 134, 119, -3, -1, 73, 148, -1, 57, 147, -63, -31, -15, -7, -3,
|
||||
-1, 88, 133, -1, 41, 103, -3, -1, 118, 146, -1, 25, 145, -7, -3,
|
||||
-1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 40, -17, -7,
|
||||
-3, -1, 130, 24, -1, 71, 116, -5, -1, 129, -1, 8, 128, -1, 86,
|
||||
101, -7, -5, -1, 23, -1, 7, 112, 115, -3, -1, 55, 39, 114, -15,
|
||||
-7, -3, -1, 70, 100, -1, 85, 113, -3, -1, 54, 99, -1, 69, 84,
|
||||
-7, -3, -1, 38, 98, -1, 22, 97, -5, -3, -1, 6, 96, 53, -1,
|
||||
83, 68, -51, -37, -23, -15, -9, -3, -1, 37, 82, -1, 21, -1, 5,
|
||||
80, -1, 81, -1, 52, 67, -3, -1, 36, 66, -1, 51, 20, -9, -5,
|
||||
-1, 65, -1, 4, 64, -1, 35, 50, -1, 19, 49, -7, -5, -3, -1,
|
||||
3, 48, 34, 18, -1, 33, -1, 2, 32, -3, -1, 17, 1, -1, 16,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab_c0[] =
|
||||
{
|
||||
-29, -21, -13, -7, -3, -1, 11, 15, -1, 13, 14, -3, -1, 7, 5,
|
||||
9, -3, -1, 6, 3, -1, 10, 12, -3, -1, 2, 1, -1, 4, 8,
|
||||
0
|
||||
};
|
||||
|
||||
static short tab_c1[] =
|
||||
{
|
||||
-15, -7, -3, -1, 15, 14, -1, 13, 12, -3, -1, 11, 10, -1, 9,
|
||||
8, -7, -3, -1, 7, 6, -1, 5, 4, -3, -1, 3, 2, -1, 1,
|
||||
0
|
||||
};
|
||||
|
||||
|
||||
|
||||
static struct newhuff ht[] =
|
||||
{
|
||||
{ /* 0 */ 0 , tab0 } ,
|
||||
{ /* 2 */ 0 , tab1 } ,
|
||||
{ /* 3 */ 0 , tab2 } ,
|
||||
{ /* 3 */ 0 , tab3 } ,
|
||||
{ /* 0 */ 0 , tab0 } ,
|
||||
{ /* 4 */ 0 , tab5 } ,
|
||||
{ /* 4 */ 0 , tab6 } ,
|
||||
{ /* 6 */ 0 , tab7 } ,
|
||||
{ /* 6 */ 0 , tab8 } ,
|
||||
{ /* 6 */ 0 , tab9 } ,
|
||||
{ /* 8 */ 0 , tab10 } ,
|
||||
{ /* 8 */ 0 , tab11 } ,
|
||||
{ /* 8 */ 0 , tab12 } ,
|
||||
{ /* 16 */ 0 , tab13 } ,
|
||||
{ /* 0 */ 0 , tab0 } ,
|
||||
{ /* 16 */ 0 , tab15 } ,
|
||||
|
||||
{ /* 16 */ 1 , tab16 } ,
|
||||
{ /* 16 */ 2 , tab16 } ,
|
||||
{ /* 16 */ 3 , tab16 } ,
|
||||
{ /* 16 */ 4 , tab16 } ,
|
||||
{ /* 16 */ 6 , tab16 } ,
|
||||
{ /* 16 */ 8 , tab16 } ,
|
||||
{ /* 16 */ 10, tab16 } ,
|
||||
{ /* 16 */ 13, tab16 } ,
|
||||
{ /* 16 */ 4 , tab24 } ,
|
||||
{ /* 16 */ 5 , tab24 } ,
|
||||
{ /* 16 */ 6 , tab24 } ,
|
||||
{ /* 16 */ 7 , tab24 } ,
|
||||
{ /* 16 */ 8 , tab24 } ,
|
||||
{ /* 16 */ 9 , tab24 } ,
|
||||
{ /* 16 */ 11, tab24 } ,
|
||||
{ /* 16 */ 13, tab24 }
|
||||
};
|
||||
|
||||
static struct newhuff htc[] =
|
||||
{
|
||||
{ /* 1 , 1 , */ 0 , tab_c0 } ,
|
||||
{ /* 1 , 1 , */ 0 , tab_c1 }
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -1,154 +0,0 @@
|
|||
/*
|
||||
* Layer 2 Alloc tables ..
|
||||
* most other tables are calculated on program start (which is (of course)
|
||||
* not ISO-conform) ..
|
||||
* Layer-3 huffman table is in huffman.h
|
||||
*/
|
||||
|
||||
struct al_table alloc_0[] = {
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767} };
|
||||
|
||||
struct al_table alloc_1[] = {
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
|
||||
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767},
|
||||
{2,0},{5,3},{7,5},{16,-32767} };
|
||||
|
||||
struct al_table alloc_2[] = {
|
||||
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
|
||||
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
|
||||
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
|
||||
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} };
|
||||
|
||||
struct al_table alloc_3[] = {
|
||||
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
|
||||
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
|
||||
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
|
||||
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} };
|
||||
|
||||
struct al_table alloc_4[] = {
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
|
||||
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
|
||||
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9},
|
||||
{2,0},{5,3},{7,5},{10,9} };
|
||||
|
||||
|
|
@ -1,157 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-1 audio decoder
|
||||
* --------------------------
|
||||
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README'
|
||||
* near unoptimzed ...
|
||||
*
|
||||
* may have a few bugs after last optimization ...
|
||||
*
|
||||
*/
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#include "getbits.h"
|
||||
|
||||
void I_step_one(unsigned int balloc[], unsigned int scale_index[2][SBLIMIT],struct frame *fr)
|
||||
{
|
||||
unsigned int *ba=balloc;
|
||||
unsigned int *sca = (unsigned int *) scale_index;
|
||||
|
||||
if(fr->stereo) {
|
||||
int i;
|
||||
int jsbound = fr->jsbound;
|
||||
for (i=0;i<jsbound;i++) {
|
||||
*ba++ = getbits(4);
|
||||
*ba++ = getbits(4);
|
||||
}
|
||||
for (i=jsbound;i<SBLIMIT;i++)
|
||||
*ba++ = getbits(4);
|
||||
|
||||
ba = balloc;
|
||||
|
||||
for (i=0;i<jsbound;i++) {
|
||||
if ((*ba++))
|
||||
*sca++ = getbits(6);
|
||||
if ((*ba++))
|
||||
*sca++ = getbits(6);
|
||||
}
|
||||
for (i=jsbound;i<SBLIMIT;i++)
|
||||
if ((*ba++)) {
|
||||
*sca++ = getbits(6);
|
||||
*sca++ = getbits(6);
|
||||
}
|
||||
}
|
||||
else {
|
||||
int i;
|
||||
for (i=0;i<SBLIMIT;i++)
|
||||
*ba++ = getbits(4);
|
||||
ba = balloc;
|
||||
for (i=0;i<SBLIMIT;i++)
|
||||
if ((*ba++))
|
||||
*sca++ = getbits(6);
|
||||
}
|
||||
}
|
||||
|
||||
void I_step_two(real fraction[2][SBLIMIT],unsigned int balloc[2*SBLIMIT],
|
||||
unsigned int scale_index[2][SBLIMIT],struct frame *fr)
|
||||
{
|
||||
int i,n;
|
||||
int smpb[2*SBLIMIT]; /* values: 0-65535 */
|
||||
int *sample;
|
||||
register unsigned int *ba;
|
||||
register unsigned int *sca = (unsigned int *) scale_index;
|
||||
|
||||
if(fr->stereo) {
|
||||
int jsbound = fr->jsbound;
|
||||
register real *f0 = fraction[0];
|
||||
register real *f1 = fraction[1];
|
||||
ba = balloc;
|
||||
for (sample=smpb,i=0;i<jsbound;i++) {
|
||||
if ((n = *ba++))
|
||||
*sample++ = getbits(n+1);
|
||||
if ((n = *ba++))
|
||||
*sample++ = getbits(n+1);
|
||||
}
|
||||
for (i=jsbound;i<SBLIMIT;i++)
|
||||
if ((n = *ba++))
|
||||
*sample++ = getbits(n+1);
|
||||
|
||||
ba = balloc;
|
||||
for (sample=smpb,i=0;i<jsbound;i++) {
|
||||
if((n=*ba++))
|
||||
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
|
||||
else
|
||||
*f0++ = 0.0;
|
||||
if((n=*ba++))
|
||||
*f1++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
|
||||
else
|
||||
*f1++ = 0.0;
|
||||
}
|
||||
for (i=jsbound;i<SBLIMIT;i++) {
|
||||
if ((n=*ba++)) {
|
||||
real samp = ( ((-1)<<n) + (*sample++) + 1);
|
||||
*f0++ = samp * muls[n+1][*sca++];
|
||||
*f1++ = samp * muls[n+1][*sca++];
|
||||
}
|
||||
else
|
||||
*f0++ = *f1++ = 0.0;
|
||||
}
|
||||
for(i=fr->down_sample_sblimit;i<32;i++)
|
||||
fraction[0][i] = fraction[1][i] = 0.0;
|
||||
}
|
||||
else {
|
||||
register real *f0 = fraction[0];
|
||||
ba = balloc;
|
||||
for (sample=smpb,i=0;i<SBLIMIT;i++)
|
||||
if ((n = *ba++))
|
||||
*sample++ = getbits(n+1);
|
||||
ba = balloc;
|
||||
for (sample=smpb,i=0;i<SBLIMIT;i++) {
|
||||
if((n=*ba++))
|
||||
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
|
||||
else
|
||||
*f0++ = 0.0;
|
||||
}
|
||||
for(i=fr->down_sample_sblimit;i<32;i++)
|
||||
fraction[0][i] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
int do_layer1(struct mpstr *mp,struct frame *fr,int outmode,struct audio_info_struct *ai)
|
||||
{
|
||||
int clip=0;
|
||||
int i,stereo = fr->stereo;
|
||||
unsigned int balloc[2*SBLIMIT];
|
||||
unsigned int scale_index[2][SBLIMIT];
|
||||
real fraction[2][SBLIMIT];
|
||||
int single = fr->single;
|
||||
|
||||
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? (fr->mode_ext<<2)+4 : 32;
|
||||
|
||||
if(stereo == 1 || single == 3)
|
||||
single = 0;
|
||||
|
||||
I_step_one(balloc,scale_index,fr);
|
||||
|
||||
for (i=0;i<SCALE_BLOCK;i++)
|
||||
{
|
||||
I_step_two(fraction,balloc,scale_index,fr);
|
||||
|
||||
if(single >= 0)
|
||||
{
|
||||
clip += (fr->synth_mono)( (real *) fraction[single],pcm_sample,&pcm_point);
|
||||
}
|
||||
else {
|
||||
int p1 = pcm_point;
|
||||
clip += (fr->synth)( (real *) fraction[0],0,pcm_sample,&p1);
|
||||
clip += (fr->synth)( (real *) fraction[1],1,pcm_sample,&pcm_point);
|
||||
}
|
||||
|
||||
if(pcm_point >= audiobufsize)
|
||||
audio_flush(outmode,ai);
|
||||
}
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,304 +0,0 @@
|
|||
/*
|
||||
* Mpeg Layer-2 audio decoder
|
||||
* --------------------------
|
||||
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README'
|
||||
*
|
||||
*/
|
||||
|
||||
#include "mpg123.h"
|
||||
#include "l2tables.h"
|
||||
|
||||
#include "getbits.h"
|
||||
|
||||
static int grp_3tab[32 * 3] = { 0, }; /* used: 27 */
|
||||
static int grp_5tab[128 * 3] = { 0, }; /* used: 125 */
|
||||
static int grp_9tab[1024 * 3] = { 0, }; /* used: 729 */
|
||||
|
||||
real muls[27][64]; /* also used by layer 1 */
|
||||
|
||||
void init_layer2(void)
|
||||
{
|
||||
static double mulmul[27] = {
|
||||
0.0 , -2.0/3.0 , 2.0/3.0 ,
|
||||
2.0/7.0 , 2.0/15.0 , 2.0/31.0, 2.0/63.0 , 2.0/127.0 , 2.0/255.0 ,
|
||||
2.0/511.0 , 2.0/1023.0 , 2.0/2047.0 , 2.0/4095.0 , 2.0/8191.0 ,
|
||||
2.0/16383.0 , 2.0/32767.0 , 2.0/65535.0 ,
|
||||
-4.0/5.0 , -2.0/5.0 , 2.0/5.0, 4.0/5.0 ,
|
||||
-8.0/9.0 , -4.0/9.0 , -2.0/9.0 , 2.0/9.0 , 4.0/9.0 , 8.0/9.0 };
|
||||
static int base[3][9] = {
|
||||
{ 1 , 0, 2 , } ,
|
||||
{ 17, 18, 0 , 19, 20 , } ,
|
||||
{ 21, 1, 22, 23, 0, 24, 25, 2, 26 } };
|
||||
int i,j,k,l,len;
|
||||
real *table;
|
||||
static int tablen[3] = { 3 , 5 , 9 };
|
||||
static int *itable,*tables[3] = { grp_3tab , grp_5tab , grp_9tab };
|
||||
|
||||
for(i=0;i<3;i++)
|
||||
{
|
||||
itable = tables[i];
|
||||
len = tablen[i];
|
||||
for(j=0;j<len;j++)
|
||||
for(k=0;k<len;k++)
|
||||
for(l=0;l<len;l++)
|
||||
{
|
||||
*itable++ = base[i][l];
|
||||
*itable++ = base[i][k];
|
||||
*itable++ = base[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
for(k=0;k<27;k++)
|
||||
{
|
||||
double m=mulmul[k];
|
||||
table = muls[k];
|
||||
#ifdef USE_MMX
|
||||
if(!param.down_sample)
|
||||
for(j=3,i=0;i<63;i++,j--)
|
||||
*table++ = 16384 * m * pow(2.0,(double) j / 3.0);
|
||||
else
|
||||
#endif
|
||||
for(j=3,i=0;i<63;i++,j--)
|
||||
*table++ = m * pow(2.0,(double) j / 3.0);
|
||||
*table++ = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void II_step_one(unsigned int *bit_alloc,int *scale,struct frame *fr)
|
||||
{
|
||||
int stereo = fr->stereo-1;
|
||||
int sblimit = fr->II_sblimit;
|
||||
int jsbound = fr->jsbound;
|
||||
int sblimit2 = fr->II_sblimit<<stereo;
|
||||
struct al_table *alloc1 = fr->alloc;
|
||||
int i;
|
||||
static unsigned int scfsi_buf[64];
|
||||
unsigned int *scfsi,*bita;
|
||||
int sc,step;
|
||||
|
||||
bita = bit_alloc;
|
||||
if(stereo)
|
||||
{
|
||||
for (i=jsbound;i;i--,alloc1+=(1<<step))
|
||||
{
|
||||
*bita++ = (char) getbits(step=alloc1->bits);
|
||||
*bita++ = (char) getbits(step);
|
||||
}
|
||||
for (i=sblimit-jsbound;i;i--,alloc1+=(1<<step))
|
||||
{
|
||||
bita[0] = (char) getbits(step=alloc1->bits);
|
||||
bita[1] = bita[0];
|
||||
bita+=2;
|
||||
}
|
||||
bita = bit_alloc;
|
||||
scfsi=scfsi_buf;
|
||||
for (i=sblimit2;i;i--)
|
||||
if (*bita++)
|
||||
*scfsi++ = (char) getbits_fast(2);
|
||||
}
|
||||
else /* mono */
|
||||
{
|
||||
for (i=sblimit;i;i--,alloc1+=(1<<step))
|
||||
*bita++ = (char) getbits(step=alloc1->bits);
|
||||
bita = bit_alloc;
|
||||
scfsi=scfsi_buf;
|
||||
for (i=sblimit;i;i--)
|
||||
if (*bita++)
|
||||
*scfsi++ = (char) getbits_fast(2);
|
||||
}
|
||||
|
||||
bita = bit_alloc;
|
||||
scfsi=scfsi_buf;
|
||||
for (i=sblimit2;i;i--)
|
||||
if (*bita++)
|
||||
switch (*scfsi++)
|
||||
{
|
||||
case 0:
|
||||
*scale++ = getbits_fast(6);
|
||||
*scale++ = getbits_fast(6);
|
||||
*scale++ = getbits_fast(6);
|
||||
break;
|
||||
case 1 :
|
||||
*scale++ = sc = getbits_fast(6);
|
||||
*scale++ = sc;
|
||||
*scale++ = getbits_fast(6);
|
||||
break;
|
||||
case 2:
|
||||
*scale++ = sc = getbits_fast(6);
|
||||
*scale++ = sc;
|
||||
*scale++ = sc;
|
||||
break;
|
||||
default: /* case 3 */
|
||||
*scale++ = getbits_fast(6);
|
||||
*scale++ = sc = getbits_fast(6);
|
||||
*scale++ = sc;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void II_step_two(unsigned int *bit_alloc,real fraction[2][4][SBLIMIT],int *scale,struct frame *fr,int x1)
|
||||
{
|
||||
int i,j,k,ba;
|
||||
int stereo = fr->stereo;
|
||||
int sblimit = fr->II_sblimit;
|
||||
int jsbound = fr->jsbound;
|
||||
struct al_table *alloc2,*alloc1 = fr->alloc;
|
||||
unsigned int *bita=bit_alloc;
|
||||
int d1,step;
|
||||
|
||||
for (i=0;i<jsbound;i++,alloc1+=(1<<step))
|
||||
{
|
||||
step = alloc1->bits;
|
||||
for (j=0;j<stereo;j++)
|
||||
{
|
||||
if ( (ba=*bita++) )
|
||||
{
|
||||
k=(alloc2 = alloc1+ba)->bits;
|
||||
if( (d1=alloc2->d) < 0)
|
||||
{
|
||||
real cm=muls[k][scale[x1]];
|
||||
fraction[j][0][i] = ((real) ((int)getbits(k) + d1)) * cm;
|
||||
fraction[j][1][i] = ((real) ((int)getbits(k) + d1)) * cm;
|
||||
fraction[j][2][i] = ((real) ((int)getbits(k) + d1)) * cm;
|
||||
}
|
||||
else
|
||||
{
|
||||
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
|
||||
unsigned int idx,*tab,m=scale[x1];
|
||||
idx = (unsigned int) getbits(k);
|
||||
tab = (unsigned int *) (table[d1] + idx + idx + idx);
|
||||
fraction[j][0][i] = muls[*tab++][m];
|
||||
fraction[j][1][i] = muls[*tab++][m];
|
||||
fraction[j][2][i] = muls[*tab][m];
|
||||
}
|
||||
scale+=3;
|
||||
}
|
||||
else
|
||||
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=jsbound;i<sblimit;i++,alloc1+=(1<<step))
|
||||
{
|
||||
step = alloc1->bits;
|
||||
bita++; /* channel 1 and channel 2 bitalloc are the same */
|
||||
if ( (ba=*bita++) )
|
||||
{
|
||||
k=(alloc2 = alloc1+ba)->bits;
|
||||
if( (d1=alloc2->d) < 0)
|
||||
{
|
||||
real cm;
|
||||
cm=muls[k][scale[x1+3]];
|
||||
fraction[1][0][i] = (fraction[0][0][i] = (real) ((int)getbits(k) + d1) ) * cm;
|
||||
fraction[1][1][i] = (fraction[0][1][i] = (real) ((int)getbits(k) + d1) ) * cm;
|
||||
fraction[1][2][i] = (fraction[0][2][i] = (real) ((int)getbits(k) + d1) ) * cm;
|
||||
cm=muls[k][scale[x1]];
|
||||
fraction[0][0][i] *= cm; fraction[0][1][i] *= cm; fraction[0][2][i] *= cm;
|
||||
}
|
||||
else
|
||||
{
|
||||
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
|
||||
unsigned int idx,*tab,m1,m2;
|
||||
m1 = scale[x1]; m2 = scale[x1+3];
|
||||
idx = (unsigned int) getbits(k);
|
||||
tab = (unsigned int *) (table[d1] + idx + idx + idx);
|
||||
fraction[0][0][i] = muls[*tab][m1]; fraction[1][0][i] = muls[*tab++][m2];
|
||||
fraction[0][1][i] = muls[*tab][m1]; fraction[1][1][i] = muls[*tab++][m2];
|
||||
fraction[0][2][i] = muls[*tab][m1]; fraction[1][2][i] = muls[*tab][m2];
|
||||
}
|
||||
scale+=6;
|
||||
}
|
||||
else {
|
||||
fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] =
|
||||
fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0;
|
||||
}
|
||||
/*
|
||||
should we use individual scalefac for channel 2 or
|
||||
is the current way the right one , where we just copy channel 1 to
|
||||
channel 2 ??
|
||||
The current 'strange' thing is, that we throw away the scalefac
|
||||
values for the second channel ...!!
|
||||
-> changed .. now we use the scalefac values of channel one !!
|
||||
*/
|
||||
}
|
||||
|
||||
if(sblimit > (fr->down_sample_sblimit) )
|
||||
sblimit = fr->down_sample_sblimit;
|
||||
|
||||
for(i=sblimit;i<SBLIMIT;i++)
|
||||
for (j=0;j<stereo;j++)
|
||||
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
|
||||
|
||||
}
|
||||
|
||||
static void II_select_table(struct frame *fr)
|
||||
{
|
||||
static int translate[3][2][16] =
|
||||
{ { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } ,
|
||||
{ 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } ,
|
||||
{ { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,
|
||||
{ 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,
|
||||
{ { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } ,
|
||||
{ 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };
|
||||
|
||||
int table,sblim;
|
||||
static struct al_table *tables[5] =
|
||||
{ alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 };
|
||||
static int sblims[5] = { 27 , 30 , 8, 12 , 30 };
|
||||
|
||||
if(fr->lsf)
|
||||
table = 4;
|
||||
else
|
||||
table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index];
|
||||
sblim = sblims[table];
|
||||
|
||||
fr->alloc = tables[table];
|
||||
fr->II_sblimit = sblim;
|
||||
}
|
||||
|
||||
|
||||
int do_layer2(struct mpstr *mp,struct frame *fr,int outmode,struct audio_info_struct *ai)
|
||||
{
|
||||
int clip=0;
|
||||
int i,j;
|
||||
int stereo = fr->stereo;
|
||||
real fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */
|
||||
unsigned int bit_alloc[64];
|
||||
int scale[192];
|
||||
int single = fr->single;
|
||||
|
||||
II_select_table(fr);
|
||||
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
|
||||
(fr->mode_ext<<2)+4 : fr->II_sblimit;
|
||||
|
||||
if(stereo == 1 || single == 3)
|
||||
single = 0;
|
||||
|
||||
II_step_one(bit_alloc, scale, fr);
|
||||
|
||||
for (i=0;i<SCALE_BLOCK;i++)
|
||||
{
|
||||
II_step_two(bit_alloc,fraction,scale,fr,i>>2);
|
||||
for (j=0;j<3;j++)
|
||||
{
|
||||
if(single >= 0)
|
||||
{
|
||||
clip += (fr->synth_mono) (fraction[single][j],pcm_sample,&pcm_point);
|
||||
}
|
||||
else {
|
||||
int p1 = pcm_point;
|
||||
clip += (fr->synth) (fraction[0][j],0,pcm_sample,&p1);
|
||||
clip += (fr->synth) (fraction[1][j],1,pcm_sample,&pcm_point);
|
||||
}
|
||||
|
||||
if(pcm_point >= audiobufsize)
|
||||
audio_flush(outmode,ai);
|
||||
}
|
||||
}
|
||||
|
||||
return clip;
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,415 +0,0 @@
|
|||
/*
|
||||
* mpg123 defines
|
||||
* used source: musicout.h from mpegaudio package
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <signal.h>
|
||||
|
||||
#ifndef WIN32
|
||||
#include <sys/signal.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <math.h>
|
||||
|
||||
typedef unsigned char byte;
|
||||
|
||||
#ifdef OS2
|
||||
#include <float.h>
|
||||
#endif
|
||||
|
||||
#define MPG123_REMOTE
|
||||
#ifdef HPUX
|
||||
#define random rand
|
||||
#define srandom srand
|
||||
#endif
|
||||
|
||||
#define FRONTEND_NONE 0
|
||||
#define FRONTEND_SAJBER 1
|
||||
#define FRONTEND_TK3PLAY 2
|
||||
#define FRONTEND_GENERIC 3
|
||||
|
||||
#define SKIP_JUNK 1
|
||||
|
||||
#ifdef _WIN32 /* Win32 Additions By Tony Million */
|
||||
# undef WIN32
|
||||
# define WIN32
|
||||
|
||||
# define M_PI 3.14159265358979323846
|
||||
# define M_SQRT2 1.41421356237309504880
|
||||
# define REAL_IS_FLOAT
|
||||
# define NEW_DCT9
|
||||
|
||||
# define random rand
|
||||
# define srandom srand
|
||||
|
||||
# undef MPG123_REMOTE /* Get rid of this stuff for Win32 */
|
||||
#endif
|
||||
|
||||
#include "xfermem.h"
|
||||
|
||||
#ifdef SUNOS
|
||||
#define memmove(dst,src,size) bcopy(src,dst,size)
|
||||
#endif
|
||||
|
||||
#ifdef REAL_IS_FLOAT
|
||||
# define real float
|
||||
#elif defined(REAL_IS_LONG_DOUBLE)
|
||||
# define real long double
|
||||
#else
|
||||
# define real double
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#ifndef INLINE
|
||||
#define INLINE inline
|
||||
#endif /* INLINE */
|
||||
#else
|
||||
#ifndef INLINE
|
||||
#define INLINE
|
||||
#endif /* INLINE */
|
||||
#endif
|
||||
|
||||
#include "mpgaudio.h"
|
||||
|
||||
/* AUDIOBUFSIZE = n*64 with n=1,2,3 ... */
|
||||
#define AUDIOBUFSIZE 16384
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
#define MAX_NAME_SIZE 81
|
||||
#define SBLIMIT 32
|
||||
#define SCALE_BLOCK 12
|
||||
#define SSLIMIT 18
|
||||
|
||||
#define MPG_MD_STEREO 0
|
||||
#define MPG_MD_JOINT_STEREO 1
|
||||
#define MPG_MD_DUAL_CHANNEL 2
|
||||
#define MPG_MD_MONO 3
|
||||
|
||||
#define MAXFRAMESIZE 1792
|
||||
#define HDRCMPMASK 0xfffffd00
|
||||
|
||||
#define MAXOUTBURST 32768
|
||||
|
||||
/* Pre Shift fo 16 to 8 bit converter table */
|
||||
#define AUSHIFT (3)
|
||||
|
||||
|
||||
struct al_table
|
||||
{
|
||||
short bits;
|
||||
short d;
|
||||
};
|
||||
|
||||
struct frame {
|
||||
struct al_table *alloc;
|
||||
int (*synth)(real *,int,unsigned char *,int *);
|
||||
int (*synth_mono)(real *,unsigned char *,int *);
|
||||
#ifdef USE_3DNOW
|
||||
void (*dct36)(real *,real *,real *,real *,real *);
|
||||
#endif
|
||||
int stereo;
|
||||
int jsbound;
|
||||
int single;
|
||||
int II_sblimit;
|
||||
int down_sample_sblimit;
|
||||
int lsf;
|
||||
int mpeg25;
|
||||
int down_sample;
|
||||
int header_change;
|
||||
int lay;
|
||||
int error_protection;
|
||||
int bitrate_index;
|
||||
int sampling_frequency;
|
||||
int padding;
|
||||
int extension;
|
||||
int mode;
|
||||
int mode_ext;
|
||||
int copyright;
|
||||
int original;
|
||||
int emphasis;
|
||||
int framesize; /* computed framesize */
|
||||
};
|
||||
|
||||
#define VBR_TOC_SIZE 100
|
||||
|
||||
#define VBR_FRAMES_FLAG 0x0001
|
||||
#define VBR_BYTES_FLAG 0x0002
|
||||
#define VBR_TOC_FLAG 0x0004
|
||||
#define VBR_SCALE_FLAG 0x0008
|
||||
|
||||
struct vbrHeader {
|
||||
unsigned long flags;
|
||||
unsigned long frames;
|
||||
unsigned long bytes;
|
||||
unsigned long scale;
|
||||
unsigned char toc[100];
|
||||
};
|
||||
|
||||
struct parameter {
|
||||
int aggressive; /* renice to max. priority */
|
||||
int shuffle; /* shuffle/random play */
|
||||
int remote; /* remote operation */
|
||||
int outmode; /* where to out the decoded sampels */
|
||||
int quiet; /* shut up! */
|
||||
int xterm_title; /* print filename in xterm title */
|
||||
long usebuffer; /* second level buffer size */
|
||||
int tryresync; /* resync stream after error */
|
||||
int verbose; /* verbose level */
|
||||
#ifdef TERM_CONTROL
|
||||
int term_ctrl;
|
||||
#endif
|
||||
int force_mono;
|
||||
int force_stereo;
|
||||
int force_8bit;
|
||||
long force_rate;
|
||||
int down_sample;
|
||||
int checkrange;
|
||||
long doublespeed;
|
||||
long halfspeed;
|
||||
int force_reopen;
|
||||
int stat_3dnow; /* automatic/force/force-off 3DNow! optimized code */
|
||||
int test_3dnow;
|
||||
long realtime;
|
||||
char filename[256];
|
||||
char *esdserver;
|
||||
char *equalfile;
|
||||
int enable_equalizer;
|
||||
long outscale;
|
||||
long startFrame;
|
||||
};
|
||||
|
||||
struct bitstream_info {
|
||||
int bitindex;
|
||||
unsigned char *wordpointer;
|
||||
};
|
||||
|
||||
struct mpstr {
|
||||
int bsize;
|
||||
int framesize;
|
||||
int fsizeold;
|
||||
struct frame fr;
|
||||
/* int (*do_layer)(struct mpstr *,struct frame *fr,int,struct audio_info_struct *); */
|
||||
unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
|
||||
real hybrid_block[2][2][SBLIMIT*SSLIMIT];
|
||||
int hybrid_blc[2];
|
||||
unsigned long header;
|
||||
int bsnum;
|
||||
real synth_buffs[2][2][0x110];
|
||||
int synth_bo;
|
||||
|
||||
struct bitstream_info bsi;
|
||||
};
|
||||
|
||||
extern struct bitstream_info bsi;
|
||||
|
||||
struct reader {
|
||||
int (*init)(struct reader *);
|
||||
void (*close)(struct reader *);
|
||||
int (*head_read)(struct reader *,unsigned long *newhead);
|
||||
int (*head_shift)(struct reader *,unsigned long *head);
|
||||
int (*skip_bytes)(struct reader *,int len);
|
||||
int (*read_frame_body)(struct reader *,unsigned char *,int size);
|
||||
int (*back_bytes)(struct reader *,int bytes);
|
||||
int (*back_frame)(struct reader *,struct frame *,int num);
|
||||
long (*tell)(struct reader *);
|
||||
void (*rewind)(struct reader *);
|
||||
long filelen;
|
||||
long filepos;
|
||||
int filept;
|
||||
int flags;
|
||||
unsigned char id3buf[128];
|
||||
};
|
||||
#define READER_FD_OPENED 0x1
|
||||
#define READER_ID3TAG 0x2
|
||||
|
||||
extern struct reader *rd,readers[];
|
||||
|
||||
extern int halfspeed;
|
||||
extern int buffer_fd[2];
|
||||
extern txfermem *buffermem;
|
||||
extern char *prgName, *prgVersion;
|
||||
|
||||
#ifndef NOXFERMEM
|
||||
extern void buffer_loop(struct audio_info_struct *ai,sigset_t *oldsigset);
|
||||
#endif
|
||||
|
||||
|
||||
/* ------ Declarations from "httpget.c" ------ */
|
||||
|
||||
extern char *proxyurl;
|
||||
extern unsigned long proxyip;
|
||||
extern int http_open (char *url);
|
||||
extern char *httpauth;
|
||||
|
||||
/* ------ Declarations from "common.c" ------ */
|
||||
|
||||
extern void audio_flush(int, struct audio_info_struct *);
|
||||
extern void (*catchsignal(int signum, void(*handler)()))();
|
||||
|
||||
extern void print_header(struct frame *);
|
||||
extern void print_header_compact(struct frame *);
|
||||
extern void print_id3_tag(unsigned char *buf);
|
||||
|
||||
extern int split_dir_file(const char *path, char **dname, char **fname);
|
||||
|
||||
extern unsigned int get1bit(struct bitstream_info *);
|
||||
extern unsigned int getbits(struct bitstream_info *,int);
|
||||
extern unsigned int getbits_fast(struct bitstream_info *,int);
|
||||
extern void backbits(struct bitstream_info *,int);
|
||||
extern int getbitoffset(struct bitstream_info *);
|
||||
extern int getbyte(struct bitstream_info *);
|
||||
|
||||
extern void set_pointer(long);
|
||||
|
||||
extern unsigned char *pcm_sample;
|
||||
extern int pcm_point;
|
||||
extern int audiobufsize;
|
||||
|
||||
extern int OutputDescriptor;
|
||||
|
||||
struct gr_info_s {
|
||||
int scfsi;
|
||||
unsigned part2_3_length;
|
||||
unsigned big_values;
|
||||
unsigned scalefac_compress;
|
||||
unsigned block_type;
|
||||
unsigned mixed_block_flag;
|
||||
unsigned table_select[3];
|
||||
unsigned subblock_gain[3];
|
||||
unsigned maxband[3];
|
||||
unsigned maxbandl;
|
||||
unsigned maxb;
|
||||
unsigned region1start;
|
||||
unsigned region2start;
|
||||
unsigned preflag;
|
||||
unsigned scalefac_scale;
|
||||
unsigned count1table_select;
|
||||
real *full_gain[3];
|
||||
real *pow2gain;
|
||||
};
|
||||
|
||||
struct III_sideinfo
|
||||
{
|
||||
unsigned main_data_begin;
|
||||
unsigned private_bits;
|
||||
struct {
|
||||
struct gr_info_s gr[2];
|
||||
} ch[2];
|
||||
};
|
||||
|
||||
extern struct reader *open_stream(char *,int fd);
|
||||
extern void read_frame_init (void);
|
||||
extern int read_frame(struct frame *fr);
|
||||
extern int play_frame(struct mpstr *mp,int init,struct frame *fr);
|
||||
extern int do_layer3(struct mpstr *mp,struct frame *fr,int,struct audio_info_struct *);
|
||||
extern int do_layer2(struct mpstr *mp,struct frame *fr,int,struct audio_info_struct *);
|
||||
extern int do_layer1(struct mpstr *mp,struct frame *fr,int,struct audio_info_struct *);
|
||||
extern void do_equalizer(real *bandPtr,int channel);
|
||||
|
||||
#ifdef PENTIUM_OPT
|
||||
extern int synth_1to1_pent (real *,int,unsigned char *);
|
||||
#endif
|
||||
extern int synth_1to1 (real *,int,unsigned char *,int *);
|
||||
extern int synth_1to1_8bit (real *,int,unsigned char *,int *);
|
||||
extern int synth_1to1_mono (real *,unsigned char *,int *);
|
||||
extern int synth_1to1_mono2stereo (real *,unsigned char *,int *);
|
||||
extern int synth_1to1_8bit_mono (real *,unsigned char *,int *);
|
||||
extern int synth_1to1_8bit_mono2stereo (real *,unsigned char *,int *);
|
||||
|
||||
extern int synth_2to1 (real *,int,unsigned char *,int *);
|
||||
extern int synth_2to1_8bit (real *,int,unsigned char *,int *);
|
||||
extern int synth_2to1_mono (real *,unsigned char *,int *);
|
||||
extern int synth_2to1_mono2stereo (real *,unsigned char *,int *);
|
||||
extern int synth_2to1_8bit_mono (real *,unsigned char *,int *);
|
||||
extern int synth_2to1_8bit_mono2stereo (real *,unsigned char *,int *);
|
||||
|
||||
extern int synth_4to1 (real *,int,unsigned char *,int *);
|
||||
extern int synth_4to1_8bit (real *,int,unsigned char *,int *);
|
||||
extern int synth_4to1_mono (real *,unsigned char *,int *);
|
||||
extern int synth_4to1_mono2stereo (real *,unsigned char *,int *);
|
||||
extern int synth_4to1_8bit_mono (real *,unsigned char *,int *);
|
||||
extern int synth_4to1_8bit_mono2stereo (real *,unsigned char *,int *);
|
||||
|
||||
extern int synth_ntom (real *,int,unsigned char *,int *);
|
||||
extern int synth_ntom_8bit (real *,int,unsigned char *,int *);
|
||||
extern int synth_ntom_mono (real *,unsigned char *,int *);
|
||||
extern int synth_ntom_mono2stereo (real *,unsigned char *,int *);
|
||||
extern int synth_ntom_8bit_mono (real *,unsigned char *,int *);
|
||||
extern int synth_ntom_8bit_mono2stereo (real *,unsigned char *,int *);
|
||||
|
||||
extern void rewindNbits(int bits);
|
||||
extern int hsstell(void);
|
||||
extern void set_pointer(long);
|
||||
extern void huffman_decoder(int ,int *);
|
||||
extern void huffman_count1(int,int *);
|
||||
extern void print_stat(struct frame *fr,int no,long buffsize,struct audio_info_struct *ai);
|
||||
extern int get_songlen(struct frame *fr,int no);
|
||||
|
||||
extern void init_layer3(int);
|
||||
extern void init_layer2(void);
|
||||
extern void make_decode_tables(long scale);
|
||||
extern void make_conv16to8_table(int);
|
||||
extern void dct64(real *,real *,real *);
|
||||
|
||||
#ifdef USE_MMX
|
||||
extern void dct64_MMX(short *a,short *b,real *c);
|
||||
extern int synth_1to1_MMX(real *, int, short *, short *, int *);
|
||||
#endif
|
||||
|
||||
extern void synth_ntom_set_step(long,long);
|
||||
|
||||
extern void control_generic(struct mpstr *,struct frame *fr);
|
||||
extern void control_sajber(struct mpstr *,struct frame *fr);
|
||||
extern void control_tk3play(struct mpstr *,struct frame *fr);
|
||||
|
||||
extern int cdr_open(struct audio_info_struct *ai, char *ame);
|
||||
extern int au_open(struct audio_info_struct *ai, char *name);
|
||||
extern int wav_open(struct audio_info_struct *ai, char *wavfilename);
|
||||
extern int wav_write(unsigned char *buf,int len);
|
||||
extern int cdr_close(void);
|
||||
extern int au_close(void);
|
||||
extern int wav_close(void);
|
||||
|
||||
extern int au_open(struct audio_info_struct *ai, char *aufilename);
|
||||
extern int au_close(void);
|
||||
|
||||
extern int cdr_open(struct audio_info_struct *ai, char *cdrfilename);
|
||||
extern int cdr_close(void);
|
||||
|
||||
extern int getVBRHeader(struct vbrHeader *head,unsigned char *buf,
|
||||
struct frame *fr);
|
||||
|
||||
|
||||
extern unsigned char *conv16to8;
|
||||
extern long freqs[9];
|
||||
extern real muls[27][64];
|
||||
extern real decwin[512+32];
|
||||
#ifndef USE_MMX
|
||||
extern real *pnts[5];
|
||||
#endif
|
||||
|
||||
extern real equalizer[2][32];
|
||||
extern real equalizer_sum[2][32];
|
||||
extern int equalizer_cnt;
|
||||
|
||||
extern struct audio_name audio_val2name[];
|
||||
|
||||
extern struct parameter param;
|
||||
|
||||
/* 486 optimizations */
|
||||
#define FIR_BUFFER_SIZE 128
|
||||
extern void dct64_486(int *a,int *b,real *c);
|
||||
extern int synth_1to1_486(real *bandPtr,int channel,unsigned char *out,int nb_blocks);
|
||||
|
||||
/* 3DNow! optimizations */
|
||||
#ifdef USE_3DNOW
|
||||
extern int getcpuflags(void);
|
||||
extern void dct36(real *,real *,real *,real *,real *);
|
||||
extern void dct36_3dnow(real *,real *,real *,real *,real *);
|
||||
extern int synth_1to1_3dnow(real *,int,unsigned char *,int *);
|
||||
#endif
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
/*
|
||||
* Audio 'LIB' defines
|
||||
*/
|
||||
|
||||
#define AUDIO_OUT_HEADPHONES 0x01
|
||||
#define AUDIO_OUT_INTERNAL_SPEAKER 0x02
|
||||
#define AUDIO_OUT_LINE_OUT 0x04
|
||||
|
||||
enum { DECODE_TEST, DECODE_AUDIO, DECODE_FILE, DECODE_BUFFER, DECODE_WAV,
|
||||
DECODE_AU,DECODE_CDR,DECODE_AUDIOFILE };
|
||||
|
||||
#define AUDIO_FORMAT_MASK 0x100
|
||||
#define AUDIO_FORMAT_16 0x100
|
||||
#define AUDIO_FORMAT_8 0x000
|
||||
|
||||
#define AUDIO_FORMAT_SIGNED_16 0x110
|
||||
#define AUDIO_FORMAT_UNSIGNED_16 0x120
|
||||
#define AUDIO_FORMAT_UNSIGNED_8 0x1
|
||||
#define AUDIO_FORMAT_SIGNED_8 0x2
|
||||
#define AUDIO_FORMAT_ULAW_8 0x4
|
||||
#define AUDIO_FORMAT_ALAW_8 0x8
|
||||
|
||||
/* 3% rate tolerance */
|
||||
#define AUDIO_RATE_TOLERANCE 3
|
||||
|
||||
#if 0
|
||||
#if defined(HPUX) || defined(SUNOS) || defined(SOLARIS) || defined(OSS) || defined(__NetBSD__) || defined(SPARCLINUX) || defined(__FreeBSD__)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define AUDIO_USES_FD
|
||||
|
||||
#ifdef SGI
|
||||
/* #include <audio.h> */
|
||||
#include <dmedia/audio.h>
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef ALSA
|
||||
#include <sys/asoundlib.h>
|
||||
#endif
|
||||
|
||||
struct audio_info_struct
|
||||
{
|
||||
#ifdef AUDIO_USES_FD
|
||||
int fn; /* filenumber */
|
||||
#endif
|
||||
#ifdef SGI
|
||||
ALconfig config;
|
||||
ALport port;
|
||||
#endif
|
||||
long rate;
|
||||
long gain;
|
||||
int output;
|
||||
#ifdef ALSA
|
||||
snd_pcm_t *handle;
|
||||
snd_pcm_format_t alsa_format;
|
||||
#endif
|
||||
char *device;
|
||||
int channels;
|
||||
int format;
|
||||
int private1;
|
||||
void *private2;
|
||||
};
|
||||
|
||||
struct audio_name {
|
||||
int val;
|
||||
char *name;
|
||||
char *sname;
|
||||
};
|
||||
|
||||
extern void audio_capabilities(struct audio_info_struct *);
|
||||
extern void audio_fit_capabilities(struct audio_info_struct *ai,int c,int r);
|
||||
|
||||
extern char *audio_encoding_name(int format);
|
||||
|
||||
extern int audio_play_samples(struct audio_info_struct *,unsigned char *,int);
|
||||
extern int audio_open(struct audio_info_struct *);
|
||||
extern int audio_reset_parameters(struct audio_info_struct *);
|
||||
extern int audio_rate_best_match(struct audio_info_struct *ai);
|
||||
extern int audio_set_rate(struct audio_info_struct *);
|
||||
extern int audio_set_format(struct audio_info_struct *);
|
||||
extern int audio_get_formats(struct audio_info_struct *);
|
||||
extern int audio_set_channels(struct audio_info_struct *);
|
||||
extern int audio_write_sample(struct audio_info_struct *,short *,int);
|
||||
extern int audio_close(struct audio_info_struct *);
|
||||
extern void audio_info_struct_init(struct audio_info_struct *);
|
||||
extern void audio_queueflush(struct audio_info_struct *ai);
|
||||
|
||||
|
|
@ -1,237 +0,0 @@
|
|||
/*
|
||||
* buffer.c
|
||||
*
|
||||
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de>
|
||||
* Mon Apr 14 03:53:18 MET DST 1997
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#define SIGUSR1 0
|
||||
#define SIGCONT 0
|
||||
#define SIGSTOP 0
|
||||
#endif /* WIN32 */
|
||||
|
||||
int outburst = MAXOUTBURST;
|
||||
int preload;
|
||||
|
||||
static int intflag = FALSE;
|
||||
static int usr1flag = FALSE;
|
||||
|
||||
static void catch_interrupt (void)
|
||||
{
|
||||
intflag = TRUE;
|
||||
}
|
||||
|
||||
static void catch_usr1 (void)
|
||||
{
|
||||
usr1flag = TRUE;
|
||||
}
|
||||
|
||||
/* Interfaces to writer process */
|
||||
|
||||
extern void buffer_sig(int signal, int block);
|
||||
|
||||
void buffer_ignore_lowmem(void)
|
||||
{
|
||||
#ifndef NOXFERMEM
|
||||
if(buffermem->wakeme[XF_READER])
|
||||
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
|
||||
#endif
|
||||
}
|
||||
|
||||
void buffer_end(void)
|
||||
{
|
||||
#ifndef NOXFERMEM
|
||||
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_TERMINATE);
|
||||
#endif
|
||||
}
|
||||
|
||||
void buffer_resync(void)
|
||||
{
|
||||
buffer_sig(SIGINT, TRUE);
|
||||
}
|
||||
|
||||
void buffer_reset(void)
|
||||
{
|
||||
buffer_sig(SIGUSR1, TRUE);
|
||||
}
|
||||
|
||||
void buffer_start(void)
|
||||
{
|
||||
buffer_sig(SIGCONT, FALSE);
|
||||
}
|
||||
|
||||
void buffer_stop(void)
|
||||
{
|
||||
buffer_sig(SIGSTOP, FALSE);
|
||||
}
|
||||
|
||||
extern int buffer_pid;
|
||||
|
||||
void buffer_sig(int signal, int block)
|
||||
{
|
||||
|
||||
#ifndef NOXFERMEM
|
||||
|
||||
kill(buffer_pid, signal);
|
||||
|
||||
if (!buffermem || !block)
|
||||
return;
|
||||
|
||||
if(xfermem_block(XF_WRITER, buffermem) != XF_CMD_WAKEUP)
|
||||
perror("Could not resync/reset buffers");
|
||||
#endif
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#ifndef NOXFERMEM
|
||||
|
||||
void buffer_loop(struct audio_info_struct *ai, sigset_t *oldsigset)
|
||||
{
|
||||
int bytes;
|
||||
int my_fd = buffermem->fd[XF_READER];
|
||||
txfermem *xf = buffermem;
|
||||
int done = FALSE;
|
||||
|
||||
catchsignal (SIGINT, catch_interrupt);
|
||||
catchsignal (SIGUSR1, catch_usr1);
|
||||
sigprocmask (SIG_SETMASK, oldsigset, NULL);
|
||||
if (param.outmode == DECODE_AUDIO) {
|
||||
if (audio_open(ai) < 0) {
|
||||
perror("audio");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
if (intflag) {
|
||||
intflag = FALSE;
|
||||
if (param.outmode == DECODE_AUDIO)
|
||||
audio_queueflush (ai);
|
||||
xf->readindex = xf->freeindex;
|
||||
if (xf->wakeme[XF_WRITER])
|
||||
xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
|
||||
}
|
||||
if (usr1flag) {
|
||||
usr1flag = FALSE;
|
||||
/* close and re-open in order to flush
|
||||
* the device's internal buffer before
|
||||
* changing the sample rate. [OF]
|
||||
*/
|
||||
/* writer must block when sending SIGUSR1
|
||||
* or we will lose all data processed
|
||||
* in the meantime! [dk]
|
||||
*/
|
||||
xf->readindex = xf->freeindex;
|
||||
/* We've nailed down the new starting location -
|
||||
* writer is now safe to go on. [dk]
|
||||
*/
|
||||
if (xf->wakeme[XF_WRITER])
|
||||
xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
|
||||
if (param.outmode == DECODE_AUDIO) {
|
||||
audio_close (ai);
|
||||
ai->rate = xf->buf[0];
|
||||
ai->channels = xf->buf[1];
|
||||
ai->format = xf->buf[2];
|
||||
if (audio_open(ai) < 0) {
|
||||
perror("audio");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( (bytes = xfermem_get_usedspace(xf)) < outburst ) {
|
||||
/* if we got a buffer underrun we first
|
||||
* fill 1/8 of the buffer before continue/start
|
||||
* playing */
|
||||
preload = xf->size>>3;
|
||||
if(preload < outburst)
|
||||
preload = outburst;
|
||||
}
|
||||
if(bytes < preload) {
|
||||
int cmd;
|
||||
if (done && !bytes) {
|
||||
break;
|
||||
}
|
||||
|
||||
if(!done) {
|
||||
|
||||
cmd = xfermem_block(XF_READER, xf);
|
||||
|
||||
switch(cmd) {
|
||||
|
||||
/* More input pending. */
|
||||
case XF_CMD_WAKEUP_INFO:
|
||||
continue;
|
||||
/* Yes, we know buffer is low but
|
||||
* know we don't care.
|
||||
*/
|
||||
case XF_CMD_WAKEUP:
|
||||
break; /* Proceed playing. */
|
||||
case XF_CMD_TERMINATE:
|
||||
/* Proceed playing without
|
||||
* blocking any further.
|
||||
*/
|
||||
done=TRUE;
|
||||
break;
|
||||
case -1:
|
||||
if(errno==EINTR)
|
||||
continue;
|
||||
perror("Yuck! Error in buffer handling...");
|
||||
done = TRUE;
|
||||
xf->readindex = xf->freeindex;
|
||||
xfermem_putcmd(xf->fd[XF_READER], XF_CMD_TERMINATE);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "\nEh!? Received unknown command 0x%x in buffer process. Tell Daniel!\n", cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
preload = outburst; /* set preload to lower mark */
|
||||
if (bytes > xf->size - xf->readindex)
|
||||
bytes = xf->size - xf->readindex;
|
||||
if (bytes > outburst)
|
||||
bytes = outburst;
|
||||
|
||||
if (param.outmode == DECODE_FILE)
|
||||
bytes = write(OutputDescriptor, xf->data + xf->readindex, bytes);
|
||||
else if (param.outmode == DECODE_AUDIO)
|
||||
bytes = audio_play_samples(ai,
|
||||
(unsigned char *) (xf->data + xf->readindex), bytes);
|
||||
|
||||
if(bytes < 0) {
|
||||
bytes = 0;
|
||||
if(errno != EINTR) {
|
||||
perror("Ouch ... error while writing audio data: ");
|
||||
/*
|
||||
* done==TRUE tells writer process to stop
|
||||
* sending data. There might be some latency
|
||||
* involved when resetting readindex to
|
||||
* freeindex so we might need more than one
|
||||
* cycle to terminate. (The number of cycles
|
||||
* should be finite unless I managed to mess
|
||||
* up something. ;-) [dk]
|
||||
*/
|
||||
done = TRUE;
|
||||
xf->readindex = xf->freeindex;
|
||||
xfermem_putcmd(xf->fd[XF_READER], XF_CMD_TERMINATE);
|
||||
}
|
||||
}
|
||||
|
||||
xf->readindex = (xf->readindex + bytes) % xf->size;
|
||||
if (xf->wakeme[XF_WRITER])
|
||||
xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
|
||||
}
|
||||
|
||||
if (param.outmode == DECODE_AUDIO)
|
||||
audio_close (ai);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* EOF */
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
/*
|
||||
* Application specific interaction between main and buffer
|
||||
* process. This is much less generic than the functions in
|
||||
* xfermem so I chose to put it in buffer.[hc].
|
||||
* 01/28/99 [dk]
|
||||
*/
|
||||
|
||||
void buffer_ignore_lowmem(void);
|
||||
void buffer_end(void);
|
||||
void buffer_resync(void);
|
||||
void buffer_reset(void);
|
||||
void buffer_start(void);
|
||||
void buffer_stop(void);
|
||||
|
|
@ -1,501 +0,0 @@
|
|||
#include <stdlib.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#ifdef WIN32
|
||||
#include <io.h>
|
||||
#endif
|
||||
#include "mpg123.h"
|
||||
#include "mpgbuffer.h"
|
||||
#include "common.h"
|
||||
|
||||
#ifdef READ_MMAP
|
||||
#include <sys/mman.h>
|
||||
#ifndef MAP_FAILED
|
||||
#define MAP_FAILED ( (void *) -1 )
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static int get_fileinfo(struct reader *,char *buf);
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
* stream based operation
|
||||
*/
|
||||
static int fullread(int fd,unsigned char *buf,int count)
|
||||
{
|
||||
int ret,cnt=0;
|
||||
while(cnt < count) {
|
||||
ret = read(fd,buf+cnt,count-cnt);
|
||||
if(ret < 0)
|
||||
return ret;
|
||||
if(ret == 0)
|
||||
break;
|
||||
cnt += ret;
|
||||
}
|
||||
|
||||
return cnt;
|
||||
}
|
||||
|
||||
static int default_init(struct reader *rds)
|
||||
{
|
||||
char buf[128];
|
||||
|
||||
rds->filepos = 0;
|
||||
rds->filelen = get_fileinfo(rds,buf);
|
||||
|
||||
if(rds->filelen > 0) {
|
||||
if(!strncmp(buf,"TAG",3)) {
|
||||
rds->flags |= READER_ID3TAG;
|
||||
memcpy(rds->id3buf,buf,128);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void stream_close(struct reader *rds)
|
||||
{
|
||||
if (rds->flags & READER_FD_OPENED)
|
||||
close(rds->filept);
|
||||
}
|
||||
|
||||
/****************************************
|
||||
* HACK,HACK,HACK: step back <num> frames
|
||||
* can only work if the 'stream' isn't a real stream but a file
|
||||
*/
|
||||
static int stream_back_bytes(struct reader *rds,int bytes)
|
||||
{
|
||||
if(lseek(rds->filept,-bytes,SEEK_CUR) < 0)
|
||||
return -1;
|
||||
if(param.usebuffer)
|
||||
buffer_resync();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int stream_back_frame(struct reader *rds,struct frame *fr,int num)
|
||||
{
|
||||
long bytes;
|
||||
unsigned char buf[4];
|
||||
unsigned long newhead;
|
||||
|
||||
if(!firsthead)
|
||||
return 0;
|
||||
|
||||
bytes = (fr->framesize+8)*(num+2);
|
||||
|
||||
/* Skipping back/forth requires a bit more work in buffered mode.
|
||||
* See mapped_back_frame().
|
||||
*/
|
||||
if(param.usebuffer)
|
||||
bytes += (long)(xfermem_get_usedspace(buffermem) /
|
||||
(buffermem->buf[0] * buffermem->buf[1]
|
||||
* (buffermem->buf[2] & AUDIO_FORMAT_MASK ?
|
||||
16.0 : 8.0 ))
|
||||
* (tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index] << 10));
|
||||
/*
|
||||
bytes += (long)(compute_buffer_offset(fr)*compute_bpf(fr));
|
||||
*/
|
||||
if(lseek(rds->filept,-bytes,SEEK_CUR) < 0)
|
||||
return -1;
|
||||
|
||||
if(fullread(rds->filept,buf,4) != 4)
|
||||
return -1;
|
||||
|
||||
newhead = (buf[0]<<24) + (buf[1]<<16) + (buf[2]<<8) + buf[3];
|
||||
|
||||
while( (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK) ) {
|
||||
if(fullread(rds->filept,buf,1) != 1)
|
||||
return -1;
|
||||
newhead <<= 8;
|
||||
newhead |= buf[0];
|
||||
newhead &= 0xffffffff;
|
||||
}
|
||||
|
||||
if( lseek(rds->filept,-4,SEEK_CUR) < 0)
|
||||
return -1;
|
||||
|
||||
read_frame(fr);
|
||||
read_frame(fr);
|
||||
|
||||
if(fr->lay == 3) {
|
||||
set_pointer(512);
|
||||
}
|
||||
|
||||
if(param.usebuffer)
|
||||
buffer_resync();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int stream_head_read(struct reader *rds,unsigned long *newhead)
|
||||
{
|
||||
unsigned char hbuf[4];
|
||||
|
||||
if(fullread(rds->filept,hbuf,4) != 4)
|
||||
return FALSE;
|
||||
|
||||
*newhead = ((unsigned long) hbuf[0] << 24) |
|
||||
((unsigned long) hbuf[1] << 16) |
|
||||
((unsigned long) hbuf[2] << 8) |
|
||||
(unsigned long) hbuf[3];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int stream_head_shift(struct reader *rds,unsigned long *head)
|
||||
{
|
||||
unsigned char hbuf;
|
||||
|
||||
if(fullread(rds->filept,&hbuf,1) != 1)
|
||||
return 0;
|
||||
*head <<= 8;
|
||||
*head |= hbuf;
|
||||
*head &= 0xffffffff;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int stream_skip_bytes(struct reader *rds,int len)
|
||||
{
|
||||
if (!param.usebuffer)
|
||||
return lseek(rds->filept,len,SEEK_CUR);
|
||||
|
||||
else {
|
||||
|
||||
int ret = lseek(rds->filept,len,SEEK_CUR);
|
||||
buffer_resync();
|
||||
return ret;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
static int stream_read_frame_body(struct reader *rds,unsigned char *buf,
|
||||
int size)
|
||||
{
|
||||
long l;
|
||||
|
||||
if( (l=fullread(rds->filept,buf,size)) != size)
|
||||
{
|
||||
if(l <= 0)
|
||||
return 0;
|
||||
memset(buf+l,0,size-l);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static long stream_tell(struct reader *rds)
|
||||
{
|
||||
return lseek(rds->filept,0,SEEK_CUR);
|
||||
}
|
||||
|
||||
static void stream_rewind(struct reader *rds)
|
||||
{
|
||||
lseek(rds->filept,0,SEEK_SET);
|
||||
if(param.usebuffer)
|
||||
buffer_resync();
|
||||
}
|
||||
|
||||
/*
|
||||
* returns length of a file (if filept points to a file)
|
||||
* reads the last 128 bytes information into buffer
|
||||
*/
|
||||
static int get_fileinfo(struct reader *rds,char *buf)
|
||||
{
|
||||
int len;
|
||||
|
||||
if((len=lseek(rds->filept,0,SEEK_END)) < 0) {
|
||||
return -1;
|
||||
}
|
||||
if(lseek(rds->filept,-128,SEEK_END) < 0)
|
||||
return -1;
|
||||
if(fullread(rds->filept,(unsigned char *)buf,128) != 128) {
|
||||
return -1;
|
||||
}
|
||||
if(!strncmp(buf,"TAG",3)) {
|
||||
len -= 128;
|
||||
}
|
||||
if(lseek(rds->filept,0,SEEK_SET) < 0)
|
||||
return -1;
|
||||
if(len <= 0)
|
||||
return -1;
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
#ifdef READ_MMAP
|
||||
/*********************************************************+
|
||||
* memory mapped operation
|
||||
*
|
||||
*/
|
||||
static unsigned char *mapbuf;
|
||||
static unsigned char *mappnt;
|
||||
static unsigned char *mapend;
|
||||
|
||||
static int mapped_init(struct reader *rds)
|
||||
{
|
||||
long len;
|
||||
char buf[128];
|
||||
|
||||
len = get_fileinfo(rds,buf);
|
||||
if(len < 0)
|
||||
return -1;
|
||||
|
||||
if(!strncmp(buf,"TAG",3)) {
|
||||
rds->flags |= READER_ID3TAG;
|
||||
memcpy(rds->id3buf,buf,128);
|
||||
}
|
||||
|
||||
mappnt = mapbuf = (unsigned char *)
|
||||
mmap(NULL, len, PROT_READ, MAP_SHARED , rds->filept, 0);
|
||||
if(!mapbuf || mapbuf == MAP_FAILED)
|
||||
return -1;
|
||||
|
||||
mapend = mapbuf + len;
|
||||
|
||||
if(param.verbose > 1)
|
||||
fprintf(stderr,"Using memory mapped IO for this stream.\n");
|
||||
|
||||
rds->filelen = len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mapped_rewind(struct reader *rds)
|
||||
{
|
||||
mappnt = mapbuf;
|
||||
if (param.usebuffer)
|
||||
buffer_resync();
|
||||
}
|
||||
|
||||
static void mapped_close(struct reader *rds)
|
||||
{
|
||||
munmap((void *)mapbuf,mapend-mapbuf);
|
||||
if (rds->flags & READER_FD_OPENED)
|
||||
close(rds->filept);
|
||||
}
|
||||
|
||||
static int mapped_head_read(struct reader *rds,unsigned long *newhead)
|
||||
{
|
||||
unsigned long nh;
|
||||
|
||||
if(mappnt + 4 > mapend)
|
||||
return FALSE;
|
||||
|
||||
nh = (*mappnt++) << 24;
|
||||
nh |= (*mappnt++) << 16;
|
||||
nh |= (*mappnt++) << 8;
|
||||
nh |= (*mappnt++) ;
|
||||
|
||||
*newhead = nh;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int mapped_head_shift(struct reader *rds,unsigned long *head)
|
||||
{
|
||||
if(mappnt + 1 > mapend)
|
||||
return FALSE;
|
||||
*head <<= 8;
|
||||
*head |= *mappnt++;
|
||||
*head &= 0xffffffff;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int mapped_skip_bytes(struct reader *rds,int len)
|
||||
{
|
||||
if(mappnt + len > mapend)
|
||||
return FALSE;
|
||||
mappnt += len;
|
||||
if (param.usebuffer)
|
||||
buffer_resync();
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int mapped_read_frame_body(struct reader *rds,unsigned char *buf,
|
||||
int size)
|
||||
{
|
||||
if(size <= 0) {
|
||||
fprintf(stderr,"Ouch. Read_frame called with size <= 0\n");
|
||||
return FALSE;
|
||||
}
|
||||
if(mappnt + size > mapend)
|
||||
return FALSE;
|
||||
memcpy(buf,mappnt,size);
|
||||
mappnt += size;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int mapped_back_bytes(struct reader *rds,int bytes)
|
||||
{
|
||||
if( (mappnt - bytes) < mapbuf || (mappnt - bytes + 4) > mapend)
|
||||
return -1;
|
||||
mappnt -= bytes;
|
||||
if(param.usebuffer)
|
||||
buffer_resync();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mapped_back_frame(struct reader *rds,struct frame *fr,int num)
|
||||
{
|
||||
long bytes;
|
||||
unsigned long newhead;
|
||||
|
||||
|
||||
if(!firsthead)
|
||||
return 0;
|
||||
|
||||
bytes = (fr->framesize+8)*(num+2);
|
||||
|
||||
/* Buffered mode is a bit trickier. From the size of the buffered
|
||||
* output audio stream we have to make a guess at the number of frames
|
||||
* this corresponds to.
|
||||
*/
|
||||
if(param.usebuffer)
|
||||
bytes += (long)(xfermem_get_usedspace(buffermem) /
|
||||
(buffermem->buf[0] * buffermem->buf[1]
|
||||
* (buffermem->buf[2] & AUDIO_FORMAT_MASK ?
|
||||
16.0 : 8.0 ))
|
||||
* (tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index] << 10));
|
||||
/*
|
||||
bytes += (long)(compute_buffer_offset(fr)*compute_bpf(fr));
|
||||
*/
|
||||
|
||||
if( (mappnt - bytes) < mapbuf || (mappnt - bytes + 4) > mapend)
|
||||
return -1;
|
||||
mappnt -= bytes;
|
||||
|
||||
newhead = (mappnt[0]<<24) + (mappnt[1]<<16) + (mappnt[2]<<8) + mappnt[3];
|
||||
mappnt += 4;
|
||||
|
||||
while( (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK) ) {
|
||||
if(mappnt + 1 > mapend)
|
||||
return -1;
|
||||
newhead <<= 8;
|
||||
newhead |= *mappnt++;
|
||||
newhead &= 0xffffffff;
|
||||
}
|
||||
mappnt -= 4;
|
||||
|
||||
read_frame(fr);
|
||||
read_frame(fr);
|
||||
|
||||
if(fr->lay == 3)
|
||||
set_pointer(512);
|
||||
|
||||
if(param.usebuffer)
|
||||
buffer_resync();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long mapped_tell(struct reader *rds)
|
||||
{
|
||||
return mappnt - mapbuf;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*****************************************************************
|
||||
* read frame helper
|
||||
*/
|
||||
|
||||
struct reader *rd;
|
||||
struct reader readers[] = {
|
||||
#ifdef READ_SYSTEM
|
||||
{ system_init,
|
||||
NULL, /* filled in by system_init() */
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL } ,
|
||||
#endif
|
||||
#ifdef READ_MMAP
|
||||
{ mapped_init,
|
||||
mapped_close,
|
||||
mapped_head_read,
|
||||
mapped_head_shift,
|
||||
mapped_skip_bytes,
|
||||
mapped_read_frame_body,
|
||||
mapped_back_bytes,
|
||||
mapped_back_frame,
|
||||
mapped_tell,
|
||||
mapped_rewind } ,
|
||||
#endif
|
||||
{ default_init,
|
||||
stream_close,
|
||||
stream_head_read,
|
||||
stream_head_shift,
|
||||
stream_skip_bytes,
|
||||
stream_read_frame_body,
|
||||
stream_back_bytes,
|
||||
stream_back_frame,
|
||||
stream_tell,
|
||||
stream_rewind } ,
|
||||
{ NULL, }
|
||||
};
|
||||
|
||||
|
||||
/* open the device to read the bit stream from it */
|
||||
|
||||
struct reader *open_stream(char *bs_filenam,int fd)
|
||||
{
|
||||
int i;
|
||||
int filept_opened = 1;
|
||||
int filept;
|
||||
|
||||
if (!bs_filenam) {
|
||||
if(fd < 0) {
|
||||
filept = 0;
|
||||
filept_opened = 0;
|
||||
}
|
||||
else
|
||||
filept = fd;
|
||||
}
|
||||
else if (!strncmp(bs_filenam, "http://", 7))
|
||||
filept = http_open(bs_filenam);
|
||||
#ifndef O_BINARY
|
||||
#define O_BINARY (0)
|
||||
#endif
|
||||
else if ( (filept = open(bs_filenam, O_RDONLY|O_BINARY)) < 0) {
|
||||
perror (bs_filenam);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
rd = NULL;
|
||||
for(i=0;;i++) {
|
||||
readers[i].filelen = -1;
|
||||
readers[i].filept = filept;
|
||||
readers[i].flags = 0;
|
||||
if(filept_opened)
|
||||
readers[i].flags |= READER_FD_OPENED;
|
||||
if(!readers[i].init) {
|
||||
fprintf(stderr,"Fatal error!\n");
|
||||
exit(1);
|
||||
}
|
||||
if(readers[i].init(readers+i) >= 0) {
|
||||
rd = &readers[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(rd && rd->flags & READER_ID3TAG) {
|
||||
print_id3_tag(rd->id3buf);
|
||||
}
|
||||
|
||||
return rd;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,138 +0,0 @@
|
|||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
static unsigned char *conv16to8_buf = NULL;
|
||||
unsigned char *conv16to8;
|
||||
|
||||
#ifndef USE_MMX
|
||||
real decwin[512+32];
|
||||
static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1];
|
||||
|
||||
real *pnts[] = { cos64,cos32,cos16,cos8,cos4 };
|
||||
|
||||
|
||||
static long intwinbase[] = {
|
||||
0, -1, -1, -1, -1, -1, -1, -2, -2, -2,
|
||||
-2, -3, -3, -4, -4, -5, -5, -6, -7, -7,
|
||||
-8, -9, -10, -11, -13, -14, -16, -17, -19, -21,
|
||||
-24, -26, -29, -31, -35, -38, -41, -45, -49, -53,
|
||||
-58, -63, -68, -73, -79, -85, -91, -97, -104, -111,
|
||||
-117, -125, -132, -139, -147, -154, -161, -169, -176, -183,
|
||||
-190, -196, -202, -208, -213, -218, -222, -225, -227, -228,
|
||||
-228, -227, -224, -221, -215, -208, -200, -189, -177, -163,
|
||||
-146, -127, -106, -83, -57, -29, 2, 36, 72, 111,
|
||||
153, 197, 244, 294, 347, 401, 459, 519, 581, 645,
|
||||
711, 779, 848, 919, 991, 1064, 1137, 1210, 1283, 1356,
|
||||
1428, 1498, 1567, 1634, 1698, 1759, 1817, 1870, 1919, 1962,
|
||||
2001, 2032, 2057, 2075, 2085, 2087, 2080, 2063, 2037, 2000,
|
||||
1952, 1893, 1822, 1739, 1644, 1535, 1414, 1280, 1131, 970,
|
||||
794, 605, 402, 185, -45, -288, -545, -814, -1095, -1388,
|
||||
-1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
|
||||
-5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209,
|
||||
-8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959,
|
||||
-9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092,
|
||||
-7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082,
|
||||
-70, 998, 2122, 3300, 4533, 5818, 7154, 8540, 9975, 11455,
|
||||
12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289,
|
||||
30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617,
|
||||
48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684,
|
||||
64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835,
|
||||
73415, 73908, 74313, 74630, 74856, 74992, 75038 };
|
||||
|
||||
void make_decode_tables(long scaleval)
|
||||
{
|
||||
int i,j,k,kr,divv;
|
||||
real *costab;
|
||||
int idx;
|
||||
|
||||
|
||||
for(i=0;i<5;i++)
|
||||
{
|
||||
kr=0x10>>i; divv=0x40>>i;
|
||||
costab = pnts[i];
|
||||
for(k=0;k<kr;k++)
|
||||
costab[k] = 1.0 / (2.0 * cos(M_PI * ((double) k * 2.0 + 1.0) / (double) divv));
|
||||
|
||||
}
|
||||
|
||||
idx = 0;
|
||||
scaleval = -scaleval;
|
||||
for(i=0,j=0;i<256;i++,j++,idx+=32)
|
||||
{
|
||||
if(idx < 512+16)
|
||||
decwin[idx+16] = decwin[idx] = (double) intwinbase[j] / 65536.0 * (double) scaleval;
|
||||
|
||||
if(i % 32 == 31)
|
||||
idx -= 1023;
|
||||
if(i % 64 == 63)
|
||||
scaleval = - scaleval;
|
||||
}
|
||||
|
||||
for( /* i=256 */ ;i<512;i++,j--,idx+=32)
|
||||
{
|
||||
if(idx < 512+16)
|
||||
decwin[idx+16] = decwin[idx] = (double) intwinbase[j] / 65536.0 * (double) scaleval;
|
||||
|
||||
if(i % 32 == 31)
|
||||
idx -= 1023;
|
||||
if(i % 64 == 63)
|
||||
scaleval = - scaleval;
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
void make_conv16to8_table(int mode)
|
||||
{
|
||||
int i;
|
||||
|
||||
/*
|
||||
* ????: 8.0 is right but on SB cards '2.0' is a better value ???
|
||||
*/
|
||||
const double mul = 8.0;
|
||||
|
||||
if(!conv16to8_buf) {
|
||||
conv16to8_buf = (unsigned char *) malloc(8192);
|
||||
if(!conv16to8_buf) {
|
||||
fprintf(stderr,"Can't allocate 16 to 8 converter table!\n");
|
||||
exit(1);
|
||||
}
|
||||
conv16to8 = conv16to8_buf + 4096;
|
||||
}
|
||||
|
||||
if(mode == AUDIO_FORMAT_ULAW_8) {
|
||||
double m=127.0 / log(256.0);
|
||||
int c1;
|
||||
|
||||
for(i=-4096;i<4096;i++) {
|
||||
/* dunno whether this is a valid transformation rule ?!?!? */
|
||||
if(i < 0)
|
||||
c1 = 127 - (int) (log( 1.0 - 255.0 * (double) i*mul / 32768.0 ) * m);
|
||||
else
|
||||
c1 = 255 - (int) (log( 1.0 + 255.0 * (double) i*mul / 32768.0 ) * m);
|
||||
if(c1 < 0 || c1 > 255)
|
||||
fprintf(stderr,"Converror %d %d\n",i,c1);
|
||||
if(c1 == 0)
|
||||
c1 = 2;
|
||||
conv16to8[i] = (unsigned char) c1;
|
||||
}
|
||||
}
|
||||
else if(mode == AUDIO_FORMAT_SIGNED_8) {
|
||||
for(i=-4096;i<4096;i++) {
|
||||
conv16to8[i] = i>>5;
|
||||
}
|
||||
}
|
||||
else if(mode == AUDIO_FORMAT_UNSIGNED_8) {
|
||||
for(i=-4096;i<4096;i++) {
|
||||
conv16to8[i] = (i>>5)+128;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for(i=-4096;i<4096;i++) {
|
||||
conv16to8[i] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
/*
|
||||
* This checks for the VBR Header defined by Xing(tm)
|
||||
*/
|
||||
|
||||
#include "mpg123.h"
|
||||
|
||||
static unsigned long get32bits(unsigned char *buf) {
|
||||
unsigned long ret = 0;
|
||||
|
||||
ret = (((unsigned long) buf[0]) << 24) |
|
||||
(((unsigned long) buf[1]) << 16) |
|
||||
(((unsigned long) buf[2]) << 8) |
|
||||
((unsigned long) buf[3]) ;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int getVBRHeader(struct vbrHeader *head,unsigned char *buf, struct frame *fr)
|
||||
{
|
||||
int ssize;
|
||||
|
||||
if(fr->lay != 3)
|
||||
return 0;
|
||||
|
||||
if(fr->lsf)
|
||||
ssize = (fr->stereo == 1) ? 9 : 17;
|
||||
else
|
||||
ssize = (fr->stereo == 1) ? 17 : 32;
|
||||
|
||||
|
||||
buf += ssize;
|
||||
|
||||
if(( buf[0] != 'X' ) || ( buf[1] != 'i' ) ||
|
||||
( buf[2] != 'n' ) || ( buf[3] != 'g' ) )
|
||||
return 0;
|
||||
buf+=4;
|
||||
|
||||
head->flags = get32bits(buf);
|
||||
buf+=4;
|
||||
|
||||
if(head->flags & VBR_FRAMES_FLAG) {
|
||||
head->frames = get32bits(buf);
|
||||
buf += 4;
|
||||
}
|
||||
|
||||
if(head->flags & VBR_BYTES_FLAG) {
|
||||
head->bytes = get32bits(buf);
|
||||
buf += 4;
|
||||
}
|
||||
|
||||
if(head->flags & VBR_TOC_FLAG) {
|
||||
memcpy(head->toc,buf,100);
|
||||
buf += 100;
|
||||
}
|
||||
|
||||
if(head->flags & VBR_SCALE_FLAG) {
|
||||
head->scale = get32bits(buf);
|
||||
buf += 4;
|
||||
}
|
||||
|
||||
/* fprintf(stderr,"Found XING %04lx\n",head->flags); */
|
||||
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,287 +0,0 @@
|
|||
/*
|
||||
* xfermem.c
|
||||
*
|
||||
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de>
|
||||
* Sun Apr 6 02:26:26 MET DST 1997
|
||||
*
|
||||
* See xfermem.h for documentation/description.
|
||||
*/
|
||||
|
||||
#ifndef NOXFERMEM
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/socket.h>
|
||||
#include <fcntl.h>
|
||||
#ifdef WIN32
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#ifdef AIX
|
||||
#include <sys/select.h>
|
||||
#endif
|
||||
|
||||
#include "mpg123.h"
|
||||
#define HAVE_INCLUDED_MPG123_H
|
||||
|
||||
#ifndef USE_MMAP
|
||||
#include <sys/ipc.h>
|
||||
#include <sys/shm.h>
|
||||
#endif
|
||||
|
||||
extern int errno;
|
||||
|
||||
#if defined (USE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
|
||||
#define MAP_ANON MAP_ANONYMOUS
|
||||
#endif
|
||||
|
||||
void xfermem_init (txfermem **xf, int bufsize, int msize, int skipbuf)
|
||||
{
|
||||
int regsize = bufsize + msize + skipbuf + sizeof(txfermem);
|
||||
extern int preload;
|
||||
|
||||
#ifdef USE_MMAP
|
||||
# ifdef MAP_ANON
|
||||
if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
|
||||
MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) {
|
||||
perror ("mmap()");
|
||||
exit (1);
|
||||
}
|
||||
# else
|
||||
int devzero;
|
||||
if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) {
|
||||
perror ("open(/dev/zero)");
|
||||
exit (1);
|
||||
}
|
||||
if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, devzero, 0)) == (txfermem *) -1) {
|
||||
perror ("mmap()");
|
||||
exit (1);
|
||||
}
|
||||
close (devzero);
|
||||
# endif
|
||||
#else
|
||||
struct shmid_ds shmemds;
|
||||
int shmemid;
|
||||
if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) {
|
||||
perror ("shmget()");
|
||||
exit (1);
|
||||
}
|
||||
if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) {
|
||||
perror ("shmat()");
|
||||
shmctl (shmemid, IPC_RMID, &shmemds);
|
||||
exit (1);
|
||||
}
|
||||
if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) {
|
||||
perror ("shmctl()");
|
||||
xfermem_done (*xf);
|
||||
exit (1);
|
||||
}
|
||||
#endif
|
||||
if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) {
|
||||
perror ("socketpair()");
|
||||
xfermem_done (*xf);
|
||||
exit (1);
|
||||
}
|
||||
(*xf)->freeindex = (*xf)->readindex = 0;
|
||||
(*xf)->wakeme[0] = (*xf)->wakeme[1] = FALSE;
|
||||
(*xf)->data = ((byte *) *xf) + sizeof(txfermem) + msize;
|
||||
(*xf)->metadata = ((byte *) *xf) + sizeof(txfermem);
|
||||
(*xf)->size = bufsize;
|
||||
(*xf)->metasize = msize + skipbuf;
|
||||
preload = bufsize>>3;
|
||||
}
|
||||
|
||||
void xfermem_done (txfermem *xf)
|
||||
{
|
||||
if(!xf)
|
||||
return;
|
||||
#ifdef USE_MMAP
|
||||
munmap ((caddr_t) xf, xf->size + xf->metasize + sizeof(txfermem));
|
||||
#else
|
||||
if (shmdt((void *) xf) == -1) {
|
||||
perror ("shmdt()");
|
||||
exit (1);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void xfermem_init_writer (txfermem *xf)
|
||||
{
|
||||
if(xf)
|
||||
close (xf->fd[XF_READER]);
|
||||
}
|
||||
|
||||
void xfermem_init_reader (txfermem *xf)
|
||||
{
|
||||
if(xf)
|
||||
close (xf->fd[XF_WRITER]);
|
||||
}
|
||||
|
||||
int xfermem_get_freespace (txfermem *xf)
|
||||
{
|
||||
int freeindex, readindex;
|
||||
|
||||
if(!xf)
|
||||
return 0;
|
||||
|
||||
if ((freeindex = xf->freeindex) < 0
|
||||
|| (readindex = xf->readindex) < 0)
|
||||
return (0);
|
||||
if (readindex > freeindex)
|
||||
return ((readindex - freeindex) - 1);
|
||||
else
|
||||
return ((xf->size - (freeindex - readindex)) - 1);
|
||||
}
|
||||
|
||||
int xfermem_get_usedspace (txfermem *xf)
|
||||
{
|
||||
int freeindex, readindex;
|
||||
|
||||
if(!xf)
|
||||
return 0;
|
||||
|
||||
if ((freeindex = xf->freeindex) < 0
|
||||
|| (readindex = xf->readindex) < 0)
|
||||
return (0);
|
||||
if (freeindex >= readindex)
|
||||
return (freeindex - readindex);
|
||||
else
|
||||
return (xf->size - (readindex - freeindex));
|
||||
}
|
||||
|
||||
int xfermem_getcmd (int fd, int block)
|
||||
{
|
||||
fd_set selfds;
|
||||
byte cmd;
|
||||
|
||||
for (;;) {
|
||||
struct timeval selto = {0, 0};
|
||||
|
||||
FD_ZERO (&selfds);
|
||||
FD_SET (fd, &selfds);
|
||||
/* #ifdef HPUX */ /* seems to trigger performance problems? strange */
|
||||
#if 0
|
||||
switch (select(FD_SETSIZE, (int *) &selfds, NULL, NULL, block ? NULL : &selto)) {
|
||||
#else
|
||||
switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto)) {
|
||||
#endif
|
||||
case 0:
|
||||
if (!block)
|
||||
return (0);
|
||||
continue;
|
||||
case -1:
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
return (-2);
|
||||
case 1:
|
||||
if (FD_ISSET(fd, &selfds))
|
||||
switch (read(fd, &cmd, 1)) {
|
||||
case 0: /* EOF */
|
||||
return (-1);
|
||||
case -1:
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
return (-3);
|
||||
case 1:
|
||||
return (cmd);
|
||||
default: /* ?!? */
|
||||
return (-4);
|
||||
}
|
||||
else /* ?!? */
|
||||
return (-5);
|
||||
default: /* ?!? */
|
||||
return (-6);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int xfermem_putcmd (int fd, byte cmd)
|
||||
{
|
||||
for (;;) {
|
||||
switch (write(fd, &cmd, 1)) {
|
||||
case 1:
|
||||
return (1);
|
||||
case -1:
|
||||
if (errno != EINTR)
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int xfermem_block (int readwrite, txfermem *xf)
|
||||
{
|
||||
int myfd = xf->fd[readwrite];
|
||||
int result;
|
||||
|
||||
xf->wakeme[readwrite] = TRUE;
|
||||
if (xf->wakeme[1 - readwrite])
|
||||
xfermem_putcmd (myfd, XF_CMD_WAKEUP);
|
||||
result = xfermem_getcmd(myfd, TRUE);
|
||||
xf->wakeme[readwrite] = FALSE;
|
||||
return ((result <= 0) ? -1 : result);
|
||||
}
|
||||
|
||||
#elif defined(WIN32)
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifndef HAVE_INCLUDED_MPG123_H
|
||||
#include "mpg123.h"
|
||||
#else /* HAVE_INCLUDED_MPG123_H */
|
||||
#include "xfermem.h"
|
||||
#endif /* HAVE_INCLUDED_MPG123_H */
|
||||
|
||||
extern int errno;
|
||||
|
||||
void xfermem_init (txfermem **xf, int bufsize, int msize, int skipbuf)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void xfermem_done (txfermem *xf)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void xfermem_init_writer (txfermem *xf)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void xfermem_init_reader (txfermem *xf)
|
||||
{
|
||||
return;
|
||||
}
|
||||
int xfermem_get_freespace (txfermem *xf)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int xfermem_get_usedspace (txfermem *xf)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int xfermem_getcmd (int fd, int block)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int xfermem_putcmd (int fd, byte cmd)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int xfermem_block (int readwrite, txfermem *xf)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* eof */
|
||||
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
/*
|
||||
* xfermem.h
|
||||
*
|
||||
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de>
|
||||
* Sat Mar 29 04:41:34 MET 1997
|
||||
*
|
||||
* This is a stand-alone module which implements a unidirectional,
|
||||
* fast pipe using mmap(). Its primary use is to transfer large
|
||||
* amounts of data from a parent process to its child process,
|
||||
* with a buffer in between which decouples blocking conditions
|
||||
* on both sides. Control information is transferred between the
|
||||
* processes through a socketpair. See xftest.c for an example on
|
||||
* how to use this module.
|
||||
*/
|
||||
|
||||
#ifndef TRUE
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
int freeindex; /* [W] next free index */
|
||||
int readindex; /* [R] next index to read */
|
||||
int fd[2];
|
||||
int wakeme[2];
|
||||
byte *data;
|
||||
byte *metadata;
|
||||
int size;
|
||||
int metasize;
|
||||
int buf[3];
|
||||
} txfermem;
|
||||
/*
|
||||
* [W] -- May be written to by the writing process only!
|
||||
* [R] -- May be written to by the reading process only!
|
||||
* All other entries are initialized once.
|
||||
*/
|
||||
|
||||
void xfermem_init (txfermem **xf, int bufsize, int msize,int skipbuf);
|
||||
void xfermem_init_writer (txfermem *xf);
|
||||
void xfermem_init_reader (txfermem *xf);
|
||||
|
||||
int xfermem_write (txfermem *xf, byte *data, int count);
|
||||
int xfermem_read (txfermem *xf, byte *data, int count);
|
||||
|
||||
int xfermem_get_freespace (txfermem *xf);
|
||||
int xfermem_get_usedspace (txfermem *xf);
|
||||
#define XF_CMD_WAKEUP_INFO 0x04
|
||||
#define XF_CMD_WAKEUP 0x02
|
||||
#define XF_CMD_TERMINATE 0x03
|
||||
#define XF_WRITER 0
|
||||
#define XF_READER 1
|
||||
int xfermem_getcmd (int fd, int block);
|
||||
int xfermem_putcmd (int fd, byte cmd);
|
||||
int xfermem_block (int fd, txfermem *xf);
|
||||
|
||||
void xfermem_done (txfermem *xf);
|
||||
#define xfermem_done_writer xfermem_init_reader
|
||||
#define xfermem_done_reader xfermem_init_writer
|
||||
|
||||
/* EOF */
|
||||
Loading…
Reference in New Issue