seal 0.1.0

data/mpg123/src/libmpg123/sample.h

@@ -0,0 +1,152 @@
+/*
+	sample.h: The conversion from internal data to output samples of differing formats.
+
+	copyright 2007-9 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Thomas Orgis, taking WRITE_SAMPLE from decode.c
+	Later added the end-conversion specific macros here, too.
+*/
+
+#ifndef SAMPLE_H
+#define SAMPLE_H
+
+/* mpg123lib_intern.h is included already, right? */
+
+/* Special case is fixed point math... which does work, but not that nice yet.  */
+#ifdef REAL_IS_FIXED
+static inline short idiv_signed_rounded(long x, int shift)
+{
+	x >>= (shift - 1);
+	x += (x & 1);
+	return (short)(x >> 1);
+}
+#  define REAL_PLUS_32767       ( 32767 << 15 )
+#  define REAL_MINUS_32768      ( -32768 << 15 )
+#  define REAL_TO_SHORT(x)      (idiv_signed_rounded(x, 15))
+/* No better code (yet).  */
+#  define REAL_TO_SHORT_ACCURATE(x) REAL_TO_SHORT(x)
+/* This is just here for completeness, it is not used! */
+# define REAL_TO_S32(x)        (x)
+#endif
+
+/* From now on for single precision float... double precision is a possible option once we added some bits. But, it would be rather insane. */
+#ifndef REAL_TO_SHORT
+
+/* Define the accurate rounding function. */
+# if (defined REAL_IS_FLOAT) && (defined IEEE_FLOAT)
+/* This function is only available for IEEE754 single-precision values
+   This is nearly identical to proper rounding, just -+0.5 is rounded to 0 */
+static inline short ftoi16(float x)
+{
+	union
+	{
+		float f;
+		int32_t i;
+	} u_fi;
+	u_fi.f = x + 12582912.0f; /* Magic Number: 2^23 + 2^22 */
+	return (short)u_fi.i;
+}
+#  define REAL_TO_SHORT_ACCURATE(x)      ftoi16(x)
+# else
+/* The "proper" rounding, plain C, a bit slow. */
+#  define REAL_TO_SHORT_ACCURATE(x)      (short)((x)>0.0?(x)+0.5:(x)-0.5)
+# endif
+
+/* Now define the normal rounding. */
+# ifdef ACCURATE_ROUNDING
+#  define REAL_TO_SHORT(x)      REAL_TO_SHORT_ACCURATE(x)
+# else
+/* Non-accurate rounding... simple truncation. Fastest, most LSB errors. */
+#  define REAL_TO_SHORT(x)      (short)(x)
+# endif
+
+#endif /* REAL_TO_SHORT */
+
+/* We should add dithering for S32, too? */
+#ifndef REAL_TO_S32
+# ifdef ACCURATE_ROUNDING
+#  define REAL_TO_S32(x) (int32_t)((x)>0.0?(x)+0.5:(x)-0.5)
+# else
+#  define REAL_TO_S32(x) (int32_t)(x)
+# endif
+#endif
+
+#ifndef REAL_PLUS_32767
+# define REAL_PLUS_32767 32767.0
+#endif
+#ifndef REAL_MINUS_32768
+# define REAL_MINUS_32768 -32768.0
+#endif
+#ifndef REAL_PLUS_S32
+# define REAL_PLUS_S32 2147483647.0
+#endif
+#ifndef REAL_MINUS_S32
+# define REAL_MINUS_S32 -2147483648.0
+#endif
+
+
+/* The actual storage of a decoded sample is separated in the following macros.
+   We can handle different types, we could also handle dithering here. */
+
+#ifdef NEWOLD_WRITE_SAMPLE
+
+/* This is the old new mpg123 WRITE_SAMPLE, fixed for newer GCC by MPlayer folks.
+   Makes a huge difference on old machines. */
+#if WORDS_BIGENDIAN 
+#define MANTISSA_OFFSET 1
+#else
+#define MANTISSA_OFFSET 0
+#endif
+#define WRITE_SHORT_SAMPLE(samples,sum,clip) { \
+  union { double dtemp; int itemp[2]; } u; int v; \
+  u.dtemp = ((((65536.0 * 65536.0 * 16)+(65536.0 * 0.5))* 65536.0)) + (sum);\
+  v = u.itemp[MANTISSA_OFFSET] - 0x80000000; \
+  if( v > 32767) { *(samples) = 0x7fff; (clip)++; } \
+  else if( v < -32768) { *(samples) = -0x8000; (clip)++; } \
+  else { *(samples) = v; }  \
+}
+
+#else
+/* Macro to produce a short (signed 16bit) output sample from internal representation,
+   which may be float, double or indeed some integer for fixed point handling. */
+#define WRITE_SHORT_SAMPLE(samples,sum,clip) \
+  if( (sum) > REAL_PLUS_32767) { *(samples) = 0x7fff; (clip)++; } \
+  else if( (sum) < REAL_MINUS_32768) { *(samples) = -0x8000; (clip)++; } \
+  else { *(samples) = REAL_TO_SHORT(sum); }
+#endif
+
+/* Same as above, but always using accurate rounding. Would we want softer clipping here, too? */
+#define WRITE_SHORT_SAMPLE_ACCURATE(samples,sum,clip) \
+  if( (sum) > REAL_PLUS_32767) { *(samples) = 0x7fff; (clip)++; } \
+  else if( (sum) < REAL_MINUS_32768) { *(samples) = -0x8000; (clip)++; } \
+  else { *(samples) = REAL_TO_SHORT_ACCURATE(sum); }
+
+/*
+	32bit signed 
+	We do clipping with the same old borders... but different conversion.
+	We see here that we need extra work for non-16bit output... we optimized for 16bit.
+	-0x7fffffff-1 is the minimum 32 bit signed integer value expressed so that MSVC 
+	does not give a compile time warning.
+*/
+#define WRITE_S32_SAMPLE(samples,sum,clip) \
+	{ \
+		real tmpsum = REAL_MUL((sum),S32_RESCALE); \
+		if( tmpsum > REAL_PLUS_S32 ){ *(samples) = 0x7fffffff; (clip)++; } \
+		else if( tmpsum < REAL_MINUS_S32 ) { *(samples) = -0x7fffffff-1; (clip)++; } \
+		else { *(samples) = REAL_TO_S32(tmpsum); } \
+	}
+
+/* Produce an 8bit sample, via 16bit intermediate. */
+#define WRITE_8BIT_SAMPLE(samples,sum,clip) \
+{ \
+	short write_8bit_tmp; \
+	if( (sum) > REAL_PLUS_32767) { write_8bit_tmp = 0x7fff; (clip)++; } \
+	else if( (sum) < REAL_MINUS_32768) { write_8bit_tmp = -0x8000; (clip)++; } \
+	else { write_8bit_tmp = REAL_TO_SHORT(sum); } \
+	*(samples) = fr->conv16to8[write_8bit_tmp>>AUSHIFT]; \
+}
+#ifndef REAL_IS_FIXED
+#define WRITE_REAL_SAMPLE(samples,sum,clip) *(samples) = ((real)1./SHORT_SCALE)*(sum)
+#endif
+
+#endif

data/mpg123/src/libmpg123/stringbuf.c

@@ -0,0 +1,163 @@
+/*
+	stringbuf: mimicking a bit of C++ to more safely handle strings
+
+	copyright 2006-10 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Thomas Orgis
+*/
+
+#include "mpg123lib_intern.h"
+#include "config.h"
+#include "mpg123.h"
+#include "compat.h"
+#include <string.h>
+#include "debug.h"
+
+void attribute_align_arg mpg123_init_string(mpg123_string* sb)
+{
+	sb->p = NULL;
+	sb->size = 0;
+	sb->fill = 0;
+}
+
+void attribute_align_arg mpg123_free_string(mpg123_string* sb)
+{
+	if(sb->p != NULL) free(sb->p);
+	mpg123_init_string(sb);
+}
+
+int attribute_align_arg mpg123_grow_string(mpg123_string* sb, size_t new)
+{
+	if(sb->size < new) return mpg123_resize_string(sb, new);
+	else return 1;
+}
+
+int attribute_align_arg mpg123_resize_string(mpg123_string* sb, size_t new)
+{
+	debug3("resizing string pointer %p from %lu to %lu", (void*) sb->p, (unsigned long)sb->size, (unsigned long)new);
+	if(new == 0)
+	{
+		if(sb->size && sb->p != NULL) free(sb->p);
+		mpg123_init_string(sb);
+		return 1;
+	}
+	if(sb->size != new)
+	{
+		char* t;
+		debug("really!");
+		t = (char*) safe_realloc(sb->p, new*sizeof(char));
+		debug1("safe_realloc returned %p", (void*) t); 
+		if(t != NULL)
+		{
+			sb->p = t;
+			sb->size = new;
+			return 1;
+		}
+		else return 0;
+	}
+	else return 1; /* success */
+}
+
+int attribute_align_arg mpg123_copy_string(mpg123_string* from, mpg123_string* to)
+{
+	size_t fill;
+	char  *text;
+	if(to == NULL) return -1;
+
+	debug2("called copy_string with %p -> %p", (void*)from, (void*)to);
+	if(from == NULL)
+	{
+		fill = 0;
+		text = NULL;
+	}
+	else
+	{
+		fill = from->fill;
+		text = from->p;
+	}
+
+	if(mpg123_resize_string(to, fill))
+	{
+		memcpy(to->p, text, fill);
+		to->fill = fill;
+		return 1;
+	}
+	else return 0;
+}
+
+int attribute_align_arg mpg123_add_string(mpg123_string* sb, const char* stuff)
+{
+	debug1("adding %s", stuff);
+	return mpg123_add_substring(sb, stuff, 0, strlen(stuff));
+}
+
+int attribute_align_arg mpg123_add_substring(mpg123_string *sb, const char *stuff, size_t from, size_t count)
+{
+	debug("adding a substring");
+	if(sb->fill) /* includes zero byte... */
+	{
+		if( (SIZE_MAX - sb->fill >= count) /* Avoid overflow. */
+		    && (sb->size >= sb->fill+count || mpg123_grow_string(sb, sb->fill+count)) )
+		{
+			memcpy(sb->p+sb->fill-1, stuff+from, count);
+			sb->fill += count;
+			sb->p[sb->fill-1] = 0; /* Terminate! */
+		}
+		else return 0;
+	}
+	else
+	{
+		if( count < SIZE_MAX && mpg123_grow_string(sb, count+1) )
+		{
+			memcpy(sb->p, stuff+from, count);
+			sb->fill = count+1;
+			sb->p[sb->fill-1] = 0; /* Terminate! */
+		}
+		else return 0;
+	}
+	return 1;
+}
+
+int attribute_align_arg mpg123_set_substring(mpg123_string* sb, const char* stuff, size_t from, size_t count)
+{
+	sb->fill = 0;
+	return mpg123_add_substring(sb, stuff, from, count);
+}
+
+int attribute_align_arg mpg123_set_string(mpg123_string* sb, const char* stuff)
+{
+	sb->fill = 0;
+	return mpg123_add_string(sb, stuff);
+}
+
+size_t attribute_align_arg mpg123_strlen(mpg123_string *sb, int utf8)
+{
+	size_t i;
+	size_t bytelen;
+
+	/* Notions of empty string. If there's only a single character, it has to be the trailing zero, and if the first is the trailing zero anyway, we got empty. */
+	if(sb->fill < 2 || sb->p[0] == 0) return 0;
+
+	/* Find the first non-null character from the back.
+	   We already established that the first character is non-null
+	   That at fill-2 has to be null, though. */
+	for(i=sb->fill-2; i>0; --i)
+	if(sb->p[i] != 0) break;
+
+	/* For simple byte strings, we are done now. */
+	bytelen = i+1;
+
+	if(!utf8) return bytelen;
+	else
+	{
+		/* Work out the actual count of UTF8 bytes.
+		   This employs no particular encoding error checking. */
+		size_t len = 0;
+		for(i=0; i<bytelen; ++i)
+		{
+			/* Every byte that is not a continuation byte ( 0xc0 == 10xx xxxx ) stands for a character. */
+			if((sb->p[i] & 0xc0) != 0x80) len++;
+		}
+		return len;
+	}
+}

data/mpg123/src/libmpg123/synth.c

@@ -0,0 +1,816 @@
+/*
+	synth.c: The functions for synthesizing samples, at the end of decoding.
+
+	copyright 1995-2008 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Michael Hipp, heavily dissected and rearranged by Thomas Orgis
+*/
+
+#include "mpg123lib_intern.h"
+#include "sample.h"
+#include "debug.h"
+
+/*
+	Part 1: All synth functions that produce signed short.
+	That is:
+		- synth_1to1 with cpu-specific variants (synth_1to1_i386, synth_1to1_i586 ...)
+		- synth_1to1_mono and synth_1to1_m2s; which use fr->synths.plain[r_1to1][f_16].
+	Nearly every decoder variant has it's own synth_1to1, while the mono conversion is shared.
+*/
+
+#define SAMPLE_T short
+#define WRITE_SAMPLE(samples,sum,clip) WRITE_SHORT_SAMPLE(samples,sum,clip)
+
+/* Part 1a: All straight 1to1 decoding functions */
+#define BLOCK 0x40 /* One decoding block is 64 samples. */
+
+#define SYNTH_NAME synth_1to1
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_1to1. */
+#define SYNTH_NAME       fr->synths.plain[r_1to1][f_16]
+#define MONO_NAME        synth_1to1_mono
+#define MONO2STEREO_NAME synth_1to1_m2s
+#include "synth_mono.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+/* Now we have possibly some special synth_1to1 ...
+   ... they produce signed short; the mono functions defined above work on the special synths, too. */
+
+#ifdef OPT_GENERIC_DITHER
+#define SYNTH_NAME synth_1to1_dither
+/* We need the accurate sample writing... */
+#undef WRITE_SAMPLE
+#define WRITE_SAMPLE(samples,sum,clip) WRITE_SHORT_SAMPLE_ACCURATE(samples,sum,clip)
+
+#define USE_DITHER
+#include "synth.h"
+#undef USE_DITHER
+#undef SYNTH_NAME
+
+#undef WRITE_SAMPLE
+#define WRITE_SAMPLE(samples,sum,clip) WRITE_SHORT_SAMPLE(samples,sum,clip)
+
+#endif
+
+#ifdef OPT_X86
+/* The i386-specific C code, here as short variant, later 8bit and float. */
+#define NO_AUTOINCREMENT
+#define SYNTH_NAME synth_1to1_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK /* Following functions are so special that they don't need this. */
+
+#ifdef OPT_I586
+/* This is defined in assembler. */
+int synth_1to1_i586_asm(real *bandPtr, int channel, unsigned char *out, unsigned char *buffs, int *bo, real *decwin);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_i586(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	int ret;
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	ret = synth_1to1_i586_asm(bandPtr, channel, fr->buffer.data+fr->buffer.fill, fr->rawbuffs, &fr->bo, fr->decwin);
+	if(final) fr->buffer.fill += 128;
+	return ret;
+}
+#endif
+
+#ifdef OPT_I586_DITHER
+/* This is defined in assembler. */
+int synth_1to1_i586_asm_dither(real *bandPtr, int channel, unsigned char *out, unsigned char *buffs, int *bo, real *decwin, float *dithernoise);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_i586_dither(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	int ret;
+	int bo_dither[2]; /* Temporary workaround? Could expand the asm code. */
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	/* Applying this hack, to change the asm only bit by bit (adding dithernoise pointer). */
+	bo_dither[0] = fr->bo;
+	bo_dither[1] = fr->ditherindex;
+	ret = synth_1to1_i586_asm_dither(bandPtr, channel, fr->buffer.data+fr->buffer.fill, fr->rawbuffs, bo_dither, fr->decwin, fr->dithernoise);
+	fr->bo          = bo_dither[0];
+	fr->ditherindex = bo_dither[1];
+
+	if(final) fr->buffer.fill += 128;
+	return ret;
+}
+#endif
+
+#ifdef OPT_3DNOW
+/* Those are defined in assembler. */
+void do_equalizer_3dnow(real *bandPtr,int channel, real equalizer[2][32]);
+int synth_1to1_3dnow_asm(real *bandPtr, int channel, unsigned char *out, unsigned char *buffs, int *bo, real *decwin);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_3dnow(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	int ret;
+
+	if(fr->have_eq_settings) do_equalizer_3dnow(bandPtr,channel,fr->equalizer);
+
+	/* this is in asm, can be dither or not */
+	/* uh, is this return from pointer correct? */ 
+	ret = (int) synth_1to1_3dnow_asm(bandPtr, channel, fr->buffer.data+fr->buffer.fill, fr->rawbuffs, &fr->bo, fr->decwin);
+	if(final) fr->buffer.fill += 128;
+	return ret;
+}
+#endif
+
+#ifdef OPT_MMX
+/* This is defined in assembler. */
+int synth_1to1_MMX(real *bandPtr, int channel, short *out, short *buffs, int *bo, float *decwins);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_mmx(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	/* in asm */
+	synth_1to1_MMX(bandPtr, channel, (short*) (fr->buffer.data+fr->buffer.fill), (short *) fr->rawbuffs, &fr->bo, fr->decwins);
+	if(final) fr->buffer.fill += 128;
+	return 0;
+}
+#endif
+
+#ifdef OPT_SSE
+#ifdef ACCURATE_ROUNDING
+/* This is defined in assembler. */
+int synth_1to1_sse_accurate_asm(real *window, real *b0, short *samples, int bo1);
+int synth_1to1_s_sse_accurate_asm(real *window, real *b0l, real *b0r, short *samples, int bo1);
+void dct64_real_sse(real *out0, real *out1, real *samples);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_sse(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);	
+	real *b0, **buf;
+	int clip; 
+	int bo1;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+
+	if(fr->bo & 0x1) 
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64_real_sse(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64_real_sse(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_sse_accurate_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+
+int synth_1to1_stereo_sse(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings)
+	{
+		do_equalizer(bandPtr_l,0,fr->equalizer);
+		do_equalizer(bandPtr_r,1,fr->equalizer);
+	}
+
+	fr->bo--;
+	fr->bo &= 0xf;
+	bufl = fr->real_buffs[0];
+	bufr = fr->real_buffs[1];
+
+	if(fr->bo & 0x1)
+	{
+		b0l = bufl[0];
+		b0r = bufr[0];
+		bo1 = fr->bo;
+		dct64_real_sse(bufl[1]+((fr->bo+1)&0xf),bufl[0]+fr->bo,bandPtr_l);
+		dct64_real_sse(bufr[1]+((fr->bo+1)&0xf),bufr[0]+fr->bo,bandPtr_r);
+	}
+	else
+	{
+		b0l = bufl[1];
+		b0r = bufr[1];
+		bo1 = fr->bo+1;
+		dct64_real_sse(bufl[0]+fr->bo,bufl[1]+fr->bo+1,bandPtr_l);
+		dct64_real_sse(bufr[0]+fr->bo,bufr[1]+fr->bo+1,bandPtr_r);
+	}
+
+	clip = synth_1to1_s_sse_accurate_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 128;
+
+	return clip;
+}
+#else
+/* This is defined in assembler. */
+void synth_1to1_sse_asm(real *bandPtr, int channel, short *samples, short *buffs, int *bo, real *decwin);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_sse(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	synth_1to1_sse_asm(bandPtr, channel, (short*) (fr->buffer.data+fr->buffer.fill), (short *) fr->rawbuffs, &fr->bo, fr->decwins);
+	if(final) fr->buffer.fill += 128;
+	return 0;
+}
+#endif
+#endif
+
+#ifdef OPT_3DNOWEXT
+/* This is defined in assembler. */
+void synth_1to1_3dnowext_asm(real *bandPtr, int channel, short *samples, short *buffs, int *bo, real *decwin);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_3dnowext(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	synth_1to1_3dnowext_asm(bandPtr, channel, (short*) (fr->buffer.data+fr->buffer.fill), (short *) fr->rawbuffs, &fr->bo, fr->decwins);
+	if(final) fr->buffer.fill += 128;
+	return 0;
+}
+#endif
+
+#ifdef OPT_X86_64
+#ifdef ACCURATE_ROUNDING
+/* Assembler routines. */
+int synth_1to1_x86_64_accurate_asm(real *window, real *b0, short *samples, int bo1);
+int synth_1to1_s_x86_64_accurate_asm(real *window, real *b0l, real *b0r, short *samples, int bo1);
+void dct64_real_x86_64(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_x86_64(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+
+	if(fr->bo & 0x1)
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64_real_x86_64(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64_real_x86_64(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_x86_64_accurate_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+
+int synth_1to1_stereo_x86_64(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings)
+	{
+		do_equalizer(bandPtr_l,0,fr->equalizer);
+		do_equalizer(bandPtr_r,1,fr->equalizer);
+	}
+
+	fr->bo--;
+	fr->bo &= 0xf;
+	bufl = fr->real_buffs[0];
+	bufr = fr->real_buffs[1];
+
+	if(fr->bo & 0x1)
+	{
+		b0l = bufl[0];
+		b0r = bufr[0];
+		bo1 = fr->bo;
+		dct64_real_x86_64(bufl[1]+((fr->bo+1)&0xf),bufl[0]+fr->bo,bandPtr_l);
+		dct64_real_x86_64(bufr[1]+((fr->bo+1)&0xf),bufr[0]+fr->bo,bandPtr_r);
+	}
+	else
+	{
+		b0l = bufl[1];
+		b0r = bufr[1];
+		bo1 = fr->bo+1;
+		dct64_real_x86_64(bufl[0]+fr->bo,bufl[1]+fr->bo+1,bandPtr_l);
+		dct64_real_x86_64(bufr[0]+fr->bo,bufr[1]+fr->bo+1,bandPtr_r);
+	}
+
+	clip = synth_1to1_s_x86_64_accurate_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 128;
+
+	return clip;
+}
+#else
+/* This is defined in assembler. */
+int synth_1to1_x86_64_asm(short *window, short *b0, short *samples, int bo1);
+int synth_1to1_s_x86_64_asm(short *window, short *b0l, short *b0r, short *samples, int bo1);
+void dct64_x86_64(short *out0, short *out1, real *samples);
+/* This is just a hull to use the mpg123 handle. */
+int synth_1to1_x86_64(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);	
+	short *b0, **buf;
+	int clip; 
+	int bo1;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->short_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->short_buffs[1];
+	}
+
+	if(fr->bo & 0x1) 
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64_x86_64(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64_x86_64(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_x86_64_asm((short *)fr->decwins, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+
+int synth_1to1_stereo_x86_64(real *bandPtr_l,real *bandPtr_r, mpg123_handle *fr)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+	short *b0l, *b0r, **bufl, **bufr;
+	int clip; 
+	int bo1;
+
+	if(fr->have_eq_settings)
+	{
+		do_equalizer(bandPtr_l,0,fr->equalizer);
+		do_equalizer(bandPtr_r,1,fr->equalizer);
+	}
+
+	fr->bo--;
+	fr->bo &= 0xf;
+	bufl = fr->short_buffs[0];
+	bufr = fr->short_buffs[1];
+
+	if(fr->bo & 0x1) 
+	{
+		b0l = bufl[0];
+		b0r = bufr[0];
+		bo1 = fr->bo;
+		dct64_x86_64(bufl[1]+((fr->bo+1)&0xf),bufl[0]+fr->bo,bandPtr_l);
+		dct64_x86_64(bufr[1]+((fr->bo+1)&0xf),bufr[0]+fr->bo,bandPtr_r);
+	}
+	else
+	{
+		b0l = bufl[1];
+		b0r = bufr[1];
+		bo1 = fr->bo+1;
+		dct64_x86_64(bufl[0]+fr->bo,bufl[1]+fr->bo+1,bandPtr_l);
+		dct64_x86_64(bufr[0]+fr->bo,bufr[1]+fr->bo+1,bandPtr_r);
+	}
+
+	clip = synth_1to1_s_x86_64_asm((short *)fr->decwins, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 128;
+
+	return clip;
+}
+#endif
+#endif
+
+#ifdef OPT_ARM
+#ifdef ACCURATE_ROUNDING
+/* Assembler routines. */
+int synth_1to1_arm_accurate_asm(real *window, real *b0, short *samples, int bo1);
+/* Hull for C mpg123 API */
+int synth_1to1_arm(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+
+	if(fr->bo & 0x1)
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_arm_accurate_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+#else
+/* Assembler routines. */
+int synth_1to1_arm_asm(real *window, real *b0, short *samples, int bo1);
+/* Hull for C mpg123 API */
+int synth_1to1_arm(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+
+	if(fr->bo & 0x1)
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_arm_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+#endif
+#endif
+
+#ifdef OPT_NEON
+#ifdef ACCURATE_ROUNDING
+/* This is defined in assembler. */
+int synth_1to1_neon_accurate_asm(real *window, real *b0, short *samples, int bo1);
+int synth_1to1_s_neon_accurate_asm(real *window, real *b0l, real *b0r, short *samples, int bo1);
+void dct64_real_neon(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_neon(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+
+	if(fr->bo & 0x1)
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64_real_neon(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64_real_neon(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_neon_accurate_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+
+int synth_1to1_stereo_neon(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	int bo1;
+	int clip;
+
+	if(fr->have_eq_settings)
+	{
+		do_equalizer(bandPtr_l,0,fr->equalizer);
+		do_equalizer(bandPtr_r,1,fr->equalizer);
+	}
+
+	fr->bo--;
+	fr->bo &= 0xf;
+	bufl = fr->real_buffs[0];
+	bufr = fr->real_buffs[1];
+
+	if(fr->bo & 0x1)
+	{
+		b0l = bufl[0];
+		b0r = bufr[0];
+		bo1 = fr->bo;
+		dct64_real_neon(bufl[1]+((fr->bo+1)&0xf),bufl[0]+fr->bo,bandPtr_l);
+		dct64_real_neon(bufr[1]+((fr->bo+1)&0xf),bufr[0]+fr->bo,bandPtr_r);
+	}
+	else
+	{
+		b0l = bufl[1];
+		b0r = bufr[1];
+		bo1 = fr->bo+1;
+		dct64_real_neon(bufl[0]+fr->bo,bufl[1]+fr->bo+1,bandPtr_l);
+		dct64_real_neon(bufr[0]+fr->bo,bufr[1]+fr->bo+1,bandPtr_r);
+	}
+
+	clip = synth_1to1_s_neon_accurate_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 128;
+
+	return clip;
+}
+#else
+/* This is defined in assembler. */
+int synth_1to1_neon_asm(short *window, short *b0, short *samples, int bo1);
+int synth_1to1_s_neon_asm(short *window, short *b0l, short *b0r, short *samples, int bo1);
+void dct64_neon(short *out0, short *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_neon(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);	
+	short *b0, **buf;
+	int clip; 
+	int bo1;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->short_buffs[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->short_buffs[1];
+	}
+
+	if(fr->bo & 0x1) 
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		dct64_neon(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		dct64_neon(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	clip = synth_1to1_neon_asm((short *)fr->decwins, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 128;
+
+	return clip;
+}
+
+int synth_1to1_stereo_neon(real *bandPtr_l,real *bandPtr_r, mpg123_handle *fr)
+{
+	short *samples = (short *) (fr->buffer.data+fr->buffer.fill);
+	short *b0l, *b0r, **bufl, **bufr;
+	int clip; 
+	int bo1;
+
+	if(fr->have_eq_settings)
+	{
+		do_equalizer(bandPtr_l,0,fr->equalizer);
+		do_equalizer(bandPtr_r,1,fr->equalizer);
+	}
+
+	fr->bo--;
+	fr->bo &= 0xf;
+	bufl = fr->short_buffs[0];
+	bufr = fr->short_buffs[1];
+
+	if(fr->bo & 0x1) 
+	{
+		b0l = bufl[0];
+		b0r = bufr[0];
+		bo1 = fr->bo;
+		dct64_neon(bufl[1]+((fr->bo+1)&0xf),bufl[0]+fr->bo,bandPtr_l);
+		dct64_neon(bufr[1]+((fr->bo+1)&0xf),bufr[0]+fr->bo,bandPtr_r);
+	}
+	else
+	{
+		b0l = bufl[1];
+		b0r = bufr[1];
+		bo1 = fr->bo+1;
+		dct64_neon(bufl[0]+fr->bo,bufl[1]+fr->bo+1,bandPtr_l);
+		dct64_neon(bufr[0]+fr->bo,bufr[1]+fr->bo+1,bandPtr_r);
+	}
+
+	clip = synth_1to1_s_neon_asm((short *)fr->decwins, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 128;
+
+	return clip;
+}
+#endif
+#endif
+
+#ifndef NO_DOWNSAMPLE
+
+/*
+	Part 1b: 2to1 synth.
+	Only generic and i386 functions this time.
+*/
+#define BLOCK 0x20 /* One decoding block is 32 samples. */
+
+#define SYNTH_NAME synth_2to1
+#include "synth.h"
+#undef SYNTH_NAME
+
+#ifdef OPT_DITHER /* Used for generic_dither and as fallback for i586_dither. */
+#define SYNTH_NAME synth_2to1_dither
+#define USE_DITHER
+#include "synth.h"
+#undef USE_DITHER
+#undef SYNTH_NAME
+#endif
+
+#define SYNTH_NAME       fr->synths.plain[r_2to1][f_16]
+#define MONO_NAME        synth_2to1_mono
+#define MONO2STEREO_NAME synth_2to1_m2s
+#include "synth_mono.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+#ifdef OPT_X86
+#define NO_AUTOINCREMENT
+#define SYNTH_NAME synth_2to1_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK
+
+/*
+	Part 1c: 4to1 synth.
+	Same procedure as above...
+*/
+#define BLOCK 0x10 /* One decoding block is 16 samples. */
+
+#define SYNTH_NAME synth_4to1
+#include "synth.h"
+#undef SYNTH_NAME
+
+#ifdef OPT_DITHER
+#define SYNTH_NAME synth_4to1_dither
+#define USE_DITHER
+#include "synth.h"
+#undef USE_DITHER
+#undef SYNTH_NAME
+#endif
+
+#define SYNTH_NAME       fr->synths.plain[r_4to1][f_16] /* This is just for the _i386 one... gotta check if it is really useful... */
+#define MONO_NAME        synth_4to1_mono
+#define MONO2STEREO_NAME synth_4to1_m2s
+#include "synth_mono.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+#ifdef OPT_X86
+#define NO_AUTOINCREMENT
+#define SYNTH_NAME synth_4to1_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK
+
+#endif /* NO_DOWNSAMPLE */
+
+#ifndef NO_NTOM
+/*
+	Part 1d: ntom synth.
+	Same procedure as above... Just no extra play anymore, straight synth that uses the plain dct64.
+*/
+
+/* These are all in one header, there's no flexibility to gain. */
+#define SYNTH_NAME       synth_ntom
+#define MONO_NAME        synth_ntom_mono
+#define MONO2STEREO_NAME synth_ntom_m2s
+#include "synth_ntom.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+#endif
+
+/* Done with short output. */
+#undef SAMPLE_T
+#undef WRITE_SAMPLE