seal 0.1.0

data/mpg123/src/libmpg123/synth_s32.c

@@ -0,0 +1,411 @@
+/*
+	synth_s32.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 4: All synth functions that produce signed 32 bit output.
+	What we need is just a special WRITE_SAMPLE.
+*/
+
+#define SAMPLE_T int32_t
+#define WRITE_SAMPLE(samples,sum,clip) WRITE_S32_SAMPLE(samples,sum,clip)
+
+/* Part 4a: All straight 1to1 decoding functions */
+#define BLOCK 0x40 /* One decoding block is 64 samples. */
+
+#define SYNTH_NAME synth_1to1_s32
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_1to1_s32 (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_1to1][f_32]
+#define MONO_NAME        synth_1to1_s32_mono
+#define MONO2STEREO_NAME synth_1to1_s32_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_s32_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#ifdef OPT_X86_64
+/* Assembler routines. */
+int synth_1to1_s32_x86_64_asm(real *window, real *b0, int32_t *samples, int bo1);
+int synth_1to1_s32_s_x86_64_asm(real *window, real *b0l, real *b0r, int32_t *samples, int bo1);
+void dct64_real_x86_64(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_s32_x86_64(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	int32_t *samples = (int32_t *) (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_s32_x86_64_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return clip;
+}
+
+
+int synth_1to1_s32_stereo_x86_64(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	int32_t *samples = (int32_t *) (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_s32_s_x86_64_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return clip;
+}
+#endif
+
+#ifdef OPT_SSE
+/* Assembler routines. */
+int synth_1to1_s32_sse_asm(real *window, real *b0, int32_t *samples, int bo1);
+int synth_1to1_s32_s_sse_asm(real *window, real *b0l, real *b0r, int32_t *samples, int bo1);
+void dct64_real_sse(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_s32_sse(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	int32_t *samples = (int32_t *) (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_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_s32_sse_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return clip;
+}
+
+
+int synth_1to1_s32_stereo_sse(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	int32_t *samples = (int32_t *) (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_s32_s_sse_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return clip;
+}
+#endif
+
+#ifdef OPT_NEON
+/* Assembler routines. */
+int synth_1to1_s32_neon_asm(real *window, real *b0, int32_t *samples, int bo1);
+int synth_1to1_s32_s_neon_asm(real *window, real *b0l, real *b0r, int32_t *samples, int bo1);
+void dct64_real_neon(real *out0, real *out1, real *samples);
+/* Hull for C mpg123 API */
+int synth_1to1_s32_neon(real *bandPtr,int channel, mpg123_handle *fr, int final)
+{
+	int32_t *samples = (int32_t *) (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_s32_neon_asm(fr->decwin, b0, samples, bo1);
+
+	if(final) fr->buffer.fill += 256;
+
+	return clip;
+}
+
+int synth_1to1_s32_stereo_neon(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
+{
+	int32_t *samples = (int32_t *) (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_s32_s_neon_asm(fr->decwin, b0l, b0r, samples, bo1);
+
+	fr->buffer.fill += 256;
+
+	return clip;
+}
+#endif
+
+#undef BLOCK
+
+#ifndef NO_DOWNSAMPLE
+
+/*
+	Part 4b: 2to1 synth. Only generic and i386.
+*/
+#define BLOCK 0x20 /* One decoding block is 32 samples. */
+
+#define SYNTH_NAME synth_2to1_s32
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_2to1_s32 (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_2to1][f_32]
+#define MONO_NAME        synth_2to1_s32_mono
+#define MONO2STEREO_NAME synth_2to1_s32_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_s32_i386
+#include "synth.h"
+#undef SYNTH_NAME
+/* i386 uses the normal mono functions. */
+#undef NO_AUTOINCREMENT
+#endif
+
+#undef BLOCK
+
+/*
+	Part 4c: 4to1 synth. Only generic and i386.
+*/
+#define BLOCK 0x10 /* One decoding block is 16 samples. */
+
+#define SYNTH_NAME synth_4to1_s32
+#include "synth.h"
+#undef SYNTH_NAME
+
+/* Mono-related synths; they wrap over _some_ synth_4to1_s32 (could be generic, could be i386). */
+#define SYNTH_NAME       fr->synths.plain[r_4to1][f_32]
+#define MONO_NAME        synth_4to1_s32_mono
+#define MONO2STEREO_NAME synth_4to1_s32_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_s32_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 4d: 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_s32
+#define MONO_NAME        synth_ntom_s32_mono
+#define MONO2STEREO_NAME synth_ntom_s32_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 */

data/mpg123/src/libmpg123/synth_sse.S

@@ -0,0 +1,6 @@
+#include "mangle.h"
+#define MPL_DCT64 ASM_NAME(dct64_sse)
+#define SYNTH_NAME ASM_NAME(synth_1to1_sse_asm)
+#include "synth_sse3d.h"
+
+NONEXEC_STACK

data/mpg123/src/libmpg123/synth_sse3d.h

@@ -0,0 +1,246 @@
+/*
+	decode_sse3d: Synth for SSE and extended 3DNow (yeah, the name is a relic)
+
+	copyright 2006-2007 by Zuxy Meng/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 the mysterious higway for MMX (apparently)
+	then developed into SSE opt by Zuxy Meng, also building on Romain Dolbeau's AltiVec
+	Both have agreed to distribution under LGPL 2.1 .
+
+	Transformed back into standalone asm, with help of
+	gcc -S -DHAVE_CONFIG_H -I.  -march=pentium -O3 -Wall -pedantic -fno-strict-aliasing -DREAL_IS_FLOAT -c -o decode_mmxsse.{S,c}
+
+	The difference between SSE and 3DNowExt is the dct64 function and the synth function name.
+	This template here uses the SYNTH_NAME and MPL_DCT64 macros for this - see decode_sse.S and decode_3dnowext.S...
+	That's not memory efficient since there's doubled code, but it's easier than giving another function pointer.
+	Maybe I'll change it in future, but now I need something that works.
+
+	Original comment from MPlayer source follows:
+*/
+
+/*
+ * this code comes under GPL
+ * This code was taken from http://www.mpg123.org
+ * See ChangeLog of mpg123-0.59s-pre.1 for detail
+ * Applied to mplayer by Nick Kurshev <nickols_k@mail.ru>
+ *
+ * Local ChangeLog:
+ * - Partial loops unrolling and removing MOVW insn from loops
+*/
+
+#include "mangle.h"
+
+	.data
+	ALIGN8
+one_null:
+	.long	-65536
+	.long	-65536
+	ALIGN8
+null_one:
+	.long	65535
+	.long	65535
+
+	.text
+	ALIGN16
+	/* void SYNTH_NAME(real *bandPtr, int channel, short *samples, short *buffs, int *bo, float *decwins) */
+.globl SYNTH_NAME
+SYNTH_NAME:
+	pushl	%ebp
+/* stack:0=ebp 4=back 8=bandptr 12=channel 16=samples 20=buffs 24=bo 28=decwins */
+	movl	%esp, %ebp
+/* Now the old stack addresses are preserved via %epb. */
+	subl  $4,%esp /* What has been called temp before. */
+	pushl	%edi
+	pushl	%esi
+	pushl	%ebx
+#define TEMP 12(%esp)
+/* APP */
+	movl 12(%ebp),%ecx
+	movl 16(%ebp),%edi
+	movl $15,%ebx
+	movl 24(%ebp),%edx
+	leal (%edi,%ecx,2),%edi
+	decl %ecx
+	movl 20(%ebp),%esi
+	movl (%edx),%eax
+	jecxz .L01
+	decl %eax
+	andl %ebx,%eax
+	leal 1088(%esi),%esi
+	movl %eax,(%edx)
+	.L01:
+	leal (%esi,%eax,2),%edx
+	movl %eax,TEMP
+	incl %eax
+	andl %ebx,%eax
+	leal 544(%esi,%eax,2),%ecx
+	incl %ebx
+	testl $1, %eax
+	jnz .L02
+	xchgl %edx,%ecx
+	incl TEMP
+	leal 544(%esi),%esi
+	.L02:
+	pushl 8(%ebp)
+	pushl %edx
+	pushl %ecx
+	call MPL_DCT64
+	addl $12, %esp
+	leal 1(%ebx), %ecx
+	subl TEMP,%ebx
+	pushl %ecx
+	/* leal ASM_NAME(decwins)(%ebx,%ebx,1), %edx */
+	movl 28(%ebp),%ecx
+	leal (%ecx,%ebx,2), %edx
+	movl (%esp),%ecx /* restore, but leave value on stack */
+	shrl $1, %ecx
+	ALIGN16
+	.L03:
+	movq  (%edx),%mm0
+	movq  64(%edx),%mm4
+	pmaddwd (%esi),%mm0
+	pmaddwd 32(%esi),%mm4
+	movq  8(%edx),%mm1
+	movq  72(%edx),%mm5
+	pmaddwd 8(%esi),%mm1
+	pmaddwd 40(%esi),%mm5
+	movq  16(%edx),%mm2
+	movq  80(%edx),%mm6
+	pmaddwd 16(%esi),%mm2
+	pmaddwd 48(%esi),%mm6
+	movq  24(%edx),%mm3
+	movq  88(%edx),%mm7
+	pmaddwd 24(%esi),%mm3
+	pmaddwd 56(%esi),%mm7
+	paddd %mm1,%mm0
+	paddd %mm5,%mm4
+	paddd %mm2,%mm0
+	paddd %mm6,%mm4
+	paddd %mm3,%mm0
+	paddd %mm7,%mm4
+	movq  %mm0,%mm1
+	movq  %mm4,%mm5
+	psrlq $32,%mm1
+	psrlq $32,%mm5
+	paddd %mm1,%mm0
+	paddd %mm5,%mm4
+	psrad $13,%mm0
+	psrad $13,%mm4
+	packssdw %mm0,%mm0
+	packssdw %mm4,%mm4
+	movq	(%edi), %mm1
+	punpckldq %mm4, %mm0
+	pand   one_null, %mm1
+	pand   null_one, %mm0
+	por    %mm0, %mm1
+	movq   %mm1,(%edi)
+	leal 64(%esi),%esi
+	leal 128(%edx),%edx
+	leal 8(%edi),%edi
+	decl %ecx
+	jnz  .L03
+	popl %ecx
+	andl $1, %ecx
+	jecxz .next_loop
+	movq  (%edx),%mm0
+	pmaddwd (%esi),%mm0
+	movq  8(%edx),%mm1
+	pmaddwd 8(%esi),%mm1
+	movq  16(%edx),%mm2
+	pmaddwd 16(%esi),%mm2
+	movq  24(%edx),%mm3
+	pmaddwd 24(%esi),%mm3
+	paddd %mm1,%mm0
+	paddd %mm2,%mm0
+	paddd %mm3,%mm0
+	movq  %mm0,%mm1
+	psrlq $32,%mm1
+	paddd %mm1,%mm0
+	psrad $13,%mm0
+	packssdw %mm0,%mm0
+	movd %mm0,%eax
+	movw %ax, (%edi)
+	leal 32(%esi),%esi
+	leal 64(%edx),%edx
+	leal 4(%edi),%edi
+	.next_loop:
+	subl $64,%esi
+	movl $7,%ecx
+	ALIGN16
+	.L04:
+	movq  (%edx),%mm0
+	movq  64(%edx),%mm4
+	pmaddwd (%esi),%mm0
+	pmaddwd -32(%esi),%mm4
+	movq  8(%edx),%mm1
+	movq  72(%edx),%mm5
+	pmaddwd 8(%esi),%mm1
+	pmaddwd -24(%esi),%mm5
+	movq  16(%edx),%mm2
+	movq  80(%edx),%mm6
+	pmaddwd 16(%esi),%mm2
+	pmaddwd -16(%esi),%mm6
+	movq  24(%edx),%mm3
+	movq  88(%edx),%mm7
+	pmaddwd 24(%esi),%mm3
+	pmaddwd -8(%esi),%mm7
+	paddd %mm1,%mm0
+	paddd %mm5,%mm4
+	paddd %mm2,%mm0
+	paddd %mm6,%mm4
+	paddd %mm3,%mm0
+	paddd %mm7,%mm4
+	movq  %mm0,%mm1
+	movq  %mm4,%mm5
+	psrlq $32,%mm1
+	psrlq $32,%mm5
+	paddd %mm0,%mm1
+	paddd %mm4,%mm5
+	psrad $13,%mm1
+	psrad $13,%mm5
+	packssdw %mm1,%mm1
+	packssdw %mm5,%mm5
+	psubd %mm0,%mm0
+	psubd %mm4,%mm4
+	psubsw %mm1,%mm0
+	psubsw %mm5,%mm4
+	movq	(%edi), %mm1
+	punpckldq %mm4, %mm0
+	pand   one_null, %mm1
+	pand   null_one, %mm0
+	por    %mm0, %mm1
+	movq   %mm1,(%edi)
+	subl $64,%esi
+	addl $128,%edx
+	leal 8(%edi),%edi
+	decl %ecx
+	jnz  .L04
+	movq  (%edx),%mm0
+	pmaddwd (%esi),%mm0
+	movq  8(%edx),%mm1
+	pmaddwd 8(%esi),%mm1
+	movq  16(%edx),%mm2
+	pmaddwd 16(%esi),%mm2
+	movq  24(%edx),%mm3
+	pmaddwd 24(%esi),%mm3
+	paddd %mm1,%mm0
+	paddd %mm2,%mm0
+	paddd %mm3,%mm0
+	movq  %mm0,%mm1
+	psrlq $32,%mm1
+	paddd %mm0,%mm1
+	psrad $13,%mm1
+	packssdw %mm1,%mm1
+	psubd %mm0,%mm0
+	psubsw %mm1,%mm0
+	movd %mm0,%eax
+	movw %ax,(%edi)
+	emms
+
+/* NO_APP */
+	popl	%ebx
+	popl	%esi
+	popl	%edi
+	addl $4,%esp
+	popl	%ebp
+	ret