seal 0.1.0

data/mpg123/src/libmpg123/synth_neon_s32.S

@@ -0,0 +1,168 @@
+/*
+	synth_neon_s32: ARM NEON optimized synth (32-bit output version)
+
+	copyright 1995-2010 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 Taihei Monma
+*/
+
+#include "mangle.h"
+
+#define WINDOW r0
+#define B0 r1
+#define SAMPLES r2
+
+/*
+	int synth_1to1_s32_neon_asm(real *window, real *b0, int *samples, int bo1);
+	return value: number of clipped samples (0)
+*/
+
+	.text
+	.globl ASM_NAME(synth_1to1_s32_neon_asm)
+	ALIGN4
+ASM_NAME(synth_1to1_s32_neon_asm):
+	push		{r4-r6, lr}
+	vpush		{q4-q7}
+	mov			r6, sp
+	sub			sp, sp, #16
+	bic			sp, #0xff
+	
+	add			WINDOW, WINDOW, #64
+	sub			WINDOW, WINDOW, r3, lsl #2
+
+	mov			r3, #4
+	mov			r4, #128
+	mov			r5, #64
+.Loop_start_1:
+	vld1.32		{q0,q1}, [WINDOW], r4
+	vld1.32		{q2,q3}, [WINDOW], r4
+	vld1.32		{q4,q5}, [WINDOW], r4
+	vld1.32		{q6,q7}, [WINDOW]
+	sub			WINDOW, WINDOW, #352
+	vld1.32		{q8,q9}, [B0, :128], r5
+	vld1.32		{q10,q11}, [B0, :128], r5
+	vld1.32		{q12,q13}, [B0, :128], r5
+	vld1.32		{q14,q15}, [B0, :128]
+	vswp		q1, q4
+	vswp		q3, q6
+	sub			B0, B0, #160
+	vmul.f32	q0, q0, q8
+	vmul.f32	q2, q2, q10
+	vmul.f32	q1, q1, q12
+	vmul.f32	q3, q3, q14
+	vmla.f32	q0, q4, q9
+	vmla.f32	q2, q6, q11
+	vmla.f32	q1, q5, q13
+	vmla.f32	q3, q7, q15
+	vld1.32		{q4,q5}, [WINDOW], r4
+	vld1.32		{q6,q7}, [WINDOW], r4
+	vld1.32		{q8,q9}, [WINDOW], r4
+	vld1.32		{q10,q11}, [B0, :128], r5
+	vld1.32		{q12,q13}, [B0, :128], r5
+	vld1.32		{q14,q15}, [B0, :128], r5
+	vswp		q5, q6
+	vswp		q11, q12
+	vmla.f32	q0, q4, q10
+	vmla.f32	q2, q5, q11
+	vmla.f32	q1, q8, q14
+	vld1.32		{q4,q5}, [WINDOW]
+	vld1.32		{q10,q11}, [B0, :128]!
+	add			WINDOW, WINDOW, #96
+	vmla.f32	q3, q4, q10
+	vmla.f32	q0, q6, q12
+	vmla.f32	q2, q7, q13
+	vmla.f32	q1, q9, q15
+	vmla.f32	q3, q5, q11
+	vmvn.i32	q5, #0xb9000000
+	vpadd.f32	d0, d0, d1
+	vpadd.f32	d4, d4, d5
+	vpadd.f32	d2, d2, d3
+	vpadd.f32	d6, d6, d7
+	vld1.32		{q6}, [sp, :128]
+	vpadd.f32	d0, d0, d4
+	vpadd.f32	d1, d2, d6
+
+	vcvt.s32.f32	q3, q0, #16
+	vacgt.f32	q5, q0, q5
+	vld2.32		{q1,q2}, [SAMPLES]
+	vshr.u32	q5, q5, #31
+	vmov		q1, q3
+	vst2.32		{q1,q2}, [SAMPLES]!
+	vadd.i32	q5, q5, q6
+	vst1.32		{q5}, [sp, :128]
+
+	subs		r3, r3, #1
+	bne			.Loop_start_1
+
+	mov			r3, #4
+	mov			r5, #-64
+.Loop_start_2:
+	vld1.32		{q0,q1}, [WINDOW], r4
+	vld1.32		{q2,q3}, [WINDOW], r4
+	vld1.32		{q4,q5}, [WINDOW], r4
+	vld1.32		{q6,q7}, [WINDOW]
+	sub			WINDOW, WINDOW, #352
+	vld1.32		{q8,q9}, [B0, :128], r5
+	vld1.32		{q10,q11}, [B0, :128], r5
+	vld1.32		{q12,q13}, [B0, :128], r5
+	vld1.32		{q14,q15}, [B0, :128]
+	vswp		q1, q4
+	vswp		q3, q6
+	add			B0, B0, #224
+	vmul.f32	q0, q0, q8
+	vmul.f32	q2, q2, q10
+	vmul.f32	q1, q1, q12
+	vmul.f32	q3, q3, q14
+	vmla.f32	q0, q4, q9
+	vmla.f32	q2, q6, q11
+	vmla.f32	q1, q5, q13
+	vmla.f32	q3, q7, q15
+	vld1.32		{q4,q5}, [WINDOW], r4
+	vld1.32		{q6,q7}, [WINDOW], r4
+	vld1.32		{q8,q9}, [WINDOW], r4
+	vld1.32		{q10,q11}, [B0, :128], r5
+	vld1.32		{q12,q13}, [B0, :128], r5
+	vld1.32		{q14,q15}, [B0, :128], r5
+	vswp		q5, q6
+	vswp		q11, q12
+	vmla.f32	q0, q4, q10
+	vmla.f32	q2, q5, q11
+	vmla.f32	q1, q8, q14
+	vld1.32		{q4,q5}, [WINDOW]
+	vld1.32		{q10,q11}, [B0, :128]
+	add			WINDOW, WINDOW, #96
+	sub			B0, B0, #96
+	vmla.f32	q3, q4, q10
+	vmla.f32	q0, q6, q12
+	vmla.f32	q2, q7, q13
+	vmla.f32	q1, q9, q15
+	vmla.f32	q3, q5, q11
+	vmvn.i32	q5, #0xb9000000
+	vpadd.f32	d0, d0, d1
+	vpadd.f32	d4, d4, d5
+	vpadd.f32	d2, d2, d3
+	vpadd.f32	d6, d6, d7
+	vld1.32		{q6}, [sp, :128]
+	vpadd.f32	d0, d0, d4
+	vpadd.f32	d1, d2, d6
+
+	vcvt.s32.f32	q3, q0, #16
+	vacgt.f32	q5, q0, q5
+	vld2.32		{q1,q2}, [SAMPLES]
+	vshr.u32	q5, q5, #31
+	vmov		q1, q3
+	vst2.32		{q1,q2}, [SAMPLES]!
+	vadd.i32	q5, q5, q6
+	vst1.32		{q5}, [sp, :128]
+
+	subs		r3, r3, #1
+	bne			.Loop_start_2
+
+	vld1.32		{q0}, [sp, :128]
+	vpadd.i32	d0, d0, d1
+	vpadd.i32	d0, d0, d0
+	vmov.32		r0, d0[0]
+
+	mov			sp, r6
+	vpop		{q4-q7}
+	pop			{r4-r6, pc}

data/mpg123/src/libmpg123/synth_ntom.h

@@ -0,0 +1,213 @@
+/*
+	synth_ntom.h: ntom-resampling synth functions
+
+	This header is used multiple times to create different variants of this function.
+	Hint: MONO_NAME, MONO2STEREO_NAME, SYNTH_NAME and SAMPLE_T as well as WRITE_SAMPLE do vary.
+
+	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, generalized by Thomas Orgis
+
+	Well, this is very simple resampling... you may or may not like what you hear.
+	But it's cheap.
+	But still, we don't implement a non-autoincrement version of this one.
+*/
+
+/* Note: These mono functions would also work generically,
+   it's just that they need a runtime calculation for the conversion loop...
+   The fixed XtoY functions have the chance for loop unrolling... */
+
+int MONO_NAME(real *bandPtr, mpg123_handle *fr)
+{
+	SAMPLE_T samples_tmp[8*64];
+	SAMPLE_T *tmp1 = samples_tmp;
+	size_t i;
+	int ret;
+
+	size_t pnt = fr->buffer.fill;
+	unsigned char *samples = fr->buffer.data;
+	fr->buffer.data = (unsigned char*) samples_tmp;
+	fr->buffer.fill = 0;
+	ret = SYNTH_NAME(bandPtr, 0, fr, 1);
+	fr->buffer.data = samples;
+
+	samples += pnt;
+	for(i=0;i<(fr->buffer.fill/(2*sizeof(SAMPLE_T)));i++)
+	{
+		*( (SAMPLE_T *)samples) = *tmp1;
+		samples += sizeof(SAMPLE_T);
+		tmp1 += 2;
+	}
+	fr->buffer.fill = pnt + (fr->buffer.fill/2);
+
+	return ret;
+}
+
+
+int MONO2STEREO_NAME(real *bandPtr, mpg123_handle *fr)
+{
+	size_t i;
+	int ret;
+	size_t pnt1 = fr->buffer.fill;
+	unsigned char *samples = fr->buffer.data + pnt1;
+
+	ret = SYNTH_NAME(bandPtr, 0, fr, 1);
+
+	for(i=0;i<((fr->buffer.fill-pnt1)/(2*sizeof(SAMPLE_T)));i++)
+	{
+		((SAMPLE_T *)samples)[1] = ((SAMPLE_T *)samples)[0];
+		samples+=2*sizeof(SAMPLE_T);
+	}
+
+	return ret;
+}
+
+
+int SYNTH_NAME(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	static const int step = 2;
+	SAMPLE_T *samples = (SAMPLE_T *) (fr->buffer.data + fr->buffer.fill);
+
+	real *b0, **buf; /* (*buf)[0x110]; */
+	int clip = 0; 
+	int bo1;
+	int ntom;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+		ntom = fr->ntom_val[1] = fr->ntom_val[0];
+	}
+	else
+	{
+		samples++;
+		buf = fr->real_buffs[1];
+		ntom = fr->ntom_val[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);
+	}
+
+	{
+		register int j;
+		real *window = fr->decwin + 16 - bo1;
+
+		for (j=16;j;j--,window+=0x10)
+		{
+			real sum;
+
+			ntom += fr->ntom_step;
+			if(ntom < NTOM_MUL)
+			{
+				window += 16;
+				b0 += 16;
+				continue;
+			}
+
+			sum  = REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+			sum += REAL_MUL_SYNTH(*window++, *b0++);
+			sum -= REAL_MUL_SYNTH(*window++, *b0++);
+
+			while(ntom >= NTOM_MUL)
+			{
+				WRITE_SAMPLE(samples,sum,clip);
+				samples += step;
+				ntom -= NTOM_MUL;
+			}
+		}
+
+		ntom += fr->ntom_step;
+		if(ntom >= NTOM_MUL)
+		{
+			real sum;
+			sum  = REAL_MUL_SYNTH(window[0x0], b0[0x0]);
+			sum += REAL_MUL_SYNTH(window[0x2], b0[0x2]);
+			sum += REAL_MUL_SYNTH(window[0x4], b0[0x4]);
+			sum += REAL_MUL_SYNTH(window[0x6], b0[0x6]);
+			sum += REAL_MUL_SYNTH(window[0x8], b0[0x8]);
+			sum += REAL_MUL_SYNTH(window[0xA], b0[0xA]);
+			sum += REAL_MUL_SYNTH(window[0xC], b0[0xC]);
+			sum += REAL_MUL_SYNTH(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 += fr->ntom_step;
+			if(ntom < NTOM_MUL)
+			{
+				window -= 16;
+				b0 += 16;
+				continue;
+			}
+
+			sum = REAL_MUL_SYNTH(-*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+			sum -= REAL_MUL_SYNTH(*(--window), *b0++);
+
+			while(ntom >= NTOM_MUL)
+			{
+				WRITE_SAMPLE(samples,sum,clip);
+				samples += step;
+				ntom -= NTOM_MUL;
+			}
+		}
+	}
+
+	fr->ntom_val[channel] = ntom;
+	if(final) fr->buffer.fill = ((unsigned char *) samples - fr->buffer.data - (channel ? sizeof(SAMPLE_T) : 0));
+
+	return clip;
+}
+

data/mpg123/src/libmpg123/synth_real.c

@@ -0,0 +1,404 @@
+/*
+	synth_real.c: The functions for synthesizing real (float) 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"
+
+#ifdef REAL_IS_FIXED
+#error "Do not build this file with fixed point math!"
+#else
+/* 
+	Part 3: All synth functions that produce float output.
+	What we need is just a special WRITE_SAMPLE. For the generic and i386 functions, that is.
+	The optimized synths would need to be changed internally to support float output.
+*/
+
+#define SAMPLE_T real
+#define WRITE_SAMPLE(samples,sum,clip) WRITE_REAL_SAMPLE(samples,sum,clip)
+
+/* Part 3a: All straight 1to1 decoding functions */
+#define BLOCK 0x40 /* One decoding block is 64 samples. */
+
+#define SYNTH_NAME synth_1to1_real
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_1to1_real (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_1to1][f_real]
+#define MONO_NAME        synth_1to1_real_mono
+#define MONO2STEREO_NAME synth_1to1_real_m2s
+#include "synth_mono.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+#ifdef OPT_X86
+#define NO_AUTOINCREMENT
+#define SYNTH_NAME synth_1to1_real_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK
+
+/* At least one optimized real decoder... */
+#ifdef OPT_X86_64
+/* Assembler routines. */
+int synth_1to1_real_x86_64_asm(real *window, real *b0, real *samples, int bo1);
+int synth_1to1_real_s_x86_64_asm(real *window, real *b0l, real *b0r, real *samples, int bo1);
+void dct64_real_x86_64(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_real_x86_64(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	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_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);
+	}
+
+	synth_1to1_real_x86_64_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return 0;
+}
+
+int synth_1to1_real_stereo_x86_64(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	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->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);
+	}
+
+	synth_1to1_real_s_x86_64_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return 0;
+}
+#endif
+
+#ifdef OPT_SSE
+/* Assembler routines. */
+int synth_1to1_real_sse_asm(real *window, real *b0, real *samples, int bo1);
+int synth_1to1_real_s_sse_asm(real *window, real *b0l, real *b0r, real *samples, int bo1);
+void dct64_real_sse(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_real_sse(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	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);
+	}
+
+	synth_1to1_real_sse_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return 0;
+}
+
+int synth_1to1_real_stereo_sse(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	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->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);
+	}
+
+	synth_1to1_real_s_sse_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return 0;
+}
+#endif
+
+#ifdef OPT_NEON
+/* Assembler routines. */
+int synth_1to1_real_neon_asm(real *window, real *b0, real *samples, int bo1);
+int synth_1to1_real_s_neon_asm(real *window, real *b0l, real *b0r, real *samples, int bo1);
+void dct64_real_neon(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_real_neon(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0, **buf;
+	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_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);
+	}
+
+	synth_1to1_real_neon_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return 0;
+}
+int synth_1to1_real_stereo_neon(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	real *samples = (real *) (fr->buffer.data+fr->buffer.fill);
+
+	real *b0l, *b0r, **bufl, **bufr;
+	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->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);
+	}
+
+	synth_1to1_real_s_neon_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return 0;
+}
+#endif
+
+#ifndef NO_DOWNSAMPLE
+
+/*
+	Part 3b: 2to1 synth. Only generic and i386.
+*/
+#define BLOCK 0x20 /* One decoding block is 32 samples. */
+
+#define SYNTH_NAME synth_2to1_real
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_2to1_real (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_2to1][f_real]
+#define MONO_NAME        synth_2to1_real_mono
+#define MONO2STEREO_NAME synth_2to1_real_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_real_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK
+
+/*
+	Part 3c: 4to1 synth. Only generic and i386.
+*/
+#define BLOCK 0x10 /* One decoding block is 16 samples. */
+
+#define SYNTH_NAME synth_4to1_real
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_4to1_real (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_4to1][f_real]
+#define MONO_NAME        synth_4to1_real_mono
+#define MONO2STEREO_NAME synth_4to1_real_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_real_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 3d: ntom synth.
+	Same procedure as above... Just no extra play anymore, straight synth that may use an optimized dct64.
+*/
+
+/* These are all in one header, there's no flexibility to gain. */
+#define SYNTH_NAME       synth_ntom_real
+#define MONO_NAME        synth_ntom_real_mono
+#define MONO2STEREO_NAME synth_ntom_real_m2s
+#include "synth_ntom.h"
+#undef SYNTH_NAME
+#undef MONO_NAME
+#undef MONO2STEREO_NAME
+
+#endif
+
+#undef SAMPLE_T
+#undef WRITE_SAMPLE
+
+#endif /* non-fixed type */