seal 0.1.0

data/mpg123/src/libmpg123/synth.h

@@ -0,0 +1,196 @@
+/*
+	synth.h: generic synth functions 
+
+	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
+
+	This header is used multiple times to create different variants of these functions.
+	See decode.c and friends.
+	Hint: BLOCK, MONO_NAME, MONO2STEREO_NAME, SYNTH_NAME and SAMPLE_T as well as WRITE_SAMPLE do vary.
+
+	Thomas looked closely at the decode_1to1, decode_2to1 and decode_4to1 contents, seeing that they are too similar to be separate files.
+	This is what resulted...
+
+	Basically, you need one set of these functions for each output sample type.
+	That currently means signed short, 8bit or float/double; though unsigned short may come, too.
+
+	Define NO_AUTOINCREMENT i386 code that shall not rely on autoincrement.
+	Actual benefit of this has to be examined; may apply to specific (old) compilers, only.
+*/
+
+
+/* Main synth function, uses the plain dct64 or dct64_i386. */
+int SYNTH_NAME(real *bandPtr, int channel, mpg123_handle *fr, int final)
+{
+#ifndef NO_AUTOINCREMENT
+#define BACKPEDAL 0x10 /* We use autoincrement and thus need this re-adjustment for window/b0. */
+#define MY_DCT64 dct64
+#else
+#define BACKPEDAL 0x00 /* i386 code does not need that. */
+#define MY_DCT64 dct64_i386
+#endif
+	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;
+
+	if(fr->have_eq_settings) do_equalizer(bandPtr,channel,fr->equalizer);
+
+	if(!channel)
+	{
+		fr->bo--;
+		fr->bo &= 0xf;
+		buf = fr->real_buffs[0];
+	}
+	else
+	{
+#ifdef USE_DITHER
+		/* We always go forward 32 dither points (and back again for the second channel),
+		   (re)sampling the noise the same way as the original signal. */
+		fr->ditherindex -= 32;
+#endif
+		samples++;
+		buf = fr->real_buffs[1];
+	}
+#ifdef USE_DITHER
+	/* We check only once for the overflow of dither index here ...
+	   this wraps differently than the original i586 dither code, in theory (but when DITHERSIZE % BLOCK/2 == 0 it's the same). */
+	if(DITHERSIZE-fr->ditherindex < 32) fr->ditherindex = 0;
+	/* And we define a macro for the dither action... */
+	#define ADD_DITHER(fr,sum) sum+=fr->dithernoise[fr->ditherindex]; fr->ditherindex += 64/BLOCK;
+#else
+	#define ADD_DITHER(fr,sum)
+#endif
+
+	if(fr->bo & 0x1)
+	{
+		b0 = buf[0];
+		bo1 = fr->bo;
+		MY_DCT64(buf[1]+((fr->bo+1)&0xf),buf[0]+fr->bo,bandPtr);
+	}
+	else
+	{
+		b0 = buf[1];
+		bo1 = fr->bo+1;
+		MY_DCT64(buf[0]+fr->bo,buf[1]+fr->bo+1,bandPtr);
+	}
+
+	{
+		register int j;
+		real *window = fr->decwin + 16 - bo1;
+
+		for(j=(BLOCK/4); j; j--, b0+=0x400/BLOCK-BACKPEDAL, window+=0x800/BLOCK-BACKPEDAL, samples+=step)
+		{
+			real sum;
+#ifndef NO_AUTOINCREMENT
+			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++);
+#else
+			sum  = REAL_MUL_SYNTH(window[0x0], b0[0x0]);
+			sum -= REAL_MUL_SYNTH(window[0x1], b0[0x1]);
+			sum += REAL_MUL_SYNTH(window[0x2], b0[0x2]);
+			sum -= REAL_MUL_SYNTH(window[0x3], b0[0x3]);
+			sum += REAL_MUL_SYNTH(window[0x4], b0[0x4]);
+			sum -= REAL_MUL_SYNTH(window[0x5], b0[0x5]);
+			sum += REAL_MUL_SYNTH(window[0x6], b0[0x6]);
+			sum -= REAL_MUL_SYNTH(window[0x7], b0[0x7]);
+			sum += REAL_MUL_SYNTH(window[0x8], b0[0x8]);
+			sum -= REAL_MUL_SYNTH(window[0x9], b0[0x9]);
+			sum += REAL_MUL_SYNTH(window[0xA], b0[0xA]);
+			sum -= REAL_MUL_SYNTH(window[0xB], b0[0xB]);
+			sum += REAL_MUL_SYNTH(window[0xC], b0[0xC]);
+			sum -= REAL_MUL_SYNTH(window[0xD], b0[0xD]);
+			sum += REAL_MUL_SYNTH(window[0xE], b0[0xE]);
+			sum -= REAL_MUL_SYNTH(window[0xF], b0[0xF]);
+#endif
+
+			ADD_DITHER(fr,sum)
+			WRITE_SAMPLE(samples,sum,clip);
+		}
+
+		{
+			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]);
+
+			ADD_DITHER(fr,sum)
+			WRITE_SAMPLE(samples,sum,clip);
+			samples += step;
+			b0-=0x400/BLOCK;
+			window-=0x800/BLOCK;
+		}
+		window += bo1<<1;
+
+		for(j=(BLOCK/4)-1; j; j--, b0-=0x400/BLOCK+BACKPEDAL, window-=0x800/BLOCK-BACKPEDAL, samples+=step)
+		{
+			real sum;
+#ifndef NO_AUTOINCREMENT
+			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++);
+#else
+			sum = -REAL_MUL_SYNTH(window[-0x1], b0[0x0]);
+			sum -= REAL_MUL_SYNTH(window[-0x2], b0[0x1]);
+			sum -= REAL_MUL_SYNTH(window[-0x3], b0[0x2]);
+			sum -= REAL_MUL_SYNTH(window[-0x4], b0[0x3]);
+			sum -= REAL_MUL_SYNTH(window[-0x5], b0[0x4]);
+			sum -= REAL_MUL_SYNTH(window[-0x6], b0[0x5]);
+			sum -= REAL_MUL_SYNTH(window[-0x7], b0[0x6]);
+			sum -= REAL_MUL_SYNTH(window[-0x8], b0[0x7]);
+			sum -= REAL_MUL_SYNTH(window[-0x9], b0[0x8]);
+			sum -= REAL_MUL_SYNTH(window[-0xA], b0[0x9]);
+			sum -= REAL_MUL_SYNTH(window[-0xB], b0[0xA]);
+			sum -= REAL_MUL_SYNTH(window[-0xC], b0[0xB]);
+			sum -= REAL_MUL_SYNTH(window[-0xD], b0[0xC]);
+			sum -= REAL_MUL_SYNTH(window[-0xE], b0[0xD]);
+			sum -= REAL_MUL_SYNTH(window[-0xF], b0[0xE]);
+			sum -= REAL_MUL_SYNTH(window[-0x0], b0[0xF]); /* Is that right? 0x0? Just wondering... */
+#endif
+			ADD_DITHER(fr,sum)
+			WRITE_SAMPLE(samples,sum,clip);
+		}
+	}
+
+	if(final) fr->buffer.fill += BLOCK*sizeof(SAMPLE_T);
+
+	return clip;
+#undef ADD_DITHER
+#undef BACKPEDAL
+#undef MY_DCT64
+}

data/mpg123/src/libmpg123/synth_3dnow.S

@@ -0,0 +1,318 @@
+/*
+	decode_3dnow.s - 3DNow! optimized synth_1to1()
+
+	copyright ?-2007 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 Syuuhei Kashiyama
+
+	This code based 'decode_3dnow.s' by Syuuhei Kashiyama
+	<squash@mb.kcom.ne.jp>,only two types of changes have been made:
+
+	- remove PREFETCH instruction for speedup
+	- change function name for support 3DNow! automatic detect
+	- femms moved to before 'call dct64_3dnow'
+
+	You can find Kashiyama's original 3dnow! support patch
+	(for mpg123-0.59o) at
+	http://user.ecc.u-tokyo.ac.jp/~g810370/linux-simd/ (Japanese).
+
+	by KIMURA Takuhiro <kim@hannah.ipc.miyakyo-u.ac.jp> - until 31.Mar.1999
+                  	<kim@comtec.co.jp>               - after  1.Apr.1999
+
+
+
+	Replacement of synth_1to1() with AMD's 3DNow! SIMD operations support
+
+	Syuuhei Kashiyama <squash@mb.kcom.ne.jp>
+
+	The author of this program disclaim whole expressed or implied
+	warranties with regard to this program, and in no event shall the
+	author of this program liable to whatever resulted from the use of
+	this program. Use it at your own risk.
+*/
+
+#include "mangle.h"
+
+#ifdef ACCURATE_ROUNDING
+#ifndef __APPLE__
+	.section	.rodata
+#else
+	.data
+#endif
+	ALIGN8
+max_s16:
+	.long   1191181824 /* 32767.0 */
+	.long   1191181824
+min_s16:
+	.long   -956301312 /* -32768.0 */
+	.long   -956301312
+ftoi_magic:
+	.long	1262485504 /* 2^23 + 2^22 */
+	.long	1262485504
+#endif
+	.text
+	ALIGN16
+.globl ASM_NAME(synth_1to1_3dnow_asm)
+/* int synth_1to1_3dnow_asm(real *bandPtr, int channel, unsigned char *out, unsigned char *buffs, int *bo, real *decwin); */
+ASM_NAME(synth_1to1_3dnow_asm):
+	subl $24,%esp
+	pushl %ebp
+	pushl %edi
+	xorl %ebp,%ebp
+	pushl %esi
+	pushl %ebx
+/* stack old: 0=ebx 4=esi 8=edi 12=ebp 16,20,24,28,32,36=local 40=back 44=bandptr 48=channel 52=out 56=pnt */
+/* stack new: 0=ebx 4=esi 8=edi 12=ebp 16,20,24,28,32,36=local 40=back 44=bandptr 48=channel 52=out 56=buffs 60=bo 64=decwin */
+#define OUT     52(%esp)
+#define CHANNEL 48(%esp)
+#define BANDPTR 44(%esp)
+#define BUFFS   56(%esp)
+#define BO      60(%esp)
+#define DECWIN  64(%esp)
+#define LOCAL0  16(%esp)
+#define LOCAL1  20(%esp)
+#define LOCAL5  36(%esp)
+	movl OUT,%esi
+	movl %esi,LOCAL0 /* save buffer start (samples pointer) to another local var */
+	movl CHANNEL,%ebx
+	movl BO,%esi     /* bo address */
+	movl (%esi),%edx /* bo value */
+
+	femms
+	testl %ebx,%ebx
+	jne .L26
+/* if(!channel) */
+	decl %edx   /* --bo */
+	andl $15,%edx
+	movl %edx,(%esi) /* save bo */
+	movl BUFFS,%ecx
+	jmp .L27
+.L26: /* if(channel) */
+	addl $2,LOCAL0   /* samples++ */
+	movl BUFFS,%ecx
+	addl $2176,%ecx
+.L27:
+/* edx (and it's lower end) still holds bo value */
+	testb $1,%dl  /* bo & 0x1 */
+	je .L28
+	movl %edx,LOCAL5
+	movl %ecx,%ebx
+	movl BANDPTR,%esi
+	movl %edx,%edi
+	pushl %esi
+	sall $2,%edi
+	movl %ebx,%eax
+	movl %edi,24(%esp) /* LOCAL1, actually */
+	addl %edi,%eax
+	pushl %eax
+	movl %edx,%eax
+	incl %eax
+	andl $15,%eax
+	leal 1088(,%eax,4),%eax
+	addl %ebx,%eax
+	pushl %eax
+	call ASM_NAME(dct64_3dnow)
+	addl $12,%esp
+	jmp .L29
+.L28:
+	leal 1(%edx),%esi
+	movl BANDPTR,%edi
+	movl %esi,LOCAL5
+	leal 1092(%ecx,%edx,4),%eax
+	pushl %edi
+	leal 1088(%ecx),%ebx
+	pushl %eax
+	sall $2,%esi
+	leal (%ecx,%edx,4),%eax
+	pushl %eax
+	call ASM_NAME(dct64_3dnow)
+	addl $12,%esp
+	movl %esi,LOCAL1
+.L29:
+	movl DECWIN,%edx
+	addl $64,%edx
+	movl $16,%ecx
+	subl LOCAL1,%edx
+	movl LOCAL0,%edi
+
+	pcmpeqb %mm7,%mm7
+	pslld $31,%mm7
+	movq (%edx),%mm0
+	movq (%ebx),%mm1
+	ALIGN32
+.L33:
+	movq 8(%edx),%mm3
+	pfmul %mm1,%mm0
+	movq 8(%ebx),%mm4
+	movq 16(%edx),%mm5
+	pfmul %mm4,%mm3
+	movq 16(%ebx),%mm6
+	pfadd %mm3,%mm0
+	movq 24(%edx),%mm1
+	pfmul %mm6,%mm5
+	movq 24(%ebx),%mm2
+	pfadd %mm5,%mm0
+	movq 32(%edx),%mm3
+	pfmul %mm2,%mm1
+	movq 32(%ebx),%mm4
+	pfadd %mm1,%mm0
+	movq 40(%edx),%mm5
+	pfmul %mm4,%mm3
+	movq 40(%ebx),%mm6
+	pfadd %mm3,%mm0
+	movq 48(%edx),%mm1
+	pfmul %mm6,%mm5
+	movq 48(%ebx),%mm2
+	pfadd %mm0,%mm5
+	movq 56(%edx),%mm3
+	pfmul %mm1,%mm2
+	movq 56(%ebx),%mm4
+	pfadd %mm5,%mm2
+	addl $64,%ebx
+	subl $-128,%edx
+	movq (%edx),%mm0
+	pfmul %mm4,%mm3
+	movq (%ebx),%mm1
+	pfadd %mm3,%mm2
+	movq %mm2,%mm3
+	psrlq $32,%mm3
+	pfsub %mm3,%mm2
+	incl %ebp
+#ifdef ACCURATE_ROUNDING
+	pfmin (max_s16),%mm2
+	pfmax (min_s16),%mm2
+	pfadd (ftoi_magic),%mm2
+#else
+	pf2id %mm2,%mm2
+	packssdw %mm2,%mm2
+#endif
+	movd %mm2,%eax
+	movw %ax,0(%edi)
+	addl $4,%edi
+	decl %ecx
+	jnz .L33
+
+	movd (%ebx),%mm0
+	movd (%edx),%mm1
+	punpckldq 8(%ebx),%mm0
+	punpckldq 8(%edx),%mm1
+	movd 16(%ebx),%mm3
+	movd 16(%edx),%mm4
+	pfmul %mm1,%mm0
+	punpckldq 24(%ebx),%mm3
+	punpckldq 24(%edx),%mm4
+	movd 32(%ebx),%mm5
+	movd 32(%edx),%mm6
+	pfmul %mm4,%mm3
+	punpckldq 40(%ebx),%mm5
+	punpckldq 40(%edx),%mm6
+	pfadd %mm3,%mm0
+	movd 48(%ebx),%mm1
+	movd 48(%edx),%mm2
+	pfmul %mm6,%mm5
+	punpckldq 56(%ebx),%mm1
+	punpckldq 56(%edx),%mm2
+	pfadd %mm5,%mm0
+	pfmul %mm2,%mm1
+	pfadd %mm1,%mm0
+	pfacc %mm1,%mm0
+#ifdef ACCURATE_ROUNDING
+	pfmin (max_s16),%mm0
+	pfmax (min_s16),%mm0
+	pfadd (ftoi_magic),%mm0
+#else
+	pf2id %mm0,%mm0
+	packssdw %mm0,%mm0
+#endif
+	movd %mm0,%eax
+	movw %ax,0(%edi)
+	incl %ebp
+	movl LOCAL5,%esi
+	addl $-64,%ebx
+	movl $15,%ebp
+	addl $4,%edi
+	leal -128(%edx,%esi,8),%edx
+
+	movl $15,%ecx
+	movd (%ebx),%mm0
+	movd -4(%edx),%mm1
+	punpckldq 4(%ebx),%mm0
+	punpckldq -8(%edx),%mm1
+	ALIGN32
+.L46:
+	movd 8(%ebx),%mm3
+	movd -12(%edx),%mm4
+	pfmul %mm1,%mm0
+	punpckldq 12(%ebx),%mm3
+	punpckldq -16(%edx),%mm4
+	movd 16(%ebx),%mm5
+	movd -20(%edx),%mm6
+	pfmul %mm4,%mm3
+	punpckldq 20(%ebx),%mm5
+	punpckldq -24(%edx),%mm6
+	pfadd %mm3,%mm0
+	movd 24(%ebx),%mm1
+	movd -28(%edx),%mm2
+	pfmul %mm6,%mm5
+	punpckldq 28(%ebx),%mm1
+	punpckldq -32(%edx),%mm2
+	pfadd %mm5,%mm0
+	movd 32(%ebx),%mm3
+	movd -36(%edx),%mm4
+	pfmul %mm2,%mm1
+	punpckldq 36(%ebx),%mm3
+	punpckldq -40(%edx),%mm4
+	pfadd %mm1,%mm0
+	movd 40(%ebx),%mm5
+	movd -44(%edx),%mm6
+	pfmul %mm4,%mm3
+	punpckldq 44(%ebx),%mm5
+	punpckldq -48(%edx),%mm6
+	pfadd %mm3,%mm0
+	movd 48(%ebx),%mm1
+	movd -52(%edx),%mm2
+	pfmul %mm6,%mm5
+	punpckldq 52(%ebx),%mm1
+	punpckldq -56(%edx),%mm2
+	pfadd %mm0,%mm5
+	movd 56(%ebx),%mm3
+	movd -60(%edx),%mm4
+	pfmul %mm2,%mm1
+	punpckldq 60(%ebx),%mm3
+	punpckldq (%edx),%mm4
+	pfadd %mm1,%mm5
+	addl $-128,%edx
+	addl $-64,%ebx
+	movd (%ebx),%mm0
+	movd -4(%edx),%mm1
+	pfmul %mm4,%mm3
+	punpckldq 4(%ebx),%mm0
+	punpckldq -8(%edx),%mm1
+	pfadd %mm5,%mm3
+	pfacc %mm3,%mm3
+	incl %ebp
+	pxor %mm7,%mm3
+#ifdef ACCURATE_ROUNDING
+	pfmin (max_s16),%mm3
+	pfmax (min_s16),%mm3
+	pfadd (ftoi_magic),%mm3
+#else
+	pf2id %mm3,%mm3
+	packssdw %mm3,%mm3
+#endif
+	movd %mm3,%eax
+	movw %ax,(%edi)
+	addl $4,%edi
+	decl %ecx
+	jnz .L46
+
+	femms
+	movl %ebp,%eax
+	popl %ebx
+	popl %esi
+	popl %edi
+	popl %ebp
+	addl $24,%esp
+	ret
+
+NONEXEC_STACK