adding modplug

Original commit message from CVS:
adding modplug

1 files changed, 2277 insertions, 0 deletions

diff --git a/gst/modplug/libmodplug/fastmix.cpp b/gst/modplug/libmodplug/fastmix.cpp
new file mode 100644
index 00000000..0ee94bd0
--- /dev/null
+++ b/gst/modplug/libmodplug/fastmix.cpp
@@ -0,0 +1,2277 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Olivier Lapicque <olivierl@jps.net>
+ *          Markus Fick <webmaster@mark-f.de> spline + fir-resampler
+*/
+
+#include "stdafx.h"
+#include "sndfile.h"
+#include <math.h>
+
+#ifdef MSC_VER
+#pragma bss_seg(".modplug")
+#endif
+
+// Front Mix Buffer (Also room for interleaved rear mix)
+int MixSoundBuffer[MIXBUFFERSIZE*4];
+
+// Reverb Mix Buffer
+#ifndef NO_REVERB
+int MixReverbBuffer[MIXBUFFERSIZE*2];
+extern UINT gnReverbSend;
+#endif
+
+#ifndef FASTSOUNDLIB
+int MixRearBuffer[MIXBUFFERSIZE*2];
+float MixFloatBuffer[MIXBUFFERSIZE*2];
+#endif
+
+#ifdef MSC_VER
+#pragma bss_seg()
+#endif
+
+
+extern LONG gnDryROfsVol;
+extern LONG gnDryLOfsVol;
+extern LONG gnRvbROfsVol;
+extern LONG gnRvbLOfsVol;
+
+// 4x256 taps polyphase FIR resampling filter
+extern short int gFastSinc[];
+extern short int gKaiserSinc[]; // 8-taps polyphase
+/*
+  ------------------------------------------------------------------------------------------------
+   cubic spline interpolation doc,
+	(derived from "digital image warping", g. wolberg)
+
+	interpolation polynomial: f(x) = A3*(x-floor(x))**3 + A2*(x-floor(x))**2 + A1*(x-floor(x)) + A0
+
+	with Y = equispaced data points (dist=1), YD = first derivates of data points and IP = floor(x)
+	the A[0..3] can be found by solving
+	  A0  = Y[IP]
+	  A1  = YD[IP]
+	  A2  = 3*(Y[IP+1]-Y[IP])-2.0*YD[IP]-YD[IP+1]
+	  A3  = -2.0 * (Y[IP+1]-Y[IP]) + YD[IP] - YD[IP+1]
+
+	with the first derivates as
+	  YD[IP]    = 0.5 * (Y[IP+1] - Y[IP-1]);
+	  YD[IP+1]  = 0.5 * (Y[IP+2] - Y[IP])
+
+	the coefs becomes
+	  A0  = Y[IP]
+	  A1  = YD[IP]
+	      =  0.5 * (Y[IP+1] - Y[IP-1]);
+	  A2  =  3.0 * (Y[IP+1]-Y[IP])-2.0*YD[IP]-YD[IP+1]
+	      =  3.0 * (Y[IP+1] - Y[IP]) - 0.5 * 2.0 * (Y[IP+1] - Y[IP-1]) - 0.5 * (Y[IP+2] - Y[IP])
+	      =  3.0 * Y[IP+1] - 3.0 * Y[IP] - Y[IP+1] + Y[IP-1] - 0.5 * Y[IP+2] + 0.5 * Y[IP]
+	      = -0.5 * Y[IP+2] + 2.0 * Y[IP+1] - 2.5 * Y[IP] + Y[IP-1]
+		  = Y[IP-1] + 2 * Y[IP+1] - 0.5 * (5.0 * Y[IP] + Y[IP+2])
+	  A3  = -2.0 * (Y[IP+1]-Y[IP]) + YD[IP] + YD[IP+1]
+	      = -2.0 * Y[IP+1] + 2.0 * Y[IP] + 0.5 * (Y[IP+1] - Y[IP-1]) + 0.5 * (Y[IP+2] - Y[IP])
+	      = -2.0 * Y[IP+1] + 2.0 * Y[IP] + 0.5 * Y[IP+1] - 0.5 * Y[IP-1] + 0.5 * Y[IP+2] - 0.5 * Y[IP]
+	      =  0.5 * Y[IP+2] - 1.5 * Y[IP+1] + 1.5 * Y[IP] - 0.5 * Y[IP-1]
+		  =  0.5 * (3.0 * (Y[IP] - Y[IP+1]) - Y[IP-1] + YP[IP+2])
+
+	then interpolated data value is (horner rule)
+	  out = (((A3*x)+A2)*x+A1)*x+A0
+
+	this gives parts of data points Y[IP-1] to Y[IP+2] of
+	  part       x**3    x**2    x**1    x**0
+	  Y[IP-1]    -0.5     1      -0.5    0
+	  Y[IP]       1.5    -2.5     0      1
+	  Y[IP+1]    -1.5     2       0.5    0
+	  Y[IP+2]     0.5    -0.5     0      0
+  --------------------------------------------------------------------------------------------------
+*/
+// number of bits used to scale spline coefs
+#define SPLINE_QUANTBITS	14
+#define SPLINE_QUANTSCALE	(1L<<SPLINE_QUANTBITS)
+#define SPLINE_8SHIFT		(SPLINE_QUANTBITS-8)
+#define SPLINE_16SHIFT		(SPLINE_QUANTBITS)
+// forces coefsset to unity gain
+#define SPLINE_CLAMPFORUNITY
+// log2(number) of precalculated splines (range is [4..14])
+#define SPLINE_FRACBITS 10
+#define SPLINE_LUTLEN (1L<<SPLINE_FRACBITS)
+
+class CzCUBICSPLINE
+{	public:
+		CzCUBICSPLINE( );
+		~CzCUBICSPLINE( );
+		static signed short lut[4*(1L<<SPLINE_FRACBITS)];
+};
+
+signed short CzCUBICSPLINE::lut[4*(1L<<SPLINE_FRACBITS)];
+
+CzCUBICSPLINE::CzCUBICSPLINE( )
+{	int _LIi;
+	int _LLen		= (1L<<SPLINE_FRACBITS);
+	float _LFlen	= 1.0f / (float)_LLen;
+	float _LScale	= (float)SPLINE_QUANTSCALE;
+	for(_LIi=0;_LIi<_LLen;_LIi++)
+	{	float _LCm1, _LC0, _LC1, _LC2;
+		float _LX		= ((float)_LIi)*_LFlen;
+		int _LSum,_LIdx	= _LIi<<2;
+		_LCm1			= (float)floor( 0.5 + _LScale * (-0.5*_LX*_LX*_LX + 1.0 * _LX*_LX - 0.5 * _LX       ) );
+		_LC0			= (float)floor( 0.5 + _LScale * ( 1.5*_LX*_LX*_LX - 2.5 * _LX*_LX             + 1.0 ) );
+		_LC1			= (float)floor( 0.5 + _LScale * (-1.5*_LX*_LX*_LX + 2.0 * _LX*_LX + 0.5 * _LX       ) );
+		_LC2			= (float)floor( 0.5 + _LScale * ( 0.5*_LX*_LX*_LX - 0.5 * _LX*_LX                   ) );
+		lut[_LIdx+0]	= (signed short)( (_LCm1 < -_LScale) ? -_LScale : ((_LCm1 > _LScale) ? _LScale : _LCm1) );
+		lut[_LIdx+1]	= (signed short)( (_LC0  < -_LScale) ? -_LScale : ((_LC0  > _LScale) ? _LScale : _LC0 ) );
+		lut[_LIdx+2]	= (signed short)( (_LC1  < -_LScale) ? -_LScale : ((_LC1  > _LScale) ? _LScale : _LC1 ) );
+		lut[_LIdx+3]	= (signed short)( (_LC2  < -_LScale) ? -_LScale : ((_LC2  > _LScale) ? _LScale : _LC2 ) );
+#ifdef SPLINE_CLAMPFORUNITY
+		_LSum			= lut[_LIdx+0]+lut[_LIdx+1]+lut[_LIdx+2]+lut[_LIdx+3];
+		if( _LSum != SPLINE_QUANTSCALE )
+		{	int _LMax = _LIdx;
+			if( lut[_LIdx+1]>lut[_LMax] ) _LMax = _LIdx+1;
+			if( lut[_LIdx+2]>lut[_LMax] ) _LMax = _LIdx+2;
+			if( lut[_LIdx+3]>lut[_LMax] ) _LMax = _LIdx+3;
+			lut[_LMax] += (SPLINE_QUANTSCALE-_LSum);
+		}
+#endif
+	}
+}
+
+CzCUBICSPLINE::~CzCUBICSPLINE( )
+{	// nothing todo
+}
+
+CzCUBICSPLINE sspline;
+
+/*
+  ------------------------------------------------------------------------------------------------
+   fir interpolation doc,
+	(derived from "an engineer's guide to fir digital filters", n.j. loy)
+
+	calculate coefficients for ideal lowpass filter (with cutoff = fc in 0..1 (mapped to 0..nyquist))
+	  c[-N..N] = (i==0) ? fc : sin(fc*pi*i)/(pi*i)
+
+	then apply selected window to coefficients
+	  c[-N..N] *= w(0..N)
+	with n in 2*N and w(n) being a window function (see loy)
+
+	then calculate gain and scale filter coefs to have unity gain.
+  ------------------------------------------------------------------------------------------------
+*/
+// quantizer scale of window coefs
+#define WFIR_QUANTBITS		15
+#define WFIR_QUANTSCALE		(1L<<WFIR_QUANTBITS)
+#define WFIR_8SHIFT			(WFIR_QUANTBITS-8)
+#define WFIR_16BITSHIFT		(WFIR_QUANTBITS)
+// log2(number)-1 of precalculated taps range is [4..12]
+#define WFIR_FRACBITS		10
+#define WFIR_LUTLEN			((1L<<(WFIR_FRACBITS+1))+1)
+// number of samples in window
+#define WFIR_LOG2WIDTH		3
+#define WFIR_WIDTH			(1L<<WFIR_LOG2WIDTH)
+#define WFIR_SMPSPERWING	((WFIR_WIDTH-1)>>1)
+// cutoff (1.0 == pi/2)
+#define WFIR_CUTOFF			0.90f
+// wfir type
+#define WFIR_HANN			0
+#define WFIR_HAMMING		1
+#define WFIR_BLACKMANEXACT	2
+#define WFIR_BLACKMAN3T61	3
+#define WFIR_BLACKMAN3T67	4
+#define WFIR_BLACKMAN4T92	5
+#define WFIR_BLACKMAN4T74	6
+#define WFIR_KAISER4T		7
+#define WFIR_TYPE			WFIR_BLACKMANEXACT
+// wfir help
+#ifndef M_zPI
+#define M_zPI			3.1415926535897932384626433832795
+#endif
+#define M_zEPS			1e-8
+#define M_zBESSELEPS	1e-21
+
+class CzWINDOWEDFIR
+{	public:
+		CzWINDOWEDFIR( );
+		~CzWINDOWEDFIR( );
+		float coef( int _PCnr, float _POfs, float _PCut, int _PWidth, int _PType ) //float _PPos, float _PFc, int _PLen )
+		{	double	_LWidthM1		= _PWidth-1;
+			double	_LWidthM1Half	= 0.5*_LWidthM1;
+			double	_LPosU			= ((double)_PCnr - _POfs);
+			double	_LPos			= _LPosU-_LWidthM1Half;
+			double	_LPIdl			= 2.0*M_zPI/_LWidthM1;
+			double	_LWc,_LSi;
+			if( fabs(_LPos)<M_zEPS )
+			{	_LWc	= 1.0;
+				_LSi	= _PCut;
+			}
+			else
+			{	switch( _PType )
+				{	case WFIR_HANN:
+						_LWc = 0.50 - 0.50 * cos(_LPIdl*_LPosU);
+						break;
+					case WFIR_HAMMING:
+						_LWc = 0.54 - 0.46 * cos(_LPIdl*_LPosU);
+						break;
+					case WFIR_BLACKMANEXACT:
+						_LWc = 0.42 - 0.50 * cos(_LPIdl*_LPosU) + 0.08 * cos(2.0*_LPIdl*_LPosU);
+						break;
+					case WFIR_BLACKMAN3T61:
+						_LWc = 0.44959 - 0.49364 * cos(_LPIdl*_LPosU) + 0.05677 * cos(2.0*_LPIdl*_LPosU);
+						break;
+					case WFIR_BLACKMAN3T67:
+						_LWc = 0.42323 - 0.49755 * cos(_LPIdl*_LPosU) + 0.07922 * cos(2.0*_LPIdl*_LPosU);
+						break;
+					case WFIR_BLACKMAN4T92:
+						_LWc = 0.35875 - 0.48829 * cos(_LPIdl*_LPosU) + 0.14128 * cos(2.0*_LPIdl*_LPosU) - 0.01168 * cos(3.0*_LPIdl*_LPosU);
+						break;
+					case WFIR_BLACKMAN4T74:
+						_LWc = 0.40217 - 0.49703 * cos(_LPIdl*_LPosU) + 0.09392 * cos(2.0*_LPIdl*_LPosU) - 0.00183 * cos(3.0*_LPIdl*_LPosU);
+						break;
+					case WFIR_KAISER4T:
+						_LWc = 0.40243 - 0.49804 * cos(_LPIdl*_LPosU) + 0.09831 * cos(2.0*_LPIdl*_LPosU) - 0.00122 * cos(3.0*_LPIdl*_LPosU);
+						break;
+					default:
+						_LWc = 1.0;
+						break;
+				}
+				_LPos	 *= M_zPI;
+				_LSi	 = sin(_PCut*_LPos)/_LPos;
+			}
+			return (float)(_LWc*_LSi);
+		}
+		static signed short lut[WFIR_LUTLEN*WFIR_WIDTH];
+};
+
+signed short CzWINDOWEDFIR::lut[WFIR_LUTLEN*WFIR_WIDTH];
+
+CzWINDOWEDFIR::CzWINDOWEDFIR()
+{	int _LPcl;
+	float _LPcllen	= (float)(1L<<WFIR_FRACBITS);	// number of precalculated lines for 0..1 (-1..0)
+	float _LNorm	= 1.0f / (float)(2.0f * _LPcllen);
+	float _LCut		= WFIR_CUTOFF;
+	float _LScale	= (float)WFIR_QUANTSCALE;
+	for( _LPcl=0;_LPcl<WFIR_LUTLEN;_LPcl++ )
+	{	float _LGain,_LCoefs[WFIR_WIDTH];
+		float _LOfs		= ((float)_LPcl-_LPcllen)*_LNorm;
+		int _LCc,_LIdx	= _LPcl<<WFIR_LOG2WIDTH;
+		for( _LCc=0,_LGain=0.0f;_LCc<WFIR_WIDTH;_LCc++ )
+		{	_LGain	+= (_LCoefs[_LCc] = coef( _LCc, _LOfs, _LCut, WFIR_WIDTH, WFIR_TYPE ));
+		}
+		_LGain = 1.0f/_LGain;
+		for( _LCc=0;_LCc<WFIR_WIDTH;_LCc++ )
+		{	float _LCoef = (float)floor( 0.5 + _LScale*_LCoefs[_LCc]*_LGain );
+			lut[_LIdx+_LCc] = (signed short)( (_LCoef<-_LScale)?-_LScale:((_LCoef>_LScale)?_LScale:_LCoef) );
+		}
+	}
+}
+
+CzWINDOWEDFIR::~CzWINDOWEDFIR()
+{	// nothing todo
+}
+
+CzWINDOWEDFIR sfir;
+
+// ------------------------------------------------------------------------------------------------
+// MIXING MACROS
+// ------------------------------------------------------------------------------------------------
+/////////////////////////////////////////////////////
+// Mixing Macros
+
+#define SNDMIX_BEGINSAMPLELOOP8\
+	register MODCHANNEL * const pChn = pChannel;\
+	nPos = pChn->nPosLo;\
+	const signed char *p = (signed char *)(pChn->pCurrentSample+pChn->nPos);\
+	if (pChn->dwFlags & CHN_STEREO) p += pChn->nPos;\
+	int *pvol = pbuffer;\
+	do {
+
+#define SNDMIX_BEGINSAMPLELOOP16\
+	register MODCHANNEL * const pChn = pChannel;\
+	nPos = pChn->nPosLo;\
+	const signed short *p = (signed short *)(pChn->pCurrentSample+(pChn->nPos*2));\
+	if (pChn->dwFlags & CHN_STEREO) p += pChn->nPos;\
+	int *pvol = pbuffer;\
+	do {
+
+#define SNDMIX_ENDSAMPLELOOP\
+		nPos += pChn->nInc;\
+	} while (pvol < pbufmax);\
+	pChn->nPos += nPos >> 16;\
+	pChn->nPosLo = nPos & 0xFFFF;
+
+#define SNDMIX_ENDSAMPLELOOP8	SNDMIX_ENDSAMPLELOOP
+#define SNDMIX_ENDSAMPLELOOP16	SNDMIX_ENDSAMPLELOOP
+
+//////////////////////////////////////////////////////////////////////////////
+// Mono
+
+// No interpolation
+#define SNDMIX_GETMONOVOL8NOIDO\
+	int vol = p[nPos >> 16] << 8;
+
+#define SNDMIX_GETMONOVOL16NOIDO\
+	int vol = p[nPos >> 16];
+
+// Linear Interpolation
+#define SNDMIX_GETMONOVOL8LINEAR\
+	int poshi = nPos >> 16;\
+	int poslo = (nPos >> 8) & 0xFF;\
+	int srcvol = p[poshi];\
+	int destvol = p[poshi+1];\
+	int vol = (srcvol<<8) + ((int)(poslo * (destvol - srcvol)));
+
+#define SNDMIX_GETMONOVOL16LINEAR\
+	int poshi = nPos >> 16;\
+	int poslo = (nPos >> 8) & 0xFF;\
+	int srcvol = p[poshi];\
+	int destvol = p[poshi+1];\
+	int vol = srcvol + ((int)(poslo * (destvol - srcvol)) >> 8);
+
+// spline interpolation (2 guard bits should be enough???)
+#define SPLINE_FRACSHIFT ((16-SPLINE_FRACBITS)-2)
+#define SPLINE_FRACMASK  (((1L<<(16-SPLINE_FRACSHIFT))-1)&~3)
+
+#define SNDMIX_GETMONOVOL8SPLINE \
+	int poshi	= nPos >> 16; \
+	int poslo	= (nPos >> SPLINE_FRACSHIFT) & SPLINE_FRACMASK; \
+	int vol		= (CzCUBICSPLINE::lut[poslo  ]*(int)p[poshi-1] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[poshi  ] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[poshi+2] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[poshi+1]) >> SPLINE_8SHIFT;
+
+#define SNDMIX_GETMONOVOL16SPLINE \
+	int poshi	= nPos >> 16; \
+	int poslo	= (nPos >> SPLINE_FRACSHIFT) & SPLINE_FRACMASK; \
+	int vol		= (CzCUBICSPLINE::lut[poslo  ]*(int)p[poshi-1] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[poshi  ] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[poshi+2] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[poshi+1]) >> SPLINE_16SHIFT;
+
+
+// fir interpolation
+#define WFIR_FRACSHIFT	(16-(WFIR_FRACBITS+1+WFIR_LOG2WIDTH))
+#define WFIR_FRACMASK	((((1L<<(17-WFIR_FRACSHIFT))-1)&~((1L<<WFIR_LOG2WIDTH)-1)))
+#define WFIR_FRACHALVE	(1L<<(16-(WFIR_FRACBITS+2)))
+
+#define SNDMIX_GETMONOVOL8FIRFILTER \
+	int poshi  = nPos >> 16;\
+	int poslo  = (nPos & 0xFFFF);\
+	int firidx = ((poslo+WFIR_FRACHALVE)>>WFIR_FRACSHIFT) & WFIR_FRACMASK; \
+	int vol    = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[poshi+1-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[poshi+2-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[poshi+3-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[poshi+4-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+4]*(int)p[poshi+5-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[poshi+6-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[poshi+7-4]);	\
+		vol   += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[poshi+8-4]);	\
+		vol  >>= WFIR_8SHIFT;
+
+#define SNDMIX_GETMONOVOL16FIRFILTER \
+	int poshi  = nPos >> 16;\
+	int poslo  = (nPos & 0xFFFF);\
+	int firidx = ((poslo+WFIR_FRACHALVE)>>WFIR_FRACSHIFT) & WFIR_FRACMASK; \
+    int vol1   = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[poshi+1-4]);	\
+		vol1  += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[poshi+2-4]);	\
+		vol1  += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[poshi+3-4]);	\
+		vol1  += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[poshi+4-4]);	\
+	int vol2   = (CzWINDOWEDFIR::lut[firidx+4]*(int)p[poshi+5-4]);	\
+		vol2  += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[poshi+6-4]);	\
+		vol2  += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[poshi+7-4]);	\
+		vol2  += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[poshi+8-4]);	\
+	int vol	   = ((vol1>>1)+(vol2>>1)) >> (WFIR_16BITSHIFT-1);
+
+/////////////////////////////////////////////////////////////////////////////
+// Stereo
+
+// No interpolation
+#define SNDMIX_GETSTEREOVOL8NOIDO\
+	int vol_l = p[(nPos>>16)*2] << 8;\
+	int vol_r = p[(nPos>>16)*2+1] << 8;
+
+#define SNDMIX_GETSTEREOVOL16NOIDO\
+	int vol_l = p[(nPos>>16)*2];\
+	int vol_r = p[(nPos>>16)*2+1];
+
+// Linear Interpolation
+#define SNDMIX_GETSTEREOVOL8LINEAR\
+	int poshi = nPos >> 16;\
+	int poslo = (nPos >> 8) & 0xFF;\
+	int srcvol_l = p[poshi*2];\
+	int vol_l = (srcvol_l<<8) + ((int)(poslo * (p[poshi*2+2] - srcvol_l)));\
+	int srcvol_r = p[poshi*2+1];\
+	int vol_r = (srcvol_r<<8) + ((int)(poslo * (p[poshi*2+3] - srcvol_r)));
+
+#define SNDMIX_GETSTEREOVOL16LINEAR\
+	int poshi = nPos >> 16;\
+	int poslo = (nPos >> 8) & 0xFF;\
+	int srcvol_l = p[poshi*2];\
+	int vol_l = srcvol_l + ((int)(poslo * (p[poshi*2+2] - srcvol_l)) >> 8);\
+	int srcvol_r = p[poshi*2+1];\
+	int vol_r = srcvol_r + ((int)(poslo * (p[poshi*2+3] - srcvol_r)) >> 8);\
+
+// Spline Interpolation
+#define SNDMIX_GETSTEREOVOL8SPLINE \
+	int poshi	= nPos >> 16; \
+	int poslo	= (nPos >> SPLINE_FRACSHIFT) & SPLINE_FRACMASK; \
+	int vol_l	= (CzCUBICSPLINE::lut[poslo  ]*(int)p[(poshi-1)*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[(poshi  )*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[(poshi+1)*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[(poshi+2)*2  ]) >> SPLINE_8SHIFT; \
+	int vol_r	= (CzCUBICSPLINE::lut[poslo  ]*(int)p[(poshi-1)*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[(poshi  )*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[(poshi+1)*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[(poshi+2)*2+1]) >> SPLINE_8SHIFT;
+
+#define SNDMIX_GETSTEREOVOL16SPLINE \
+	int poshi	= nPos >> 16; \
+	int poslo	= (nPos >> SPLINE_FRACSHIFT) & SPLINE_FRACMASK; \
+	int vol_l	= (CzCUBICSPLINE::lut[poslo  ]*(int)p[(poshi-1)*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[(poshi  )*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[(poshi+1)*2  ] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[(poshi+2)*2  ]) >> SPLINE_16SHIFT; \
+	int vol_r	= (CzCUBICSPLINE::lut[poslo  ]*(int)p[(poshi-1)*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+1]*(int)p[(poshi  )*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+2]*(int)p[(poshi+1)*2+1] + \
+	               CzCUBICSPLINE::lut[poslo+3]*(int)p[(poshi+2)*2+1]) >> SPLINE_16SHIFT;
+
+// fir interpolation
+#define SNDMIX_GETSTEREOVOL8FIRFILTER \
+	int poshi   = nPos >> 16;\
+	int poslo   = (nPos & 0xFFFF);\
+	int firidx  = ((poslo+WFIR_FRACHALVE)>>WFIR_FRACSHIFT) & WFIR_FRACMASK; \
+	int vol_l   = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[(poshi+1-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[(poshi+2-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[(poshi+3-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[(poshi+4-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+4]*(int)p[(poshi+5-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[(poshi+6-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[(poshi+7-4)*2  ]);	\
+		vol_l  += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[(poshi+8-4)*2  ]);	\
+		vol_l >>= WFIR_8SHIFT; \
+	int vol_r   = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[(poshi+1-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[(poshi+2-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[(poshi+3-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[(poshi+4-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+4]*(int)p[(poshi+5-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[(poshi+6-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[(poshi+7-4)*2+1]);	\
+		vol_r  += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[(poshi+8-4)*2+1]);	\
+		vol_r >>= WFIR_8SHIFT;
+
+#define SNDMIX_GETSTEREOVOL16FIRFILTER \
+	int poshi   = nPos >> 16;\
+	int poslo   = (nPos & 0xFFFF);\
+	int firidx  = ((poslo+WFIR_FRACHALVE)>>WFIR_FRACSHIFT) & WFIR_FRACMASK; \
+    int vol1_l  = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[(poshi+1-4)*2  ]);	\
+		vol1_l += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[(poshi+2-4)*2  ]);	\
+		vol1_l += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[(poshi+3-4)*2  ]);	\
+		vol1_l += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[(poshi+4-4)*2  ]);	\
+	int vol2_l  = (CzWINDOWEDFIR::lut[firidx+4]*(int)p[(poshi+5-4)*2  ]);	\
+		vol2_l += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[(poshi+6-4)*2  ]);	\
+		vol2_l += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[(poshi+7-4)*2  ]);	\
+		vol2_l += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[(poshi+8-4)*2  ]);	\
+	int vol_l   = ((vol1_l>>1)+(vol2_l>>1)) >> (WFIR_16BITSHIFT-1); \
+	int vol1_r  = (CzWINDOWEDFIR::lut[firidx+0]*(int)p[(poshi+1-4)*2+1]);	\
+		vol1_r += (CzWINDOWEDFIR::lut[firidx+1]*(int)p[(poshi+2-4)*2+1]);	\
+		vol1_r += (CzWINDOWEDFIR::lut[firidx+2]*(int)p[(poshi+3-4)*2+1]);	\
+		vol1_r += (CzWINDOWEDFIR::lut[firidx+3]*(int)p[(poshi+4-4)*2+1]);	\
+	int vol2_r  = (CzWINDOWEDFIR::lut[firidx+4]*(int)p[(poshi+5-4)*2+1]);	\
+		vol2_r += (CzWINDOWEDFIR::lut[firidx+5]*(int)p[(poshi+6-4)*2+1]);	\
+		vol2_r += (CzWINDOWEDFIR::lut[firidx+6]*(int)p[(poshi+7-4)*2+1]);	\
+		vol2_r += (CzWINDOWEDFIR::lut[firidx+7]*(int)p[(poshi+8-4)*2+1]);	\
+	int vol_r   = ((vol1_r>>1)+(vol2_r>>1)) >> (WFIR_16BITSHIFT-1);
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+#define SNDMIX_STOREMONOVOL\
+	pvol[0] += vol * pChn->nRightVol;\
+	pvol[1] += vol * pChn->nLeftVol;\
+	pvol += 2;
+
+#define SNDMIX_STORESTEREOVOL\
+	pvol[0] += vol_l * pChn->nRightVol;\
+	pvol[1] += vol_r * pChn->nLeftVol;\
+	pvol += 2;
+
+#define SNDMIX_STOREFASTMONOVOL\
+	int v = vol * pChn->nRightVol;\
+	pvol[0] += v;\
+	pvol[1] += v;\
+	pvol += 2;
+
+#define SNDMIX_RAMPMONOVOL\
+	nRampLeftVol += pChn->nLeftRamp;\
+	nRampRightVol += pChn->nRightRamp;\
+	pvol[0] += vol * (nRampRightVol >> VOLUMERAMPPRECISION);\
+	pvol[1] += vol * (nRampLeftVol >> VOLUMERAMPPRECISION);\
+	pvol += 2;
+
+#define SNDMIX_RAMPFASTMONOVOL\
+	nRampRightVol += pChn->nRightRamp;\
+	int fastvol = vol * (nRampRightVol >> VOLUMERAMPPRECISION);\
+	pvol[0] += fastvol;\
+	pvol[1] += fastvol;\
+	pvol += 2;
+
+#define SNDMIX_RAMPSTEREOVOL\
+	nRampLeftVol += pChn->nLeftRamp;\
+	nRampRightVol += pChn->nRightRamp;\
+	pvol[0] += vol_l * (nRampRightVol >> VOLUMERAMPPRECISION);\
+	pvol[1] += vol_r * (nRampLeftVol >> VOLUMERAMPPRECISION);\
+	pvol += 2;
+
+
+///////////////////////////////////////////////////
+// Resonant Filters
+
+// Mono
+#define MIX_BEGIN_FILTER\
+	int fy1 = pChannel->nFilter_Y1;\
+	int fy2 = pChannel->nFilter_Y2;\
+
+#define MIX_END_FILTER\
+	pChannel->nFilter_Y1 = fy1;\
+	pChannel->nFilter_Y2 = fy2;
+
+#define SNDMIX_PROCESSFILTER\
+	vol = (vol * pChn->nFilter_A0 + fy1 * pChn->nFilter_B0 + fy2 * pChn->nFilter_B1 + 4096) >> 13;\
+	fy2 = fy1;\
+	fy1 = vol;\
+
+// Stereo
+#define MIX_BEGIN_STEREO_FILTER\
+	int fy1 = pChannel->nFilter_Y1;\
+	int fy2 = pChannel->nFilter_Y2;\
+	int fy3 = pChannel->nFilter_Y3;\
+	int fy4 = pChannel->nFilter_Y4;\
+
+#define MIX_END_STEREO_FILTER\
+	pChannel->nFilter_Y1 = fy1;\
+	pChannel->nFilter_Y2 = fy2;\
+	pChannel->nFilter_Y3 = fy3;\
+	pChannel->nFilter_Y4 = fy4;\
+
+#define SNDMIX_PROCESSSTEREOFILTER\
+	vol_l = (vol_l * pChn->nFilter_A0 + fy1 * pChn->nFilter_B0 + fy2 * pChn->nFilter_B1 + 4096) >> 13;\
+	vol_r = (vol_r * pChn->nFilter_A0 + fy3 * pChn->nFilter_B0 + fy4 * pChn->nFilter_B1 + 4096) >> 13;\
+	fy2 = fy1; fy1 = vol_l;\
+	fy4 = fy3; fy3 = vol_r;\
+
+//////////////////////////////////////////////////////////
+// Interfaces
+
+typedef VOID (MPPASMCALL * LPMIXINTERFACE)(MODCHANNEL *, int *, int *);
+
+#define BEGIN_MIX_INTERFACE(func)\
+	VOID MPPASMCALL func(MODCHANNEL *pChannel, int *pbuffer, int *pbufmax)\
+	{\
+		LONG nPos;
+
+#define END_MIX_INTERFACE()\
+		SNDMIX_ENDSAMPLELOOP\
+	}
+
+// Volume Ramps
+#define BEGIN_RAMPMIX_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+		LONG nRampRightVol = pChannel->nRampRightVol;\
+		LONG nRampLeftVol = pChannel->nRampLeftVol;
+
+#define END_RAMPMIX_INTERFACE()\
+		SNDMIX_ENDSAMPLELOOP\
+		pChannel->nRampRightVol = nRampRightVol;\
+		pChannel->nRightVol = nRampRightVol >> VOLUMERAMPPRECISION;\
+		pChannel->nRampLeftVol = nRampLeftVol;\
+		pChannel->nLeftVol = nRampLeftVol >> VOLUMERAMPPRECISION;\
+	}
+
+#define BEGIN_FASTRAMPMIX_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+		LONG nRampRightVol = pChannel->nRampRightVol;
+
+#define END_FASTRAMPMIX_INTERFACE()\
+		SNDMIX_ENDSAMPLELOOP\
+		pChannel->nRampRightVol = nRampRightVol;\
+		pChannel->nRampLeftVol = nRampRightVol;\
+		pChannel->nRightVol = nRampRightVol >> VOLUMERAMPPRECISION;\
+		pChannel->nLeftVol = pChannel->nRightVol;\
+	}
+
+
+// Mono Resonant Filters
+#define BEGIN_MIX_FLT_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+	MIX_BEGIN_FILTER
+
+
+#define END_MIX_FLT_INTERFACE()\
+	SNDMIX_ENDSAMPLELOOP\
+	MIX_END_FILTER\
+	}
+
+#define BEGIN_RAMPMIX_FLT_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+		LONG nRampRightVol = pChannel->nRampRightVol;\
+		LONG nRampLeftVol = pChannel->nRampLeftVol;\
+		MIX_BEGIN_FILTER
+
+#define END_RAMPMIX_FLT_INTERFACE()\
+		SNDMIX_ENDSAMPLELOOP\
+		MIX_END_FILTER\
+		pChannel->nRampRightVol = nRampRightVol;\
+		pChannel->nRightVol = nRampRightVol >> VOLUMERAMPPRECISION;\
+		pChannel->nRampLeftVol = nRampLeftVol;\
+		pChannel->nLeftVol = nRampLeftVol >> VOLUMERAMPPRECISION;\
+	}
+
+// Stereo Resonant Filters
+#define BEGIN_MIX_STFLT_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+	MIX_BEGIN_STEREO_FILTER
+
+
+#define END_MIX_STFLT_INTERFACE()\
+	SNDMIX_ENDSAMPLELOOP\
+	MIX_END_STEREO_FILTER\
+	}
+
+#define BEGIN_RAMPMIX_STFLT_INTERFACE(func)\
+	BEGIN_MIX_INTERFACE(func)\
+		LONG nRampRightVol = pChannel->nRampRightVol;\
+		LONG nRampLeftVol = pChannel->nRampLeftVol;\
+		MIX_BEGIN_STEREO_FILTER
+
+#define END_RAMPMIX_STFLT_INTERFACE()\
+		SNDMIX_ENDSAMPLELOOP\
+		MIX_END_STEREO_FILTER\
+		pChannel->nRampRightVol = nRampRightVol;\
+		pChannel->nRightVol = nRampRightVol >> VOLUMERAMPPRECISION;\
+		pChannel->nRampLeftVol = nRampLeftVol;\
+		pChannel->nLeftVol = nRampLeftVol >> VOLUMERAMPPRECISION;\
+	}
+
+
+/////////////////////////////////////////////////////
+//
+
+void MPPASMCALL X86_InitMixBuffer(int *pBuffer, UINT nSamples);
+void MPPASMCALL X86_EndChannelOfs(MODCHANNEL *pChannel, int *pBuffer, UINT nSamples);
+void MPPASMCALL X86_StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs);
+void X86_StereoMixToFloat(const int *, float *, float *, UINT nCount);
+void X86_FloatToStereoMix(const float *pIn1, const float *pIn2, int *pOut, UINT nCount);
+
+/////////////////////////////////////////////////////
+// Mono samples functions
+
+BEGIN_MIX_INTERFACE(Mono8BitMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono16BitMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono8BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono16BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono8BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono16BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono8BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Mono16BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_INTERFACE()
+
+
+// Volume Ramps
+BEGIN_RAMPMIX_INTERFACE(Mono8BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono16BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono8BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono16BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono8BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono16BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono8BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Mono16BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_INTERFACE()
+
+
+//////////////////////////////////////////////////////
+// Fast mono mix for leftvol=rightvol (1 less imul)
+
+BEGIN_MIX_INTERFACE(FastMono8BitMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono16BitMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono8BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono16BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono8BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono16BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono8BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(FastMono16BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_STOREFASTMONOVOL
+END_MIX_INTERFACE()
+
+
+// Fast Ramps
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono8BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono16BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono8BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono16BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono8BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono16BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono8BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+BEGIN_FASTRAMPMIX_INTERFACE(FastMono16BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_RAMPFASTMONOVOL
+END_FASTRAMPMIX_INTERFACE()
+
+
+//////////////////////////////////////////////////////
+// Stereo samples
+
+BEGIN_MIX_INTERFACE(Stereo8BitMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8NOIDO
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo16BitMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16NOIDO
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo8BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8LINEAR
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo16BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16LINEAR
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo8BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8SPLINE
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo16BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16SPLINE
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo8BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8FIRFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+BEGIN_MIX_INTERFACE(Stereo16BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16FIRFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_INTERFACE()
+
+
+// Volume Ramps
+BEGIN_RAMPMIX_INTERFACE(Stereo8BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8NOIDO
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo16BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16NOIDO
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo8BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8LINEAR
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo16BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16LINEAR
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo8BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8SPLINE
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo16BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16SPLINE
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo8BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8FIRFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+BEGIN_RAMPMIX_INTERFACE(Stereo16BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16FIRFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_INTERFACE()
+
+
+
+//////////////////////////////////////////////////////
+// Resonant Filter Mix
+
+#ifndef NO_FILTER
+
+// Mono Filter Mix
+BEGIN_MIX_FLT_INTERFACE(FilterMono8BitMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono16BitMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono8BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono16BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono8BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono16BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono8BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+BEGIN_MIX_FLT_INTERFACE(FilterMono16BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_PROCESSFILTER
+	SNDMIX_STOREMONOVOL
+END_MIX_FLT_INTERFACE()
+
+// Filter + Ramp
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono8BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8NOIDO
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono16BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16NOIDO
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono8BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8LINEAR
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono16BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16LINEAR
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono8BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8SPLINE
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono16BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16SPLINE
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono8BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETMONOVOL8FIRFILTER
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+BEGIN_RAMPMIX_FLT_INTERFACE(FilterMono16BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETMONOVOL16FIRFILTER
+	SNDMIX_PROCESSFILTER
+	SNDMIX_RAMPMONOVOL
+END_RAMPMIX_FLT_INTERFACE()
+
+
+// Stereo Filter Mix
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo8BitMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8NOIDO
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo16BitMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16NOIDO
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo8BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8LINEAR
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo16BitLinearMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16LINEAR
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo8BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8SPLINE
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo16BitSplineMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16SPLINE
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo8BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8FIRFILTER
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+BEGIN_MIX_STFLT_INTERFACE(FilterStereo16BitFirFilterMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16FIRFILTER
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_STORESTEREOVOL
+END_MIX_STFLT_INTERFACE()
+
+// Stereo Filter + Ramp
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo8BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8NOIDO
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo16BitRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16NOIDO
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo8BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8LINEAR
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo16BitLinearRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16LINEAR
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo8BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8SPLINE
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo16BitSplineRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16SPLINE
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo8BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP8
+	SNDMIX_GETSTEREOVOL8FIRFILTER
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+BEGIN_RAMPMIX_STFLT_INTERFACE(FilterStereo16BitFirFilterRampMix)
+	SNDMIX_BEGINSAMPLELOOP16
+	SNDMIX_GETSTEREOVOL16FIRFILTER
+	SNDMIX_PROCESSSTEREOFILTER
+	SNDMIX_RAMPSTEREOVOL
+END_RAMPMIX_STFLT_INTERFACE()
+
+
+#else
+// Mono
+#define FilterMono8BitMix					Mono8BitMix
+#define FilterMono16BitMix					Mono16BitMix
+#define FilterMono8BitLinearMix				Mono8BitLinearMix
+#define FilterMono16BitLinearMix			Mono16BitLinearMix
+#define FilterMono8BitSplineMix				Mono8BitSplineMix
+#define FilterMono16BitSplineMix			Mono16BitSplineMix
+#define FilterMono8BitFirFilterMix			Mono8BitFirFilterMix
+#define FilterMono16BitFirFilterMix			Mono16BitFirFilterMix
+#define FilterMono8BitRampMix				Mono8BitRampMix
+#define FilterMono16BitRampMix				Mono16BitRampMix
+#define FilterMono8BitLinearRampMix			Mono8BitLinearRampMix
+#define FilterMono16BitLinearRampMix		Mono16BitLinearRampMix
+#define FilterMono8BitSplineRampMix			Mono8BitSplineRampMix
+#define FilterMono16BitSplineRampMix		Mono16BitSplineRampMix
+#define FilterMono8BitFirFilterRampMix		Mono8BitFirFilterRampMix
+#define FilterMono16BitFirFilterRampMix		Mono16BitFirFilterRampMix
+// Stereo
+#define FilterStereo8BitMix					Stereo8BitMix
+#define FilterStereo16BitMix				Stereo16BitMix
+#define FilterStereo8BitLinearMix			Stereo8BitLinearMix
+#define FilterStereo16BitLinearMix			Stereo16BitLinearMix
+#define FilterStereo8BitSplineMix			Stereo8BitSplineMix
+#define FilterStereo16BitSplineMix			Stereo16BitSplineMix
+#define FilterStereo8BitFirFilterMix		Stereo8BitFirFilterMix
+#define FilterStereo16BitFirFilterMix		Stereo16BitFirFilterMix
+#define FilterStereo8BitRampMix				Stereo8BitRampMix
+#define FilterStereo16BitRampMix			Stereo16BitRampMix
+#define FilterStereo8BitLinearRampMix		Stereo8BitLinearRampMix
+#define FilterStereo16BitLinearRampMix		Stereo16BitLinearRampMix
+#define FilterStereo8BitSplineRampMix		Stereo8BitSplineRampMix
+#define FilterStereo16BitSplineRampMix		Stereo16BitSplineRampMix
+#define FilterStereo8BitFirFilterRampMix	Stereo8BitFirFilterRampMix
+#define FilterStereo16BitFirFilterRampMix	Stereo16BitFirFilterRampMix
+
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////
+//
+// Mix function tables
+//
+//
+// Index is as follow:
+//	[b1-b0]	format (8-bit-mono, 16-bit-mono, 8-bit-stereo, 16-bit-stereo)
+//	[b2]	ramp
+//	[b3]	filter
+//	[b5-b4]	src type
+//
+
+#define MIXNDX_16BIT		0x01
+#define MIXNDX_STEREO		0x02
+#define MIXNDX_RAMP			0x04
+#define MIXNDX_FILTER		0x08
+#define MIXNDX_LINEARSRC	0x10
+#define MIXNDX_SPLINESRC    0x20
+#define MIXNDX_FIRSRC     	0x30
+
+const LPMIXINTERFACE gpMixFunctionTable[2*2*16] =
+{
+	// No SRC
+	Mono8BitMix,				Mono16BitMix,				Stereo8BitMix,			Stereo16BitMix,
+	Mono8BitRampMix,			Mono16BitRampMix,			Stereo8BitRampMix,		Stereo16BitRampMix,
+	// No SRC, Filter
+	FilterMono8BitMix,			FilterMono16BitMix,			FilterStereo8BitMix,	FilterStereo16BitMix,
+	FilterMono8BitRampMix,		FilterMono16BitRampMix,		FilterStereo8BitRampMix,FilterStereo16BitRampMix,
+	// Linear SRC
+	Mono8BitLinearMix,			Mono16BitLinearMix,			Stereo8BitLinearMix,	Stereo16BitLinearMix,
+	Mono8BitLinearRampMix,		Mono16BitLinearRampMix,		Stereo8BitLinearRampMix,Stereo16BitLinearRampMix,
+	// Linear SRC, Filter
+	FilterMono8BitLinearMix,	FilterMono16BitLinearMix,	FilterStereo8BitLinearMix,	FilterStereo16BitLinearMix,
+	FilterMono8BitLinearRampMix,FilterMono16BitLinearRampMix,FilterStereo8BitLinearRampMix,FilterStereo16BitLinearRampMix,
+
+	// FirFilter SRC
+	Mono8BitSplineMix,			Mono16BitSplineMix,			Stereo8BitSplineMix,	Stereo16BitSplineMix,
+	Mono8BitSplineRampMix,		Mono16BitSplineRampMix,		Stereo8BitSplineRampMix,Stereo16BitSplineRampMix,
+	// Spline SRC, Filter
+	FilterMono8BitSplineMix,	FilterMono16BitSplineMix,	FilterStereo8BitSplineMix,	FilterStereo16BitSplineMix,
+	FilterMono8BitSplineRampMix,FilterMono16BitSplineRampMix,FilterStereo8BitSplineRampMix,FilterStereo16BitSplineRampMix,
+
+	// FirFilter  SRC
+	Mono8BitFirFilterMix,			Mono16BitFirFilterMix,			Stereo8BitFirFilterMix,	Stereo16BitFirFilterMix,
+	Mono8BitFirFilterRampMix,		Mono16BitFirFilterRampMix,		Stereo8BitFirFilterRampMix,Stereo16BitFirFilterRampMix,
+	// FirFilter  SRC, Filter
+	FilterMono8BitFirFilterMix,	FilterMono16BitFirFilterMix,	FilterStereo8BitFirFilterMix,	FilterStereo16BitFirFilterMix,
+	FilterMono8BitFirFilterRampMix,FilterMono16BitFirFilterRampMix,FilterStereo8BitFirFilterRampMix,FilterStereo16BitFirFilterRampMix
+};
+
+const LPMIXINTERFACE gpFastMixFunctionTable[2*2*16] =
+{
+	// No SRC
+	FastMono8BitMix,			FastMono16BitMix,			Stereo8BitMix,			Stereo16BitMix,
+	FastMono8BitRampMix,		FastMono16BitRampMix,		Stereo8BitRampMix,		Stereo16BitRampMix,
+	// No SRC, Filter
+	FilterMono8BitMix,			FilterMono16BitMix,			FilterStereo8BitMix,	FilterStereo16BitMix,
+	FilterMono8BitRampMix,		FilterMono16BitRampMix,		FilterStereo8BitRampMix,FilterStereo16BitRampMix,
+	// Linear SRC
+	FastMono8BitLinearMix,		FastMono16BitLinearMix,		Stereo8BitLinearMix,	Stereo16BitLinearMix,
+	FastMono8BitLinearRampMix,	FastMono16BitLinearRampMix,	Stereo8BitLinearRampMix,Stereo16BitLinearRampMix,
+	// Linear SRC, Filter
+	FilterMono8BitLinearMix,	FilterMono16BitLinearMix,	FilterStereo8BitLinearMix,	FilterStereo16BitLinearMix,
+	FilterMono8BitLinearRampMix,FilterMono16BitLinearRampMix,FilterStereo8BitLinearRampMix,FilterStereo16BitLinearRampMix,
+
+	// Spline SRC
+	Mono8BitSplineMix,		Mono16BitSplineMix,		Stereo8BitSplineMix,	Stereo16BitSplineMix,
+	Mono8BitSplineRampMix,	Mono16BitSplineRampMix,	Stereo8BitSplineRampMix,Stereo16BitSplineRampMix,
+	// Spline SRC, Filter
+	FilterMono8BitSplineMix,	FilterMono16BitSplineMix,	FilterStereo8BitSplineMix,	FilterStereo16BitSplineMix,
+	FilterMono8BitSplineRampMix,FilterMono16BitSplineRampMix,FilterStereo8BitSplineRampMix,FilterStereo16BitSplineRampMix,
+
+	// FirFilter SRC
+	Mono8BitFirFilterMix,		Mono16BitFirFilterMix,		Stereo8BitFirFilterMix,	Stereo16BitFirFilterMix,
+	Mono8BitFirFilterRampMix,	Mono16BitFirFilterRampMix,	Stereo8BitFirFilterRampMix,Stereo16BitFirFilterRampMix,
+	// FirFilter SRC, Filter
+	FilterMono8BitFirFilterMix,	FilterMono16BitFirFilterMix,	FilterStereo8BitFirFilterMix,	FilterStereo16BitFirFilterMix,
+	FilterMono8BitFirFilterRampMix,FilterMono16BitFirFilterRampMix,FilterStereo8BitFirFilterRampMix,FilterStereo16BitFirFilterRampMix,
+};
+
+
+/////////////////////////////////////////////////////////////////////////
+
+static LONG MPPFASTCALL GetSampleCount(MODCHANNEL *pChn, LONG nSamples)
+//---------------------------------------------------------------------
+{
+	LONG nLoopStart = (pChn->dwFlags & CHN_LOOP) ? pChn->nLoopStart : 0;
+	LONG nInc = pChn->nInc;
+
+	if ((nSamples <= 0) || (!nInc) || (!pChn->nLength)) return 0;
+	// Under zero ?
+	if ((LONG)pChn->nPos < nLoopStart)
+	{
+		if (nInc < 0)
+		{
+			// Invert loop for bidi loops
+			LONG nDelta = ((nLoopStart - pChn->nPos) << 16) - (pChn->nPosLo & 0xffff);
+			pChn->nPos = nLoopStart | (nDelta>>16);
+			pChn->nPosLo = nDelta & 0xffff;
+			if (((LONG)pChn->nPos < nLoopStart) || (pChn->nPos >= (nLoopStart+pChn->nLength)/2))
+			{
+				pChn->nPos = nLoopStart; pChn->nPosLo = 0;
+			}
+			nInc = -nInc;
+			pChn->nInc = nInc;
+			pChn->dwFlags &= ~(CHN_PINGPONGFLAG); // go forward
+			if ((!(pChn->dwFlags & CHN_LOOP)) || (pChn->nPos >= pChn->nLength))
+			{
+				pChn->nPos = pChn->nLength;
+				pChn->nPosLo = 0;
+				return 0;
+			}
+		} else
+		{
+			// We probably didn't hit the loop end yet (first loop), so we do nothing
+			if ((LONG)pChn->nPos < 0) pChn->nPos = 0;
+		}
+	} else
+	// Past the end
+	if (pChn->nPos >= pChn->nLength)
+	{
+		if (!(pChn->dwFlags & CHN_LOOP)) return 0; // not looping -> stop this channel
+		if (pChn->dwFlags & CHN_PINGPONGLOOP)
+		{
+			// Invert loop
+			if (nInc > 0)
+			{
+				nInc = -nInc;
+				pChn->nInc = nInc;
+			}
+			pChn->dwFlags |= CHN_PINGPONGFLAG;
+			// adjust loop position
+			LONG nDeltaHi = (pChn->nPos - pChn->nLength);
+			LONG nDeltaLo = 0x10000 - (pChn->nPosLo & 0xffff);
+			pChn->nPos = pChn->nLength - nDeltaHi - (nDeltaLo>>16);
+			pChn->nPosLo = nDeltaLo & 0xffff;
+			if ((pChn->nPos <= pChn->nLoopStart) || (pChn->nPos >= pChn->nLength)) pChn->nPos = pChn->nLength-1;
+		} else
+		{
+			if (nInc < 0) // This is a bug
+			{
+				nInc = -nInc;
+				pChn->nInc = nInc;
+			}
+			// Restart at loop start
+			pChn->nPos += nLoopStart - pChn->nLength;
+			if ((LONG)pChn->nPos < nLoopStart) pChn->nPos = pChn->nLoopStart;
+		}
+	}
+	LONG nPos = pChn->nPos;
+	// too big increment, and/or too small loop length
+	if (nPos < nLoopStart)
+	{
+		if ((nPos < 0) || (nInc < 0)) return 0;
+	}
+	if ((nPos < 0) || (nPos >= (LONG)pChn->nLength)) return 0;
+	LONG nPosLo = (USHORT)pChn->nPosLo, nSmpCount = nSamples;
+	if (nInc < 0)
+	{
+		LONG nInv = -nInc;
+		LONG maxsamples = 16384 / ((nInv>>16)+1);
+		if (maxsamples < 2) maxsamples = 2;
+		if (nSamples > maxsamples) nSamples = maxsamples;
+		LONG nDeltaHi = (nInv>>16) * (nSamples - 1);
+		LONG nDeltaLo = (nInv&0xffff) * (nSamples - 1);
+		LONG nPosDest = nPos - nDeltaHi + ((nPosLo - nDeltaLo) >> 16);
+		if (nPosDest < nLoopStart)
+		{
+			nSmpCount = (ULONG)(((((LONGLONG)nPos - nLoopStart) << 16) + nPosLo - 1) / nInv) + 1;
+		}
+	} else
+	{
+		LONG maxsamples = 16384 / ((nInc>>16)+1);
+		if (maxsamples < 2) maxsamples = 2;
+		if (nSamples > maxsamples) nSamples = maxsamples;
+		LONG nDeltaHi = (nInc>>16) * (nSamples - 1);
+		LONG nDeltaLo = (nInc&0xffff) * (nSamples - 1);
+		LONG nPosDest = nPos + nDeltaHi + ((nPosLo + nDeltaLo)>>16);
+		if (nPosDest >= (LONG)pChn->nLength)
+		{
+			nSmpCount = (ULONG)(((((LONGLONG)pChn->nLength - nPos) << 16) - nPosLo - 1) / nInc) + 1;
+		}
+	}
+	if (nSmpCount <= 1) return 1;
+	if (nSmpCount > nSamples) return nSamples;
+	return nSmpCount;
+}
+
+
+UINT CSoundFile::CreateStereoMix(int count)
+//-----------------------------------------
+{
+	LPLONG pOfsL, pOfsR;
+	DWORD nchused, nchmixed;
+
+	if (!count) return 0;
+#ifndef FASTSOUNDLIB
+	if (gnChannels > 2) X86_InitMixBuffer(MixRearBuffer, count*2);
+#endif
+	nchused = nchmixed = 0;
+	for (UINT nChn=0; nChn<m_nMixChannels; nChn++)
+	{
+		const LPMIXINTERFACE *pMixFuncTable;
+		MODCHANNEL * const pChannel = &Chn[ChnMix[nChn]];
+		UINT nFlags, nMasterCh;
+		LONG nSmpCount;
+		int nsamples;
+		int *pbuffer;
+
+		if (!pChannel->pCurrentSample) continue;
+		nMasterCh = (ChnMix[nChn] < m_nChannels) ? ChnMix[nChn]+1 : pChannel->nMasterChn;
+		pOfsR = &gnDryROfsVol;
+		pOfsL = &gnDryLOfsVol;
+		nFlags = 0;
+		if (pChannel->dwFlags & CHN_16BIT) nFlags |= MIXNDX_16BIT;
+		if (pChannel->dwFlags & CHN_STEREO) nFlags |= MIXNDX_STEREO;
+	#ifndef NO_FILTER
+		if (pChannel->dwFlags & CHN_FILTER) nFlags |= MIXNDX_FILTER;
+	#endif
+		if (!(pChannel->dwFlags & CHN_NOIDO))
+		{
+			// use hq-fir mixer?
+			if( (gdwSoundSetup & (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE)) == (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE) )
+				nFlags += MIXNDX_FIRSRC;
+			else if( (gdwSoundSetup & (SNDMIX_HQRESAMPLER)) == SNDMIX_HQRESAMPLER )
+				nFlags += MIXNDX_SPLINESRC;
+			else
+				nFlags += MIXNDX_LINEARSRC; // use
+		}
+		if ((nFlags < 0x40) && (pChannel->nLeftVol == pChannel->nRightVol)
+		 && ((!pChannel->nRampLength) || (pChannel->nLeftRamp == pChannel->nRightRamp)))
+		{
+			pMixFuncTable = gpFastMixFunctionTable;
+		} else
+		{
+			pMixFuncTable = gpMixFunctionTable;
+		}
+		nsamples = count;
+#ifndef NO_REVERB
+		pbuffer = (gdwSoundSetup & SNDMIX_REVERB) ? MixReverbBuffer : MixSoundBuffer;
+		if (pChannel->dwFlags & CHN_NOREVERB) pbuffer = MixSoundBuffer;
+		if (pChannel->dwFlags & CHN_REVERB) pbuffer = MixReverbBuffer;
+		if (pbuffer == MixReverbBuffer)
+		{
+			if (!gnReverbSend) memset(MixReverbBuffer, 0, count * 8);
+			gnReverbSend += count;
+		}
+#else
+		pbuffer = MixSoundBuffer;
+#endif
+		nchused++;
+		////////////////////////////////////////////////////
+	SampleLooping:
+		UINT nrampsamples = nsamples;
+		if (pChannel->nRampLength > 0)
+		{
+			if ((LONG)nrampsamples > pChannel->nRampLength) nrampsamples = pChannel->nRampLength;
+		}
+		if ((nSmpCount = GetSampleCount(pChannel, nrampsamples)) <= 0)
+		{
+			// Stopping the channel
+			pChannel->pCurrentSample = NULL;
+			pChannel->nLength = 0;
+			pChannel->nPos = 0;
+			pChannel->nPosLo = 0;
+			pChannel->nRampLength = 0;
+			X86_EndChannelOfs(pChannel, pbuffer, nsamples);
+			*pOfsR += pChannel->nROfs;
+			*pOfsL += pChannel->nLOfs;
+			pChannel->nROfs = pChannel->nLOfs = 0;
+			pChannel->dwFlags &= ~CHN_PINGPONGFLAG;
+			continue;
+		}
+		// Should we mix this channel ?
+		UINT naddmix;
+		if (((nchmixed >= m_nMaxMixChannels) && (!(gdwSoundSetup & SNDMIX_DIRECTTODISK)))
+		 || ((!pChannel->nRampLength) && (!(pChannel->nLeftVol|pChannel->nRightVol))))
+		{
+			LONG delta = (pChannel->nInc * (LONG)nSmpCount) + (LONG)pChannel->nPosLo;
+			pChannel->nPosLo = delta & 0xFFFF;
+			pChannel->nPos += (delta >> 16);
+			pChannel->nROfs = pChannel->nLOfs = 0;
+			pbuffer += nSmpCount*2;
+			naddmix = 0;
+		} else
+		// Do mixing
+		{
+			// Choose function for mixing
+			LPMIXINTERFACE pMixFunc;
+			pMixFunc = (pChannel->nRampLength) ? pMixFuncTable[nFlags|MIXNDX_RAMP] : pMixFuncTable[nFlags];
+			int *pbufmax = pbuffer + (nSmpCount*2);
+			pChannel->nROfs = - *(pbufmax-2);
+			pChannel->nLOfs = - *(pbufmax-1);
+			pMixFunc(pChannel, pbuffer, pbufmax);
+			pChannel->nROfs += *(pbufmax-2);
+			pChannel->nLOfs += *(pbufmax-1);
+			pbuffer = pbufmax;
+			naddmix = 1;
+
+		}
+		nsamples -= nSmpCount;
+		if (pChannel->nRampLength)
+		{
+			pChannel->nRampLength -= nSmpCount;
+			if (pChannel->nRampLength <= 0)
+			{
+				pChannel->nRampLength = 0;
+				pChannel->nRightVol = pChannel->nNewRightVol;
+				pChannel->nLeftVol = pChannel->nNewLeftVol;
+				pChannel->nRightRamp = pChannel->nLeftRamp = 0;
+				if ((pChannel->dwFlags & CHN_NOTEFADE) && (!(pChannel->nFadeOutVol)))
+				{
+					pChannel->nLength = 0;
+					pChannel->pCurrentSample = NULL;
+				}
+			}
+		}
+		if (nsamples > 0) goto SampleLooping;
+		nchmixed += naddmix;
+	}
+	return nchused;
+}
+
+
+#ifdef MSC_VER
+#pragma warning (disable:4100)
+#endif
+
+// Clip and convert to 8 bit
+#ifdef MSC_VER
+__declspec(naked) DWORD MPPASMCALL X86_Convert32To8(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+//----------------------------------------------------------------------------------------------------------------------------
+{
+	_asm {
+	push ebx
+	push esi
+	push edi
+	mov ebx, 16[esp]		// ebx = 8-bit buffer
+	mov esi, 20[esp]		// esi = pBuffer
+	mov edi, 24[esp]		// edi = lSampleCount
+	mov eax, 28[esp]
+	mov ecx, dword ptr [eax]	// ecx = clipmin
+	mov eax, 32[esp]
+	mov edx, dword ptr [eax]	// edx = clipmax
+cliploop:
+	mov eax, dword ptr [esi]
+	inc ebx
+	cdq
+	and edx, (1 << (24-MIXING_ATTENUATION)) - 1
+	add eax, edx
+	cmp eax, MIXING_CLIPMIN
+	jl cliplow
+	cmp eax, MIXING_CLIPMAX
+	jg cliphigh
+	cmp eax, ecx
+	jl updatemin
+	cmp eax, edx
+	jg updatemax
+cliprecover:
+	add esi, 4
+	sar eax, 24-MIXING_ATTENUATION
+	xor eax, 0x80
+	dec edi
+	mov byte ptr [ebx-1], al
+	jnz cliploop
+	mov eax, 28[esp]
+	mov dword ptr [eax], ecx
+	mov eax, 32[esp]
+	mov dword ptr [eax], edx
+	mov eax, 24[esp]
+	pop edi
+	pop esi
+	pop ebx
+	ret
+updatemin:
+	mov ecx, eax
+	jmp cliprecover
+updatemax:
+	mov edx, eax
+	jmp cliprecover
+cliplow:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMIN
+	jmp cliprecover
+cliphigh:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMAX
+	jmp cliprecover
+	}
+}
+#else //MSC_VER
+//---GCCFIX: Asm replaced with C function
+// The C version was written by Rani Assaf <rani@magic.metawire.com>, I believe
+DWORD MPPASMCALL X86_Convert32To8(LPVOID lp8, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+{
+	int vumin = *lpMin, vumax = *lpMax;
+	unsigned char *p = (unsigned char *)lp8;
+	for (UINT i=0; i<lSampleCount; i++)
+	{
+		int n = pBuffer[i];
+		if (n < MIXING_CLIPMIN)
+			n = MIXING_CLIPMIN;
+		else if (n > MIXING_CLIPMAX)
+			n = MIXING_CLIPMAX;
+		if (n < vumin)
+			vumin = n;
+		else if (n > vumax)
+			vumax = n;
+		p[i] = (n >> (24-MIXING_ATTENUATION)) ^ 0x80;	// 8-bit unsigned
+	}
+	*lpMin = vumin;
+	*lpMax = vumax;
+	return lSampleCount;
+}
+#endif //MSC_VER, else
+
+
+#ifdef MSC_VER
+// Clip and convert to 16 bit
+__declspec(naked) DWORD MPPASMCALL X86_Convert32To16(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+//-----------------------------------------------------------------------------------------------------------------------------
+{
+	_asm {
+	push ebx
+	push esi
+	push edi
+	mov ebx, 16[esp]		// ebx = 16-bit buffer
+	mov eax, 28[esp]
+	mov esi, 20[esp]		// esi = pBuffer
+	mov ecx, dword ptr [eax]	// ecx = clipmin
+	mov edi, 24[esp]		// edi = lSampleCount
+	mov eax, 32[esp]
+	push ebp
+	mov ebp, dword ptr [eax]	// edx = clipmax
+cliploop:
+	mov eax, dword ptr [esi]
+	add ebx, 2
+	cdq
+	and edx, (1 << (16-MIXING_ATTENUATION)) - 1
+	add esi, 4
+	add eax, edx
+	cmp eax, MIXING_CLIPMIN
+	jl cliplow
+	cmp eax, MIXING_CLIPMAX
+	jg cliphigh
+	cmp eax, ecx
+	jl updatemin
+	cmp eax, ebp
+	jg updatemax
+cliprecover:
+	sar eax, 16-MIXING_ATTENUATION
+	dec edi
+	mov word ptr [ebx-2], ax
+	jnz cliploop
+	mov edx, ebp
+	pop ebp
+	mov eax, 28[esp]
+	mov dword ptr [eax], ecx
+	mov eax, 32[esp]
+	mov dword ptr [eax], edx
+	mov eax, 24[esp]
+	pop edi
+	shl eax, 1
+	pop esi
+	pop ebx
+	ret
+updatemin:
+	mov ecx, eax
+	jmp cliprecover
+updatemax:
+	mov ebp, eax
+	jmp cliprecover
+cliplow:
+	mov ecx, MIXING_CLIPMIN
+	mov ebp, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMIN
+	jmp cliprecover
+cliphigh:
+	mov ecx, MIXING_CLIPMIN
+	mov ebp, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMAX
+	jmp cliprecover
+	}
+}
+#else //MSC_VER
+//---GCCFIX: Asm replaced with C function
+// The C version was written by Rani Assaf <rani@magic.metawire.com>, I believe
+DWORD MPPASMCALL X86_Convert32To16(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+{
+	int vumin = *lpMin, vumax = *lpMax;
+	signed short *p = (signed short *)lp16;
+	for (UINT i=0; i<lSampleCount; i++)
+	{
+		int n = pBuffer[i];
+		if (n < MIXING_CLIPMIN)
+			n = MIXING_CLIPMIN;
+		else if (n > MIXING_CLIPMAX)
+			n = MIXING_CLIPMAX;
+		if (n < vumin)
+			vumin = n;
+		else if (n > vumax)
+			vumax = n;
+		p[i] = n >> (16-MIXING_ATTENUATION);	// 16-bit signed
+	}
+	*lpMin = vumin;
+	*lpMax = vumax;
+	return lSampleCount * 2;
+}
+#endif //MSC_VER, else
+
+#ifdef MSC_VER
+// Clip and convert to 24 bit
+__declspec(naked) DWORD MPPASMCALL X86_Convert32To24(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+//-----------------------------------------------------------------------------------------------------------------------------
+{
+	_asm {
+	push ebx
+	push esi
+	push edi
+	mov ebx, 16[esp]		// ebx = 8-bit buffer
+	mov esi, 20[esp]		// esi = pBuffer
+	mov edi, 24[esp]		// edi = lSampleCount
+	mov eax, 28[esp]
+	mov ecx, dword ptr [eax]	// ecx = clipmin
+	mov eax, 32[esp]
+	push ebp
+	mov edx, dword ptr [eax]	// edx = clipmax
+cliploop:
+	mov eax, dword ptr [esi]
+	mov ebp, eax
+	sar ebp, 31
+	and ebp, (1 << (8-MIXING_ATTENUATION)) - 1
+	add eax, ebp
+	cmp eax, MIXING_CLIPMIN
+	jl cliplow
+	cmp eax, MIXING_CLIPMAX
+	jg cliphigh
+	cmp eax, ecx
+	jl updatemin
+	cmp eax, edx
+	jg updatemax
+cliprecover:
+	add ebx, 3
+	sar eax, 8-MIXING_ATTENUATION
+	add esi, 4
+	mov word ptr [ebx-3], ax
+	shr eax, 16
+	dec edi
+	mov byte ptr [ebx-1], al
+	jnz cliploop
+	pop ebp
+	mov eax, 28[esp]
+	mov dword ptr [eax], ecx
+	mov eax, 32[esp]
+	mov dword ptr [eax], edx
+	mov edx, 24[esp]
+	mov eax, edx
+	pop edi
+	shl eax, 1
+	pop esi
+	add eax, edx
+	pop ebx
+	ret
+updatemin:
+	mov ecx, eax
+	jmp cliprecover
+updatemax:
+	mov edx, eax
+	jmp cliprecover
+cliplow:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMIN
+	jmp cliprecover
+cliphigh:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMAX
+	jmp cliprecover
+	}
+}
+#else //MSC_VER
+//---GCCFIX: Asm replaced with C function
+// 24-bit audio not supported.
+DWORD MPPASMCALL X86_Convert32To24(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+{
+	return 0;
+}
+#endif
+
+#ifdef MSC_VER
+// Clip and convert to 32 bit
+__declspec(naked) DWORD MPPASMCALL X86_Convert32To32(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+//-----------------------------------------------------------------------------------------------------------------------------
+{
+	_asm {
+	push ebx
+	push esi
+	push edi
+	mov ebx, 16[esp]			// ebx = 32-bit buffer
+	mov esi, 20[esp]			// esi = pBuffer
+	mov edi, 24[esp]			// edi = lSampleCount
+	mov eax, 28[esp]
+	mov ecx, dword ptr [eax]	// ecx = clipmin
+	mov eax, 32[esp]
+	mov edx, dword ptr [eax]	// edx = clipmax
+cliploop:
+	mov eax, dword ptr [esi]
+	add ebx, 4
+	add esi, 4
+	cmp eax, MIXING_CLIPMIN
+	jl cliplow
+	cmp eax, MIXING_CLIPMAX
+	jg cliphigh
+	cmp eax, ecx
+	jl updatemin
+	cmp eax, edx
+	jg updatemax
+cliprecover:
+	shl eax, MIXING_ATTENUATION
+	dec edi
+	mov dword ptr [ebx-4], eax
+	jnz cliploop
+	mov eax, 28[esp]
+	mov dword ptr [eax], ecx
+	mov eax, 32[esp]
+	mov dword ptr [eax], edx
+	mov edx, 24[esp]
+	pop edi
+	mov eax, edx
+	pop esi
+	shl eax, 2
+	pop ebx
+	ret
+updatemin:
+	mov ecx, eax
+	jmp cliprecover
+updatemax:
+	mov edx, eax
+	jmp cliprecover
+cliplow:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMIN
+	jmp cliprecover
+cliphigh:
+	mov ecx, MIXING_CLIPMIN
+	mov edx, MIXING_CLIPMAX
+	mov eax, MIXING_CLIPMAX
+	jmp cliprecover
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+// 32-bit audio not supported
+DWORD MPPASMCALL X86_Convert32To32(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LPLONG lpMin, LPLONG lpMax)
+{
+	return 0;
+}
+#endif
+
+
+#ifdef MSC_VER
+void MPPASMCALL X86_InitMixBuffer(int *pBuffer, UINT nSamples)
+//------------------------------------------------------------
+{
+	_asm {
+	mov ecx, nSamples
+	mov esi, pBuffer
+	xor eax, eax
+	mov edx, ecx
+	shr ecx, 2
+	and edx, 3
+	jz unroll4x
+loop1x:
+	add esi, 4
+	dec edx
+	mov dword ptr [esi-4], eax
+	jnz loop1x
+unroll4x:
+	or ecx, ecx
+	jnz loop4x
+	jmp done
+loop4x:
+	add esi, 16
+	dec ecx
+	mov dword ptr [esi-16], eax
+	mov dword ptr [esi-12], eax
+	mov dword ptr [esi-8], eax
+	mov dword ptr [esi-4], eax
+	jnz loop4x
+done:;
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+// Will fill in later.
+void MPPASMCALL X86_InitMixBuffer(int *pBuffer, UINT nSamples)
+{
+	memset(pBuffer, 0, nSamples * sizeof(int));
+}
+#endif
+
+
+#ifdef MSC_VER
+__declspec(naked) void MPPASMCALL X86_InterleaveFrontRear(int *pFrontBuf, int *pRearBuf, DWORD nSamples)
+//------------------------------------------------------------------------------------------------------
+{
+	_asm {
+	push ebx
+	push ebp
+	push esi
+	push edi
+	mov ecx, 28[esp] // ecx = samplecount
+	mov esi, 20[esp] // esi = front buffer
+	mov edi, 24[esp] // edi = rear buffer
+	lea esi, [esi+ecx*4]	// esi = &front[N]
+	lea edi, [edi+ecx*4]	// edi = &rear[N]
+	lea ebx, [esi+ecx*4]	// ebx = &front[N*2]
+interleaveloop:
+	mov eax, dword ptr [esi-8]
+	mov edx, dword ptr [esi-4]
+	sub ebx, 16
+	mov ebp, dword ptr [edi-8]
+	mov dword ptr [ebx], eax
+	mov dword ptr [ebx+4], edx
+	mov eax, dword ptr [edi-4]
+	sub esi, 8
+	sub edi, 8
+	dec ecx
+	mov dword ptr [ebx+8], ebp
+	mov dword ptr [ebx+12], eax
+	jnz interleaveloop
+	pop edi
+	pop esi
+	pop ebp
+	pop ebx
+	ret
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+// Multichannel not supported.
+void MPPASMCALL X86_InterleaveFrontRear(int *pFrontBuf, int *pRearBuf, DWORD nSamples)
+{
+}
+#endif
+
+
+#ifdef MSC_VER
+VOID MPPASMCALL X86_MonoFromStereo(int *pMixBuf, UINT nSamples)
+//-------------------------------------------------------------
+{
+	_asm {
+	mov ecx, nSamples
+	mov esi, pMixBuf
+	mov edi, esi
+stloop:
+	mov eax, dword ptr [esi]
+	mov edx, dword ptr [esi+4]
+	add edi, 4
+	add esi, 8
+	add eax, edx
+	sar eax, 1
+	dec ecx
+	mov dword ptr [edi-4], eax
+	jnz stloop
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+VOID MPPASMCALL X86_MonoFromStereo(int *pMixBuf, UINT nSamples)
+{
+	UINT j;
+	for(UINT i = 0; i < nSamples; i++)
+	{
+		j = i << 1;
+		pMixBuf[i] = (pMixBuf[j] + pMixBuf[j + 1]) >> 1;
+	}
+}
+#endif
+
+#define OFSDECAYSHIFT	8
+#define OFSDECAYMASK	0xFF
+
+
+#ifdef MSC_VER
+void MPPASMCALL X86_StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs)
+//---------------------------------------------------------------------------------------
+{
+	_asm {
+	mov edi, pBuffer
+	mov ecx, nSamples
+	mov eax, lpROfs
+	mov edx, lpLOfs
+	mov eax, [eax]
+	mov edx, [edx]
+	or ecx, ecx
+	jz fill_loop
+	mov ebx, eax
+	or ebx, edx
+	jz fill_loop
+ofsloop:
+	mov ebx, eax
+	mov esi, edx
+	neg ebx
+	neg esi
+	sar ebx, 31
+	sar esi, 31
+	and ebx, OFSDECAYMASK
+	and esi, OFSDECAYMASK
+	add ebx, eax
+	add esi, edx
+	sar ebx, OFSDECAYSHIFT
+	sar esi, OFSDECAYSHIFT
+	sub eax, ebx
+	sub edx, esi
+	mov ebx, eax
+	or ebx, edx
+	jz fill_loop
+	add edi, 8
+	dec ecx
+	mov [edi-8], eax
+	mov [edi-4], edx
+	jnz ofsloop
+fill_loop:
+	mov ebx, ecx
+	and ebx, 3
+	jz fill4x
+fill1x:
+	mov [edi], eax
+	mov [edi+4], edx
+	add edi, 8
+	dec ebx
+	jnz fill1x
+fill4x:
+	shr ecx, 2
+	or ecx, ecx
+	jz done
+fill4xloop:
+	mov [edi], eax
+	mov [edi+4], edx
+	mov [edi+8], eax
+	mov [edi+12], edx
+	add edi, 8*4
+	dec ecx
+	mov [edi-16], eax
+	mov [edi-12], edx
+	mov [edi-8], eax
+	mov [edi-4], edx
+	jnz fill4xloop
+done:
+	mov esi, lpROfs
+	mov edi, lpLOfs
+	mov [esi], eax
+	mov [edi], edx
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+#define OFSDECAYSHIFT    8
+#define OFSDECAYMASK     0xFF
+void MPPASMCALL X86_StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs)
+//---------------------------------------------------------------------------------------------------------
+{
+	int rofs = *lpROfs;
+	int lofs = *lpLOfs;
+
+	if ((!rofs) && (!lofs))
+	{
+		X86_InitMixBuffer(pBuffer, nSamples*2);
+		return;
+	}
+	for (UINT i=0; i<nSamples; i++)
+	{
+		int x_r = (rofs + (((-rofs)>>31) & OFSDECAYMASK)) >> OFSDECAYSHIFT;
+		int x_l = (lofs + (((-lofs)>>31) & OFSDECAYMASK)) >> OFSDECAYSHIFT;
+		rofs -= x_r;
+		lofs -= x_l;
+		pBuffer[i*2] = x_r;
+		pBuffer[i*2+1] = x_l;
+	}
+	*lpROfs = rofs;
+	*lpLOfs = lofs;
+}
+#endif
+
+#ifdef MSC_VER
+void MPPASMCALL X86_EndChannelOfs(MODCHANNEL *pChannel, int *pBuffer, UINT nSamples)
+//----------------------------------------------------------------------------------
+{
+	_asm {
+	mov esi, pChannel
+	mov edi, pBuffer
+	mov ecx, nSamples
+	mov eax, dword ptr [esi+MODCHANNEL.nROfs]
+	mov edx, dword ptr [esi+MODCHANNEL.nLOfs]
+	or ecx, ecx
+	jz brkloop
+ofsloop:
+	mov ebx, eax
+	mov esi, edx
+	neg ebx
+	neg esi
+	sar ebx, 31
+	sar esi, 31
+	and ebx, OFSDECAYMASK
+	and esi, OFSDECAYMASK
+	add ebx, eax
+	add esi, edx
+	sar ebx, OFSDECAYSHIFT
+	sar esi, OFSDECAYSHIFT
+	sub eax, ebx
+	sub edx, esi
+	mov ebx, eax
+	add dword ptr [edi], eax
+	add dword ptr [edi+4], edx
+	or ebx, edx
+	jz brkloop
+	add edi, 8
+	dec ecx
+	jnz ofsloop
+brkloop:
+	mov esi, pChannel
+	mov dword ptr [esi+MODCHANNEL.nROfs], eax
+	mov dword ptr [esi+MODCHANNEL.nLOfs], edx
+	}
+}
+#else
+//---GCCFIX: Asm replaced with C function
+// Will fill in later.
+void MPPASMCALL X86_EndChannelOfs(MODCHANNEL *pChannel, int *pBuffer, UINT nSamples)
+{
+	int rofs = pChannel->nROfs;
+	int lofs = pChannel->nLOfs;
+
+	if ((!rofs) && (!lofs)) return;
+	for (UINT i=0; i<nSamples; i++)
+	{
+		int x_r = (rofs + (((-rofs)>>31) & OFSDECAYMASK)) >> OFSDECAYSHIFT;
+		int x_l = (lofs + (((-lofs)>>31) & OFSDECAYMASK)) >> OFSDECAYSHIFT;
+		rofs -= x_r;
+		lofs -= x_l;
+		pBuffer[i*2] += x_r;
+		pBuffer[i*2+1] += x_l;
+	}
+	pChannel->nROfs = rofs;
+	pChannel->nLOfs = lofs;
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////////
+// Automatic Gain Control
+
+#ifndef NO_AGC
+
+// Limiter
+#define MIXING_LIMITMAX		(0x08100000)
+#define MIXING_LIMITMIN		(-MIXING_LIMITMAX)
+
+__declspec(naked) UINT MPPASMCALL X86_AGC(int *pBuffer, UINT nSamples, UINT nAGC)
+//-------------------------------------------------------------------------------
+{
+	__asm {
+	push ebx
+	push ebp
+	push esi
+	push edi
+	mov esi, 20[esp]	// esi = pBuffer+i
+	mov ecx, 24[esp]	// ecx = i
+	mov edi, 28[esp]	// edi = AGC (0..256)
+agcloop:
+	mov eax, dword ptr [esi]
+	imul edi
+	shrd eax, edx, AGC_PRECISION
+	add esi, 4
+	cmp eax, MIXING_LIMITMIN
+	jl agcupdate
+	cmp eax, MIXING_LIMITMAX
+	jg agcupdate
+agcrecover:
+	dec ecx
+	mov dword ptr [esi-4], eax
+	jnz agcloop
+	mov eax, edi
+	pop edi
+	pop esi
+	pop ebp
+	pop ebx
+	ret
+agcupdate:
+	dec edi
+	jmp agcrecover
+	}
+}
+
+#pragma warning (default:4100)
+
+void CSoundFile::ProcessAGC(int count)
+//------------------------------------
+{
+	static DWORD gAGCRecoverCount = 0;
+	UINT agc = X86_AGC(MixSoundBuffer, count, gnAGC);
+	// Some kind custom law, so that the AGC stays quite stable, but slowly
+	// goes back up if the sound level stays below a level inversely proportional
+	// to the AGC level. (J'me comprends)
+	if ((agc >= gnAGC) && (gnAGC < AGC_UNITY) && (gnVUMeter < (0xFF - (gnAGC >> (AGC_PRECISION-7))) ))
+	{
+		gAGCRecoverCount += count;
+		UINT agctimeout = gdwMixingFreq + gnAGC;
+		if (gnChannels >= 2) agctimeout <<= 1;
+		if (gAGCRecoverCount >= agctimeout)
+		{
+			gAGCRecoverCount = 0;
+			gnAGC++;
+		}
+	} else
+	{
+		gnAGC = agc;
+		gAGCRecoverCount = 0;
+	}
+}
+
+
+
+void CSoundFile::ResetAGC()
+//-------------------------
+{
+	gnAGC = AGC_UNITY;
+}
+
+#endif // NO_AGC
+