[audacious-plugins/f15] Patch to use system's libmodplug (BR libmodplug-devel).
Michael Schwendt
mschwendt at fedoraproject.org
Thu Sep 8 16:49:32 UTC 2011
commit fda145eceffbf6196ca2b300285a4a117b33a8d7
Author: Michael Schwendt <mschwendt at fedoraproject.org>
Date: Thu Sep 8 18:49:12 2011 +0200
Patch to use system's libmodplug (BR libmodplug-devel).
audacious-plugins-2.5.4-libmodplug-system.patch |19943 +++++++++++++++++++++++
audacious-plugins.spec | 13 +-
2 files changed, 19954 insertions(+), 2 deletions(-)
---
diff --git a/audacious-plugins-2.5.4-libmodplug-system.patch b/audacious-plugins-2.5.4-libmodplug-system.patch
new file mode 100644
index 0000000..59d441d
--- /dev/null
+++ b/audacious-plugins-2.5.4-libmodplug-system.patch
@@ -0,0 +1,19943 @@
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/fastmix.cxx audacious-plugins-2.5.4/src/modplug/fastmix.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/fastmix.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/fastmix.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,1852 +0,0 @@
+-/*
+- * This program is free software; you can redistribute it and modify it
+- * under the terms of the GNU General Public License as published by the
+- * Free Software Foundation; either version 2 of the license or (at your
+- * option) any later version.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+- * Markus Fick <webmaster at mark-f.de> spline + fir-resampler
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-#include <math.h>
+-
+-// Front Mix Buffer (Also room for interleaved rear mix)
+-int MixSoundBuffer[MIXBUFFERSIZE*4];
+-
+-// Reverb Mix Buffer
+-#ifndef MODPLUG_NO_REVERB
+-int MixReverbBuffer[MIXBUFFERSIZE*2];
+-extern UINT gnReverbSend;
+-#endif
+-
+-int MixRearBuffer[MIXBUFFERSIZE*2];
+-float MixFloatBuffer[MIXBUFFERSIZE*2];
+-
+-
+-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 \
+- double fy1 = pChannel->nFilter_Y1;\
+- double fy2 = pChannel->nFilter_Y2;\
+- double ta;
+-
+-#define MIX_END_FILTER \
+- pChannel->nFilter_Y1 = fy1;\
+- pChannel->nFilter_Y2 = fy2;
+-
+-#define SNDMIX_PROCESSFILTER \
+-ta = ((double)vol * pChn->nFilter_A0 + fy1 * pChn->nFilter_B0 + fy2 * pChn->nFilter_B1);\
+-fy2 = fy1;\
+-fy1 = ta;vol=(int)ta;
+-
+-// Stereo
+-#define MIX_BEGIN_STEREO_FILTER \
+-double fy1 = pChannel->nFilter_Y1;\
+-double fy2 = pChannel->nFilter_Y2;\
+-double fy3 = pChannel->nFilter_Y3;\
+-double fy4 = pChannel->nFilter_Y4;\
+-double ta, tb;
+-
+-#define MIX_END_STEREO_FILTER \
+-pChannel->nFilter_Y1 = fy1;\
+-pChannel->nFilter_Y2 = fy2;\
+-pChannel->nFilter_Y3 = fy3;\
+-pChannel->nFilter_Y4 = fy4;\
+-
+-#define SNDMIX_PROCESSSTEREOFILTER \
+-ta = ((double)vol_l * pChn->nFilter_A0 + fy1 * pChn->nFilter_B0 + fy2 * pChn->nFilter_B1);\
+-tb = ((double)vol_r * pChn->nFilter_A0 + fy3 * pChn->nFilter_B0 + fy4 * pChn->nFilter_B1);\
+-fy2 = fy1; fy1 = ta;vol_l=(int)ta;\
+-fy4 = fy3; fy3 = tb;vol_r=(int)tb;
+-
+-//////////////////////////////////////////////////////////
+-// 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;\
+- }
+-
+-
+-/////////////////////////////////////////////////////
+-//
+-
+-extern void StereoMixToFloat(const int *pSrc, float *pOut1, float *pOut2, UINT nCount, const float _i2fc);
+-extern void FloatToStereoMix(const float *pIn1, const float *pIn2, int *pOut, UINT nCount, const float _f2ic);
+-extern void MonoMixToFloat(const int *pSrc, float *pOut, UINT nCount, const float _i2fc);
+-extern void FloatToMonoMix(const float *pIn, int *pOut, UINT nCount, const float _f2ic);
+-
+-void InitMixBuffer(int *pBuffer, UINT nSamples);
+-void EndChannelOfs(MODCHANNEL *pChannel, int *pBuffer, UINT nSamples);
+-void StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs);
+-
+-void StereoMixToFloat(const int *, float *, float *, UINT nCount);
+-void 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;
+- if (gnChannels > 2) InitMixBuffer(MixRearBuffer, count*2);
+- nchused = nchmixed = 0;
+- for (UINT nChn=0; nChn<m_nMixChannels; nChn++)
+- {
+- const LPMIXINTERFACE *pMixFuncTable;
+- MODCHANNEL * const pChannel = &Chn[ChnMix[nChn]];
+- UINT nFlags;
+- LONG nSmpCount;
+- int nsamples;
+- int *pbuffer;
+-
+- if (!pChannel->pCurrentSample) continue;
+- 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)
+- && !(gdwSoundSetup & SNDMIX_NORESAMPLING))
+- {
+- // use hq-fir mixer?
+- if( (gdwSoundSetup & (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE)) == (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE) )
+- nFlags |= MIXNDX_FIRSRC;
+- else if( (gdwSoundSetup & 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 MODPLUG_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;
+- 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
+- {
+- if (pChannel->nLength) {
+- pChannel->topnote_offset = ((pChannel->nPos << 16) | pChannel->nPosLo) % pChannel->nLength;
+- }
+-
+- // 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;
+-}
+-
+-static float f2ic = (float)(1 << 28);
+-static float i2fc = (float)(1.0 / (1 << 28));
+-
+-VOID CSoundFile::StereoMixToFloat(const int *pSrc, float *pOut1, float *pOut2, UINT nCount)
+-//-----------------------------------------------------------------------------------------
+-{
+- for (UINT i = 0; i < nCount; i++) {
+- *pOut1++ = *pSrc * i2fc; /*!*/
+- pSrc++;
+-
+- *pOut2++ = *pSrc * i2fc; /*!*/
+- pSrc++;
+- }
+-}
+-
+-
+-VOID CSoundFile::FloatToStereoMix(const float *pIn1, const float *pIn2, int *pOut, UINT nCount)
+-//---------------------------------------------------------------------------------------------
+-{
+- for (UINT i = 0; i < nCount; i++) {
+- *pOut++ = (int)(*pIn1 * f2ic);
+- *pOut++ = (int)(*pIn2 * f2ic);
+- pIn1++;
+- pIn2++;
+- }
+-}
+-
+-
+-VOID CSoundFile::MonoMixToFloat(const int *pSrc, float *pOut, UINT nCount)
+-//------------------------------------------------------------------------
+-{
+- for (UINT i = 0; i < nCount; i++) {
+- *pOut++ = *pSrc * i2fc; /*!*/
+- pSrc++;
+- }
+-}
+-
+-
+-VOID CSoundFile::FloatToMonoMix(const float *pIn, int *pOut, UINT nCount)
+-//-----------------------------------------------------------------------
+-{
+- for (UINT i = 0; i < nCount; i++) {
+- *pOut++ = (int)(*pIn * f2ic); /*!*/
+- pIn++;
+- }
+-}
+-
+-
+-// Clip and convert to 8 bit
+-//---GCCFIX: Asm replaced with C function
+-// The C version was written by Rani Assaf <rani at magic.metawire.com>, I believe
+-DWORD Convert32To8(LPVOID lp8, int *pBuffer, DWORD lSampleCount, LONG mins[2], LONG maxs[2])
+-{
+- 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 < mins[i&1])
+- mins[i&1]= n;
+- else if (n > maxs[i&1])
+- maxs[i&1] = n;
+- p[i] = (n >> (24-MIXING_ATTENUATION)) ^ 0x80; // 8-bit unsigned
+- }
+- return lSampleCount;
+-}
+-//---GCCFIX: Asm replaced with C function
+-// The C version was written by Rani Assaf <rani at magic.metawire.com>, I believe
+-DWORD Convert32To16(LPVOID lp16, int *pBuffer, DWORD lSampleCount, LONG mins[2], LONG maxs[2])
+-{
+- 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 < mins[i&1])
+- mins[i&1]= n;
+- else if (n > maxs[i&1])
+- maxs[i&1] = n;
+- p[i] = n >> (16-MIXING_ATTENUATION); // 16-bit signed
+- }
+- return lSampleCount * 2;
+-}
+-//---GCCFIX: Asm replaced with C function
+-// 24-bit might not work...
+-DWORD Convert32To24(LPVOID lp24, int *pBuffer, DWORD lSampleCount, LONG mins[2], LONG maxs[2])
+-{
+- /* the inventor of 24bit anything should be shot */
+- unsigned char *p = (unsigned char *)lp24;
+- 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 < mins[i&1])
+- mins[i&1]= n;
+- else if (n > maxs[i&1])
+- maxs[i&1] = n;
+- n = n >> (8-MIXING_ATTENUATION); // 24-bit signed
+- /* err, assume same endian */
+- memcpy(p, &n, 3);
+- p += 3;
+- }
+- return lSampleCount * 2;
+-}
+-//---GCCFIX: Asm replaced with C function
+-// 32-bit might not work...
+-DWORD Convert32To32(LPVOID lp32, int *pBuffer, DWORD lSampleCount, LONG mins[2], LONG maxs[2])
+-{
+- signed int *p = (signed int *)lp32;
+- 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 < mins[i&1])
+- mins[i&1]= n;
+- else if (n > maxs[i&1])
+- maxs[i&1] = n;
+- p[i] = (n >> MIXING_ATTENUATION); // 32-bit signed
+- }
+- return lSampleCount * 2;
+-}
+-//---GCCFIX: Asm replaced with C function
+-// Will fill in later.
+-void InitMixBuffer(int *pBuffer, UINT nSamples)
+-{
+- memset(pBuffer, 0, nSamples * sizeof(int));
+-}
+-
+-//---GCCFIX: Asm replaced with C function
+-void InterleaveFrontRear(int *pFrontBuf, int *pRearBuf, DWORD nSamples)
+-{
+- DWORD i=0;
+-
+- pRearBuf[i] = pFrontBuf[1];
+- for (i = 1; i < nSamples; i++) {
+- pRearBuf[i] = pFrontBuf[(i*2)+1];
+- pFrontBuf[i] = pFrontBuf[i*2];
+- }
+-}
+-//---GCCFIX: Asm replaced with C function
+-VOID 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;
+- }
+-}
+-
+-//---GCCFIX: Asm replaced with C function
+-#define OFSDECAYSHIFT 8
+-#define OFSDECAYMASK 0xFF
+-void StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs)
+-//---------------------------------------------------------------------------------------------------------
+-{
+- int rofs = *lpROfs;
+- int lofs = *lpLOfs;
+-
+- if ((!rofs) && (!lofs))
+- {
+- 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;
+-}
+-//---GCCFIX: Asm replaced with C function
+-// Will fill in later.
+-void 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;
+-}
+-
+-
+-
+-
+-
+-//////////////////////////////////////////////////////////////////////////////////
+-// Automatic Gain Control
+-
+-#ifndef NO_AGC
+-
+-// Limiter
+-#define MIXING_LIMITMAX (0x08100000)
+-#define MIXING_LIMITMIN (-MIXING_LIMITMAX)
+-
+-void CSoundFile::ProcessAGC(int count)
+-//------------------------------------
+-{
+- static DWORD gAGCRecoverCount = 0;
+- UINT agc = 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
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/gui/main.cxx audacious-plugins-2.5.4/src/modplug/gui/main.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/gui/main.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/gui/main.cxx 2011-09-08 18:43:07.016726319 +0200
+@@ -6,8 +6,8 @@
+ #include <config.h>
+
+ #include "../stddefs.h"
+-#include "../stdafx.h"
+-#include "../sndfile.h"
++#include "stdafx.h"
++#include "sndfile.h"
+ #include "../archive/open.h"
+
+ // Order of #include is important - UINT is redefined to unsigned long instead of unsigned int
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/it_defs.h audacious-plugins-2.5.4/src/modplug/it_defs.h
+--- audacious-plugins-2.5.4-orig/src/modplug/it_defs.h 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/it_defs.h 1970-01-01 01:00:00.000000000 +0100
+@@ -1,135 +0,0 @@
+-#ifndef _ITDEFS_H_
+-#define _ITDEFS_H_
+-
+-#pragma pack(1)
+-
+-typedef struct tagITFILEHEADER
+-{
+- DWORD id; // 0x4D504D49
+- CHAR songname[26];
+- BYTE hilight_minor;
+- BYTE hilight_major;
+- WORD ordnum;
+- WORD insnum;
+- WORD smpnum;
+- WORD patnum;
+- WORD cwtv;
+- WORD cmwt;
+- WORD flags;
+- WORD special;
+- BYTE globalvol;
+- BYTE mv;
+- BYTE speed;
+- BYTE tempo;
+- BYTE sep;
+- BYTE pwd;
+- WORD msglength;
+- DWORD msgoffset;
+- DWORD reserved2;
+- BYTE chnpan[64];
+- BYTE chnvol[64];
+-} ITFILEHEADER;
+-
+-
+-typedef struct tagITENVELOPE
+-{
+- BYTE flags;
+- BYTE num;
+- BYTE lpb;
+- BYTE lpe;
+- BYTE slb;
+- BYTE sle;
+- BYTE data[25*3];
+- BYTE reserved;
+-} ITENVELOPE;
+-
+-// Old Impulse Instrument Format (cmwt < 0x200)
+-typedef struct tagITOLDINSTRUMENT
+-{
+- DWORD id; // IMPI = 0x49504D49
+- CHAR filename[12]; // DOS file name
+- BYTE zero;
+- BYTE flags;
+- BYTE vls;
+- BYTE vle;
+- BYTE sls;
+- BYTE sle;
+- WORD reserved1;
+- WORD fadeout;
+- BYTE nna;
+- BYTE dnc;
+- WORD trkvers;
+- BYTE nos;
+- BYTE reserved2;
+- CHAR name[26];
+- WORD reserved3[3];
+- BYTE keyboard[240];
+- BYTE volenv[200];
+- BYTE nodes[50];
+-} ITOLDINSTRUMENT;
+-
+-
+-// Impulse Instrument Format
+-typedef struct tagITINSTRUMENT
+-{
+- DWORD id;
+- CHAR filename[12];
+- BYTE zero;
+- BYTE nna;
+- BYTE dct;
+- BYTE dca;
+- WORD fadeout;
+- signed char pps;
+- BYTE ppc;
+- BYTE gbv;
+- BYTE dfp;
+- BYTE rv;
+- BYTE rp;
+- WORD trkvers;
+- BYTE nos;
+- BYTE reserved1;
+- CHAR name[26];
+- BYTE ifc;
+- BYTE ifr;
+- BYTE mch;
+- BYTE mpr;
+- WORD mbank;
+- BYTE keyboard[240];
+- ITENVELOPE volenv;
+- ITENVELOPE panenv;
+- ITENVELOPE pitchenv;
+- BYTE dummy[4]; // was 7, but IT v2.17 saves 554 bytes
+-} ITINSTRUMENT;
+-
+-
+-// IT Sample Format
+-typedef struct ITSAMPLESTRUCT
+-{
+- DWORD id; // 0x53504D49
+- CHAR filename[12];
+- BYTE zero;
+- BYTE gvl;
+- BYTE flags;
+- BYTE vol;
+- CHAR name[26];
+- BYTE cvt;
+- BYTE dfp;
+- DWORD length;
+- DWORD loopbegin;
+- DWORD loopend;
+- DWORD C5Speed;
+- DWORD susloopbegin;
+- DWORD susloopend;
+- DWORD samplepointer;
+- BYTE vis;
+- BYTE vid;
+- BYTE vir;
+- BYTE vit;
+-} ITSAMPLESTRUCT;
+-
+-#pragma pack()
+-
+-extern BYTE autovibit2xm[8];
+-extern BYTE autovibxm2it[8];
+-
+-#endif
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_669.cxx audacious-plugins-2.5.4/src/modplug/load_669.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_669.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_669.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,193 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-////////////////////////////////////////////////////////////
+-// 669 Composer / UNIS 669 module loader
+-////////////////////////////////////////////////////////////
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-typedef struct tagFILEHEADER669
+-{
+- WORD sig; // 'if' or 'JN'
+- signed char songmessage[108]; // Song Message
+- BYTE samples; // number of samples (1-64)
+- BYTE patterns; // number of patterns (1-128)
+- BYTE restartpos;
+- BYTE orders[128];
+- BYTE tempolist[128];
+- BYTE breaks[128];
+-} FILEHEADER669;
+-
+-
+-typedef struct tagSAMPLE669
+-{
+- BYTE filename[13];
+- BYTE length[4]; // when will somebody think about DWORD align ???
+- BYTE loopstart[4];
+- BYTE loopend[4];
+-} SAMPLE669;
+-
+-DWORD lengthArrayToDWORD(const BYTE length[4]) {
+- DWORD len = (length[3] << 24) +
+- (length[2] << 16) +
+- (length[1] << 8) +
+- (length[0]);
+-
+- return(len);
+-}
+-
+-
+-BOOL CSoundFile::Read669(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- const FILEHEADER669 *pfh = (const FILEHEADER669 *)lpStream;
+- const SAMPLE669 *psmp = (const SAMPLE669 *)(lpStream + 0x1F1);
+- DWORD dwMemPos = 0;
+-
+- if ((!lpStream) || (dwMemLength < sizeof(FILEHEADER669))) return FALSE;
+- if ((bswapLE16(pfh->sig) != 0x6669) && (bswapLE16(pfh->sig) != 0x4E4A)) return FALSE;
+- if ((!pfh->samples) || (pfh->samples > 64) || (pfh->restartpos >= 128)
+- || (!pfh->patterns) || (pfh->patterns > 128)) return FALSE;
+- DWORD dontfuckwithme = 0x1F1 + pfh->samples * sizeof(SAMPLE669) + pfh->patterns * 0x600;
+- if (dontfuckwithme > dwMemLength) return FALSE;
+- for (UINT ichk=0; ichk<pfh->samples; ichk++)
+- {
+- DWORD len = lengthArrayToDWORD(psmp[ichk].length);
+- dontfuckwithme += len;
+- }
+- if (dontfuckwithme > dwMemLength) return FALSE;
+- // That should be enough checking: this must be a 669 module.
+- m_nType = MOD_TYPE_669;
+- m_dwSongFlags |= SONG_LINEARSLIDES;
+- m_nMinPeriod = 28 << 2;
+- m_nMaxPeriod = 1712 << 3;
+- m_nDefaultTempo = 125;
+- m_nDefaultSpeed = 6;
+- m_nChannels = 8;
+- memcpy(m_szNames[0], pfh->songmessage, 16);
+- m_nSamples = pfh->samples;
+- for (UINT nins=1; nins<=m_nSamples; nins++, psmp++)
+- {
+- DWORD len = lengthArrayToDWORD(psmp->length);
+- DWORD loopstart = lengthArrayToDWORD(psmp->loopstart);
+- DWORD loopend = lengthArrayToDWORD(psmp->loopend);
+- if (len > MAX_SAMPLE_LENGTH) len = MAX_SAMPLE_LENGTH;
+- if ((loopend > len) && (!loopstart)) loopend = 0;
+- if (loopend > len) loopend = len;
+- if (loopstart + 4 >= loopend) loopstart = loopend = 0;
+- Ins[nins].nLength = len;
+- Ins[nins].nLoopStart = loopstart;
+- Ins[nins].nLoopEnd = loopend;
+- if (loopend) Ins[nins].uFlags |= CHN_LOOP;
+- memcpy(m_szNames[nins], psmp->filename, 13);
+- Ins[nins].nVolume = 256;
+- Ins[nins].nGlobalVol = 64;
+- Ins[nins].nPan = 128;
+- }
+- // Song Message
+- m_lpszSongComments = new char[109];
+- memcpy(m_lpszSongComments, pfh->songmessage, 108);
+- m_lpszSongComments[108] = 0;
+- // Reading Orders
+- memcpy(Order, pfh->orders, 128);
+- m_nRestartPos = pfh->restartpos;
+- if (Order[m_nRestartPos] >= pfh->patterns) m_nRestartPos = 0;
+- // Reading Pattern Break Locations
+- for (UINT npan=0; npan<8; npan++)
+- {
+- ChnSettings[npan].nPan = (npan & 1) ? 0x30 : 0xD0;
+- ChnSettings[npan].nVolume = 64;
+- }
+- // Reading Patterns
+- dwMemPos = 0x1F1 + pfh->samples * 25;
+- for (UINT npat=0; npat<pfh->patterns; npat++)
+- {
+- Patterns[npat] = AllocatePattern(64, m_nChannels);
+- if (!Patterns[npat]) break;
+- PatternSize[npat] = 64;
+- MODCOMMAND *m = Patterns[npat];
+- const BYTE *p = lpStream + dwMemPos;
+- for (UINT row=0; row<64; row++)
+- {
+- MODCOMMAND *mspeed = m;
+- if ((row == pfh->breaks[npat]) && (row != 63))
+- {
+- for (UINT i=0; i<8; i++)
+- {
+- m[i].command = CMD_PATTERNBREAK;
+- m[i].param = 0;
+- }
+- }
+- for (UINT n=0; n<8; n++, m++, p+=3)
+- {
+- UINT note = p[0] >> 2;
+- UINT instr = ((p[0] & 0x03) << 4) | (p[1] >> 4);
+- UINT vol = p[1] & 0x0F;
+- if (p[0] < 0xFE)
+- {
+- m->note = note + 37;
+- m->instr = instr + 1;
+- }
+- if (p[0] <= 0xFE)
+- {
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = (vol << 2) + 2;
+- }
+- if (p[2] != 0xFF)
+- {
+- UINT command = p[2] >> 4;
+- UINT param = p[2] & 0x0F;
+- switch(command)
+- {
+- case 0x00: command = CMD_PORTAMENTOUP; break;
+- case 0x01: command = CMD_PORTAMENTODOWN; break;
+- case 0x02: command = CMD_TONEPORTAMENTO; break;
+- case 0x03: command = CMD_MODCMDEX; param |= 0x50; break;
+- case 0x04: command = CMD_VIBRATO; param |= 0x40; break;
+- case 0x05: if (param) command = CMD_SPEED; else command = 0; param += 2; break;
+- case 0x06: if (param == 0) { command = CMD_PANNINGSLIDE; param = 0xFE; } else
+- if (param == 1) { command = CMD_PANNINGSLIDE; param = 0xEF; } else
+- command = 0;
+- break;
+- default: command = 0;
+- }
+- if (command)
+- {
+- if (command == CMD_SPEED) mspeed = NULL;
+- m->command = command;
+- m->param = param;
+- }
+- }
+- }
+- if ((!row) && (mspeed))
+- {
+- for (UINT i=0; i<8; i++) if (!mspeed[i].command)
+- {
+- mspeed[i].command = CMD_SPEED;
+- mspeed[i].param = pfh->tempolist[npat] + 2;
+- break;
+- }
+- }
+- }
+- dwMemPos += 0x600;
+- }
+- // Reading Samples
+- for (UINT n=1; n<=m_nSamples; n++)
+- {
+- UINT len = Ins[n].nLength;
+- if (dwMemPos >= dwMemLength) break;
+- if (len > 4) ReadSample(&Ins[n], RS_PCM8U, (LPSTR)(lpStream+dwMemPos), dwMemLength - dwMemPos);
+- dwMemPos += len;
+- }
+- return TRUE;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_amf.cxx audacious-plugins-2.5.4/src/modplug/load_amf.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_amf.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_amf.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,422 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-///////////////////////////////////////////////////
+-//
+-// AMF module loader
+-//
+-// There is 2 types of AMF files:
+-// - ASYLUM Music Format
+-// - Advanced Music Format(DSM)
+-//
+-///////////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#define AMFLOG
+-
+-//#pragma warning(disable:4244)
+-
+-#pragma pack(1)
+-
+-typedef struct _AMFFILEHEADER
+-{
+- UCHAR szAMF[3];
+- UCHAR version;
+- CHAR title[32];
+- UCHAR numsamples;
+- UCHAR numorders;
+- USHORT numtracks;
+- UCHAR numchannels;
+-} AMFFILEHEADER;
+-
+-typedef struct _AMFSAMPLE
+-{
+- UCHAR type;
+- CHAR samplename[32];
+- CHAR filename[13];
+- ULONG offset;
+- ULONG length;
+- USHORT c2spd;
+- UCHAR volume;
+-} AMFSAMPLE;
+-
+-
+-#pragma pack()
+-
+-
+-#ifdef AMFLOG
+-extern void Log(LPCSTR, ...);
+-#endif
+-
+-VOID AMF_Unpack(MODCOMMAND *pPat, const BYTE *pTrack, UINT nRows, UINT nChannels)
+-//-------------------------------------------------------------------------------
+-{
+- UINT lastinstr = 0;
+- UINT nTrkSize = bswapLE16(*(USHORT *)pTrack);
+- nTrkSize += (UINT)pTrack[2] << 16;
+- pTrack += 3;
+- while (nTrkSize--)
+- {
+- UINT row = pTrack[0];
+- UINT cmd = pTrack[1];
+- UINT arg = pTrack[2];
+- if (row >= nRows) break;
+- MODCOMMAND *m = pPat + row * nChannels;
+- if (cmd < 0x7F) // note+vol
+- {
+- m->note = cmd+1;
+- if (!m->instr) m->instr = lastinstr;
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = arg;
+- } else
+- if (cmd == 0x7F) // duplicate row
+- {
+- signed char rdelta = (signed char)arg;
+- int rowsrc = (int)row + (int)rdelta;
+- if ((rowsrc >= 0) && (rowsrc < (int)nRows)) memcpy(m, &pPat[rowsrc*nChannels],sizeof(pPat[rowsrc*nChannels]));
+- } else
+- if (cmd == 0x80) // instrument
+- {
+- m->instr = arg+1;
+- lastinstr = m->instr;
+- } else
+- if (cmd == 0x83) // volume
+- {
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = arg;
+- } else
+- // effect
+- {
+- UINT command = cmd & 0x7F;
+- UINT param = arg;
+- switch(command)
+- {
+- // 0x01: Set Speed
+- case 0x01: command = CMD_SPEED; break;
+- // 0x02: Volume Slide
+- // 0x0A: Tone Porta + Vol Slide
+- // 0x0B: Vibrato + Vol Slide
+- case 0x02: command = CMD_VOLUMESLIDE;
+- case 0x0A: if (command == 0x0A) command = CMD_TONEPORTAVOL;
+- case 0x0B: if (command == 0x0B) command = CMD_VIBRATOVOL;
+- if (param & 0x80) param = (-(signed char)param)&0x0F;
+- else param = (param&0x0F)<<4;
+- break;
+- // 0x04: Porta Up/Down
+- case 0x04: if (param & 0x80) { command = CMD_PORTAMENTOUP; param = (-(signed char)param)&0x7F; }
+- else { command = CMD_PORTAMENTODOWN; } break;
+- // 0x06: Tone Portamento
+- case 0x06: command = CMD_TONEPORTAMENTO; break;
+- // 0x07: Tremor
+- case 0x07: command = CMD_TREMOR; break;
+- // 0x08: Arpeggio
+- case 0x08: command = CMD_ARPEGGIO; break;
+- // 0x09: Vibrato
+- case 0x09: command = CMD_VIBRATO; break;
+- // 0x0C: Pattern Break
+- case 0x0C: command = CMD_PATTERNBREAK; break;
+- // 0x0D: Position Jump
+- case 0x0D: command = CMD_POSITIONJUMP; break;
+- // 0x0F: Retrig
+- case 0x0F: command = CMD_RETRIG; break;
+- // 0x10: Offset
+- case 0x10: command = CMD_OFFSET; break;
+- // 0x11: Fine Volume Slide
+- case 0x11: if (param) { command = CMD_VOLUMESLIDE;
+- if (param & 0x80) param = 0xF0|((-(signed char)param)&0x0F);
+- else param = 0x0F|((param&0x0F)<<4);
+- } else command = 0; break;
+- // 0x12: Fine Portamento
+- // 0x16: Extra Fine Portamento
+- case 0x12:
+- case 0x16: if (param) { int mask = (command == 0x16) ? 0xE0 : 0xF0;
+- command = (param & 0x80) ? CMD_PORTAMENTOUP : CMD_PORTAMENTODOWN;
+- if (param & 0x80) param = mask|((-(signed char)param)&0x0F);
+- else param |= mask;
+- } else command = 0; break;
+- // 0x13: Note Delay
+- case 0x13: command = CMD_S3MCMDEX; param = 0xD0|(param & 0x0F); break;
+- // 0x14: Note Cut
+- case 0x14: command = CMD_S3MCMDEX; param = 0xC0|(param & 0x0F); break;
+- // 0x15: Set Tempo
+- case 0x15: command = CMD_TEMPO; break;
+- // 0x17: Panning
+- case 0x17: param = (param+64)&0x7F;
+- if (m->command) { if (!m->volcmd) { m->volcmd = VOLCMD_PANNING; m->vol = param/2; } command = 0; }
+- else { command = CMD_PANNING8; }
+- // Unknown effects
+- default: command = param = 0;
+- }
+- if (command)
+- {
+- m->command = command;
+- m->param = param;
+- }
+- }
+- pTrack += 3;
+- }
+-}
+-
+-
+-
+-BOOL CSoundFile::ReadAMF(LPCBYTE lpStream, const DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- const AMFFILEHEADER *pfh = (AMFFILEHEADER *)lpStream;
+- DWORD dwMemPos;
+-
+- if ((!lpStream) || (dwMemLength < 2048)) return FALSE;
+- if ((!strncmp((LPCTSTR)lpStream, "ASYLUM Music Format V1.0", 25)) && (dwMemLength > 4096))
+- {
+- UINT numorders, numpats, numsamples;
+-
+- dwMemPos = 32;
+- numpats = lpStream[dwMemPos+3];
+- numorders = lpStream[dwMemPos+4];
+- numsamples = 64;
+- dwMemPos += 6;
+- if ((!numpats) || (numpats > MAX_PATTERNS) || (!numorders)
+- || (numpats*64*32 + 294 + 37*64 >= dwMemLength)) return FALSE;
+- m_nType = MOD_TYPE_AMF0;
+- m_nChannels = 8;
+- m_nInstruments = 0;
+- m_nSamples = 31;
+- m_nDefaultTempo = 125;
+- m_nDefaultSpeed = 6;
+- for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+- {
+- Order[iOrd] = (iOrd < numorders) ? lpStream[dwMemPos+iOrd] : 0xFF;
+- }
+- dwMemPos = 294; // ???
+- for (UINT iSmp=0; iSmp<numsamples; iSmp++)
+- {
+- MODINSTRUMENT *psmp = &Ins[iSmp+1];
+- memcpy(m_szNames[iSmp+1], lpStream+dwMemPos, 22);
+- m_szNames[iSmp+1][21] = '\0';
+- psmp->nFineTune = MOD2XMFineTune(lpStream[dwMemPos+22]);
+- psmp->nVolume = lpStream[dwMemPos+23];
+- psmp->nGlobalVol = 64;
+- if (psmp->nVolume > 0x40) psmp->nVolume = 0x40;
+- psmp->nVolume <<= 2;
+- psmp->nLength = bswapLE32(*((LPDWORD)(lpStream+dwMemPos+25)));
+- psmp->nLoopStart = bswapLE32(*((LPDWORD)(lpStream+dwMemPos+29)));
+- psmp->nLoopEnd = psmp->nLoopStart + bswapLE32(*((LPDWORD)(lpStream+dwMemPos+33)));
+- if ((psmp->nLoopEnd > psmp->nLoopStart) && (psmp->nLoopEnd <= psmp->nLength))
+- {
+- psmp->uFlags = CHN_LOOP;
+- } else
+- {
+- psmp->nLoopStart = psmp->nLoopEnd = 0;
+- }
+- if ((psmp->nLength) && (iSmp>31)) m_nSamples = iSmp+1;
+- dwMemPos += 37;
+- }
+- for (UINT iPat=0; iPat<numpats; iPat++)
+- {
+- MODCOMMAND *p = AllocatePattern(64, m_nChannels);
+- if (!p) break;
+- Patterns[iPat] = p;
+- PatternSize[iPat] = 64;
+- const UCHAR *pin = lpStream + dwMemPos;
+- for (UINT i=0; i<8*64; i++)
+- {
+- p->note = 0;
+-
+- if (pin[0])
+- {
+- p->note = pin[0] + 13;
+- }
+- p->instr = pin[1];
+- p->command = pin[2];
+- p->param = pin[3];
+- if (p->command > 0x0F)
+- {
+- #ifdef AMFLOG
+- Log("0x%02X.0x%02X ?", p->command, p->param);
+- #endif
+- p->command = 0;
+- }
+- ConvertModCommand(p);
+- pin += 4;
+- p++;
+- }
+- dwMemPos += 64*32;
+- }
+- // Read samples
+- for (UINT iData=0; iData<m_nSamples; iData++)
+- {
+- MODINSTRUMENT *psmp = &Ins[iData+1];
+- if (psmp->nLength)
+- {
+- if (dwMemPos > dwMemLength) return FALSE;
+- dwMemPos += ReadSample(psmp, RS_PCM8S, (LPCSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+- }
+- }
+- return TRUE;
+- }
+- ////////////////////////////
+- // DSM/AMF
+- USHORT *ptracks[MAX_PATTERNS];
+- DWORD sampleseekpos[MAX_SAMPLES];
+-
+- if ((pfh->szAMF[0] != 'A') || (pfh->szAMF[1] != 'M') || (pfh->szAMF[2] != 'F')
+- || (pfh->version < 10) || (pfh->version > 14) || (!bswapLE16(pfh->numtracks))
+- || (!pfh->numorders) || (pfh->numorders > MAX_PATTERNS)
+- || (!pfh->numsamples) || (pfh->numsamples > MAX_SAMPLES)
+- || (pfh->numchannels < 4) || (pfh->numchannels > 32))
+- return FALSE;
+- memcpy(m_szNames[0], pfh->title, 32);
+- m_szNames[0][31] = '\0';
+- dwMemPos = sizeof(AMFFILEHEADER);
+- m_nType = MOD_TYPE_AMF;
+- m_nChannels = pfh->numchannels;
+- m_nSamples = pfh->numsamples;
+- m_nInstruments = 0;
+- // Setup Channel Pan Positions
+- if (pfh->version >= 11)
+- {
+- signed char *panpos = (signed char *)(lpStream + dwMemPos);
+- UINT nchannels = (pfh->version >= 13) ? 32 : 16;
+- for (UINT i=0; i<nchannels; i++)
+- {
+- int pan = (panpos[i] + 64) * 2;
+- if (pan < 0) pan = 0;
+- if (pan > 256) { pan = 128; ChnSettings[i].dwFlags |= CHN_SURROUND; }
+- ChnSettings[i].nPan = pan;
+- }
+- dwMemPos += nchannels;
+- } else
+- {
+- for (UINT i=0; i<16; i++)
+- {
+- ChnSettings[i].nPan = (lpStream[dwMemPos+i] & 1) ? 0x30 : 0xD0;
+- }
+- dwMemPos += 16;
+- }
+- // Get Tempo/Speed
+- m_nDefaultTempo = 125;
+- m_nDefaultSpeed = 6;
+- if (pfh->version >= 13)
+- {
+- if (lpStream[dwMemPos] >= 32) m_nDefaultTempo = lpStream[dwMemPos];
+- if (lpStream[dwMemPos+1] <= 32) m_nDefaultSpeed = lpStream[dwMemPos+1];
+- dwMemPos += 2;
+- }
+- // Setup sequence list
+- for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+- {
+- Order[iOrd] = 0xFF;
+- if (iOrd < pfh->numorders)
+- {
+- Order[iOrd] = iOrd;
+- PatternSize[iOrd] = 64;
+- if (pfh->version >= 14)
+- {
+- PatternSize[iOrd] = bswapLE16(*(USHORT *)(lpStream+dwMemPos));
+- dwMemPos += 2;
+- }
+- ptracks[iOrd] = (USHORT *)(lpStream+dwMemPos);
+- dwMemPos += m_nChannels * sizeof(USHORT);
+- }
+- }
+- if (dwMemPos + m_nSamples * (sizeof(AMFSAMPLE)+8) > dwMemLength) return TRUE;
+- // Read Samples
+- UINT maxsampleseekpos = 0;
+- for (UINT iIns=0; iIns<m_nSamples; iIns++)
+- {
+- MODINSTRUMENT *pins = &Ins[iIns+1];
+- AMFSAMPLE *psh = (AMFSAMPLE *)(lpStream + dwMemPos);
+-
+- dwMemPos += sizeof(AMFSAMPLE);
+- memcpy(m_szNames[iIns+1], psh->samplename, 32);
+- m_szNames[iIns+1][31] = '\0';
+- memcpy(pins->name, psh->filename, 13);
+- pins->name[12] = '\0';
+- pins->nLength = bswapLE32(psh->length);
+- pins->nC4Speed = bswapLE16(psh->c2spd);
+- pins->nGlobalVol = 64;
+- pins->nVolume = psh->volume * 4;
+- if (pfh->version >= 11)
+- {
+- pins->nLoopStart = bswapLE32(*(DWORD *)(lpStream+dwMemPos));
+- pins->nLoopEnd = bswapLE32(*(DWORD *)(lpStream+dwMemPos+4));
+- dwMemPos += 8;
+- } else
+- {
+- pins->nLoopStart = bswapLE16(*(WORD *)(lpStream+dwMemPos));
+- pins->nLoopEnd = pins->nLength;
+- dwMemPos += 2;
+- }
+- sampleseekpos[iIns] = 0;
+- if ((psh->type) && (bswapLE32(psh->offset) < dwMemLength-1))
+- {
+- sampleseekpos[iIns] = bswapLE32(psh->offset);
+- if (bswapLE32(psh->offset) > maxsampleseekpos)
+- maxsampleseekpos = bswapLE32(psh->offset);
+- if ((pins->nLoopEnd > pins->nLoopStart + 2)
+- && (pins->nLoopEnd <= pins->nLength)) pins->uFlags |= CHN_LOOP;
+- }
+- }
+- // Read Track Mapping Table
+- USHORT *pTrackMap = (USHORT *)(lpStream+dwMemPos);
+- UINT realtrackcnt = 0;
+- dwMemPos += pfh->numtracks * sizeof(USHORT);
+- for (UINT iTrkMap=0; iTrkMap<pfh->numtracks; iTrkMap++)
+- {
+- if (realtrackcnt < pTrackMap[iTrkMap]) realtrackcnt = pTrackMap[iTrkMap];
+- }
+- // Store tracks positions
+- BYTE **pTrackData = new BYTE *[realtrackcnt];
+- memset(pTrackData, 0, sizeof(pTrackData));
+- for (UINT iTrack=0; iTrack<realtrackcnt; iTrack++) if (dwMemPos + 3 <= dwMemLength)
+- {
+- UINT nTrkSize = bswapLE16(*(USHORT *)(lpStream+dwMemPos));
+- nTrkSize += (UINT)lpStream[dwMemPos+2] << 16;
+- if (dwMemPos + nTrkSize * 3 + 3 <= dwMemLength)
+- {
+- pTrackData[iTrack] = (BYTE *)(lpStream + dwMemPos);
+- }
+- dwMemPos += nTrkSize * 3 + 3;
+- }
+- // Create the patterns from the list of tracks
+- for (UINT iPat=0; iPat<pfh->numorders; iPat++)
+- {
+- MODCOMMAND *p = AllocatePattern(PatternSize[iPat], m_nChannels);
+- if (!p) break;
+- Patterns[iPat] = p;
+- for (UINT iChn=0; iChn<m_nChannels; iChn++)
+- {
+- UINT nTrack = bswapLE16(ptracks[iPat][iChn]);
+- if ((nTrack) && (nTrack <= pfh->numtracks))
+- {
+- UINT realtrk = bswapLE16(pTrackMap[nTrack-1]);
+- if (realtrk)
+- {
+- realtrk--;
+- if ((realtrk < realtrackcnt) && (pTrackData[realtrk]))
+- {
+- AMF_Unpack(p+iChn, pTrackData[realtrk], PatternSize[iPat], m_nChannels);
+- }
+- }
+- }
+- }
+- }
+- delete[] pTrackData;
+- // Read Sample Data
+- for (UINT iSeek=1; iSeek<=maxsampleseekpos; iSeek++)
+- {
+- if (dwMemPos >= dwMemLength) break;
+- for (UINT iSmp=0; iSmp<m_nSamples; iSmp++) if (iSeek == sampleseekpos[iSmp])
+- {
+- MODINSTRUMENT *pins = &Ins[iSmp+1];
+- dwMemPos += ReadSample(pins, RS_PCM8U, (LPCSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+- break;
+- }
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_ams.cxx audacious-plugins-2.5.4/src/modplug/load_ams.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_ams.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_ams.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,629 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-//////////////////////////////////////////////
+-// AMS module loader //
+-//////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#pragma pack(1)
+-
+-typedef struct AMSFILEHEADER
+-{
+- char szHeader[7]; // "Extreme" // changed from CHAR
+- BYTE verlo, verhi; // 0x??,0x01
+- BYTE chncfg;
+- BYTE samples;
+- WORD patterns;
+- WORD orders;
+- BYTE vmidi;
+- WORD extra;
+-} AMSFILEHEADER;
+-
+-typedef struct AMSSAMPLEHEADER
+-{
+- DWORD length;
+- DWORD loopstart;
+- DWORD loopend;
+- BYTE finetune_and_pan;
+- WORD samplerate; // C-2 = 8363
+- BYTE volume; // 0-127
+- BYTE infobyte;
+-} AMSSAMPLEHEADER;
+-
+-
+-#pragma pack()
+-
+-
+-
+-BOOL CSoundFile::ReadAMS(LPCBYTE lpStream, DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- AMSFILEHEADER *pfh = (AMSFILEHEADER *)lpStream;
+- DWORD dwMemPos;
+- UINT tmp, tmp2;
+-
+- if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
+- if ((pfh->verhi != 0x01) || (strncmp(pfh->szHeader, "Extreme", 7))
+- || (!pfh->patterns) || (!pfh->orders) || (!pfh->samples) || (pfh->samples > MAX_SAMPLES)
+- || (pfh->patterns > MAX_PATTERNS) || (pfh->orders > MAX_ORDERS))
+- {
+- return ReadAMS2(lpStream, dwMemLength);
+- }
+- dwMemPos = sizeof(AMSFILEHEADER) + pfh->extra;
+- if (dwMemPos + pfh->samples * sizeof(AMSSAMPLEHEADER) + 256 >= dwMemLength) return FALSE;
+- m_nType = MOD_TYPE_AMS;
+- m_nInstruments = 0;
+- m_nChannels = (pfh->chncfg & 0x1F) + 1;
+- m_nSamples = pfh->samples;
+- for (UINT nSmp=1; nSmp<=m_nSamples; nSmp++, dwMemPos += sizeof(AMSSAMPLEHEADER))
+- {
+- AMSSAMPLEHEADER *psh = (AMSSAMPLEHEADER *)(lpStream + dwMemPos);
+- MODINSTRUMENT *pins = &Ins[nSmp];
+- pins->nLength = psh->length;
+- pins->nLoopStart = psh->loopstart;
+- pins->nLoopEnd = psh->loopend;
+- pins->nGlobalVol = 64;
+- pins->nVolume = psh->volume << 1;
+- pins->nC4Speed = psh->samplerate;
+- pins->nPan = (psh->finetune_and_pan & 0xF0);
+- if (pins->nPan < 0x80) pins->nPan += 0x10;
+- pins->nFineTune = MOD2XMFineTune(psh->finetune_and_pan & 0x0F);
+- pins->uFlags = (psh->infobyte & 0x80) ? CHN_16BIT : 0;
+- if ((pins->nLoopEnd <= pins->nLength) && (pins->nLoopStart+4 <= pins->nLoopEnd)) pins->uFlags |= CHN_LOOP;
+- }
+- // Read Song Name
+- tmp = lpStream[dwMemPos++];
+- if (dwMemPos + tmp + 1 >= dwMemLength) return TRUE;
+- tmp2 = (tmp < 32) ? tmp : 31;
+- if (tmp2) memcpy(m_szNames[0], lpStream+dwMemPos, tmp2);
+- m_szNames[0][tmp2] = 0;
+- dwMemPos += tmp;
+- // Read sample names
+- for (UINT sNam=1; sNam<=m_nSamples; sNam++)
+- {
+- if (dwMemPos + 32 >= dwMemLength) return TRUE;
+- tmp = lpStream[dwMemPos++];
+- tmp2 = (tmp < 32) ? tmp : 31;
+- if (tmp2) memcpy(m_szNames[sNam], lpStream+dwMemPos, tmp2);
+- dwMemPos += tmp;
+- }
+- // Skip Channel names
+- for (UINT cNam=0; cNam<m_nChannels; cNam++)
+- {
+- if (dwMemPos + 32 >= dwMemLength) return TRUE;
+- tmp = lpStream[dwMemPos++];
+- dwMemPos += tmp;
+- }
+- // Read Pattern Names
+- m_lpszPatternNames = new char[pfh->patterns * 32]; // changed from CHAR
+- if (!m_lpszPatternNames) return TRUE;
+- m_nPatternNames = pfh->patterns;
+- memset(m_lpszPatternNames, 0, m_nPatternNames * 32);
+- for (UINT pNam=0; pNam < m_nPatternNames; pNam++)
+- {
+- if (dwMemPos + 32 >= dwMemLength) return TRUE;
+- tmp = lpStream[dwMemPos++];
+- tmp2 = (tmp < 32) ? tmp : 31;
+- if (tmp2) memcpy(m_lpszPatternNames+pNam*32, lpStream+dwMemPos, tmp2);
+- dwMemPos += tmp;
+- }
+- // Read Song Comments
+- tmp = *((WORD *)(lpStream+dwMemPos));
+- dwMemPos += 2;
+- if (dwMemPos + tmp >= dwMemLength) return TRUE;
+- if (tmp)
+- {
+- m_lpszSongComments = new char[tmp+1]; // changed from CHAR
+- if (!m_lpszSongComments) return TRUE;
+- memset(m_lpszSongComments, 0, tmp+1);
+- memcpy(m_lpszSongComments, lpStream + dwMemPos, tmp);
+- dwMemPos += tmp;
+- }
+- // Read Order List
+- for (UINT iOrd=0; iOrd<pfh->orders; iOrd++, dwMemPos += 2)
+- {
+- UINT n = *((WORD *)(lpStream+dwMemPos));
+- Order[iOrd] = (BYTE)n;
+- }
+- // Read Patterns
+- for (UINT iPat=0; iPat<pfh->patterns; iPat++)
+- {
+- if (dwMemPos + 4 >= dwMemLength) return TRUE;
+- UINT len = *((DWORD *)(lpStream + dwMemPos));
+- dwMemPos += 4;
+- if ((len >= dwMemLength) || (dwMemPos + len > dwMemLength)) return TRUE;
+- PatternSize[iPat] = 64;
+- PatternAllocSize[iPat] = 64;
+- MODCOMMAND *m = AllocatePattern(PatternSize[iPat], m_nChannels);
+- if (!m) return TRUE;
+- Patterns[iPat] = m;
+- const BYTE *p = lpStream + dwMemPos;
+- UINT row = 0, i = 0;
+- while ((row < PatternSize[iPat]) && (i+2 < len))
+- {
+- BYTE b0 = p[i++];
+- BYTE b1 = p[i++];
+- BYTE b2 = 0;
+- UINT ch = b0 & 0x3F;
+- // Note+Instr
+- if (!(b0 & 0x40))
+- {
+- b2 = p[i++];
+- if (ch < m_nChannels)
+- {
+- if (b1 & 0x7F) m[ch].note = (b1 & 0x7F) + 25;
+- m[ch].instr = b2;
+- }
+- if (b1 & 0x80)
+- {
+- b0 |= 0x40;
+- b1 = p[i++];
+- }
+- }
+- // Effect
+- if (b0 & 0x40)
+- {
+- anothercommand:
+- if (b1 & 0x40)
+- {
+- if (ch < m_nChannels)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = b1 & 0x3F;
+- }
+- } else
+- {
+- b2 = p[i++];
+- if (ch < m_nChannels)
+- {
+- UINT cmd = b1 & 0x3F;
+- if (cmd == 0x0C)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = b2 >> 1;
+- } else
+- if (cmd == 0x0E)
+- {
+- if (!m[ch].command)
+- {
+- UINT command = CMD_S3MCMDEX;
+- UINT param = b2;
+- switch(param & 0xF0)
+- {
+- case 0x00: if (param & 0x08) { param &= 0x07; param |= 0x90; } else {command=param=0;} break;
+- case 0x10: command = CMD_PORTAMENTOUP; param |= 0xF0; break;
+- case 0x20: command = CMD_PORTAMENTODOWN; param |= 0xF0; break;
+- case 0x30: param = (param & 0x0F) | 0x10; break;
+- case 0x40: param = (param & 0x0F) | 0x30; break;
+- case 0x50: param = (param & 0x0F) | 0x20; break;
+- case 0x60: param = (param & 0x0F) | 0xB0; break;
+- case 0x70: param = (param & 0x0F) | 0x40; break;
+- case 0x90: command = CMD_RETRIG; param &= 0x0F; break;
+- case 0xA0: if (param & 0x0F) { command = CMD_VOLUMESLIDE; param = (param << 4) | 0x0F; } else command=param=0; break;
+- case 0xB0: if (param & 0x0F) { command = CMD_VOLUMESLIDE; param |= 0xF0; } else command=param=0; break;
+- }
+- m[ch].command = command;
+- m[ch].param = param;
+- }
+- } else
+- {
+- m[ch].command = cmd;
+- m[ch].param = b2;
+- ConvertModCommand(&m[ch]);
+- }
+- }
+- }
+- if (b1 & 0x80)
+- {
+- b1 = p[i++];
+- if (i <= len) goto anothercommand;
+- }
+- }
+- if (b0 & 0x80)
+- {
+- row++;
+- m += m_nChannels;
+- }
+- }
+- dwMemPos += len;
+- }
+- // Read Samples
+- for (UINT iSmp=1; iSmp<=m_nSamples; iSmp++) if (Ins[iSmp].nLength)
+- {
+- if (dwMemPos >= dwMemLength - 9) return TRUE;
+- UINT flags = (Ins[iSmp].uFlags & CHN_16BIT) ? RS_AMS16 : RS_AMS8;
+- dwMemPos += ReadSample(&Ins[iSmp], flags, (LPSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+- }
+- return TRUE;
+-}
+-
+-
+-/////////////////////////////////////////////////////////////////////
+-// AMS 2.2 loader
+-
+-#pragma pack(1)
+-
+-typedef struct AMS2FILEHEADER
+-{
+- DWORD dwHdr1; // AMShdr
+- WORD wHdr2;
+- BYTE b1A; // 0x1A
+- BYTE titlelen; // 30-bytes max
+- CHAR szTitle[30]; // [titlelen]
+-} AMS2FILEHEADER;
+-
+-typedef struct AMS2SONGHEADER
+-{
+- WORD version;
+- BYTE instruments;
+- WORD patterns;
+- WORD orders;
+- WORD bpm;
+- BYTE speed;
+- BYTE channels;
+- BYTE commands;
+- BYTE rows;
+- WORD flags;
+-} AMS2SONGHEADER;
+-
+-typedef struct AMS2INSTRUMENT
+-{
+- BYTE samples;
+- BYTE notemap[120];
+-} AMS2INSTRUMENT;
+-
+-typedef struct AMS2ENVELOPE
+-{
+- BYTE speed;
+- BYTE sustain;
+- BYTE loopbegin;
+- BYTE loopend;
+- BYTE points;
+- BYTE info[3];
+-} AMS2ENVELOPE;
+-
+-typedef struct AMS2SAMPLE
+-{
+- DWORD length;
+- DWORD loopstart;
+- DWORD loopend;
+- WORD frequency;
+- BYTE finetune;
+- WORD c4speed;
+- CHAR transpose;
+- BYTE volume;
+- BYTE flags;
+-} AMS2SAMPLE;
+-
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadAMS2(LPCBYTE lpStream, DWORD dwMemLength)
+-//------------------------------------------------------------
+-{
+- AMS2FILEHEADER *pfh = (AMS2FILEHEADER *)lpStream;
+- AMS2SONGHEADER *psh;
+- DWORD dwMemPos;
+- BYTE smpmap[16];
+- BYTE packedsamples[MAX_SAMPLES];
+-
+- if ((pfh->dwHdr1 != 0x68534D41) || (pfh->wHdr2 != 0x7264)
+- || (pfh->b1A != 0x1A) || (pfh->titlelen > 30)) return FALSE;
+- dwMemPos = pfh->titlelen + 8;
+- psh = (AMS2SONGHEADER *)(lpStream + dwMemPos);
+- if (((psh->version & 0xFF00) != 0x0200) || (!psh->instruments)
+- || (psh->instruments > MAX_INSTRUMENTS) || (!psh->patterns) || (!psh->orders)) return FALSE;
+- dwMemPos += sizeof(AMS2SONGHEADER);
+- if (pfh->titlelen)
+- {
+- memcpy(m_szNames, pfh->szTitle, pfh->titlelen);
+- m_szNames[0][pfh->titlelen] = 0;
+- }
+- m_nType = MOD_TYPE_AMS;
+- m_nChannels = 32;
+- m_nDefaultTempo = psh->bpm >> 8;
+- m_nDefaultSpeed = psh->speed;
+- m_nInstruments = psh->instruments;
+- m_nSamples = 0;
+- m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- if (psh->flags & 0x40) m_dwSongFlags |= SONG_LINEARSLIDES;
+- for (UINT nIns=1; nIns<=m_nInstruments; nIns++)
+- {
+- UINT insnamelen = lpStream[dwMemPos];
+- CHAR *pinsname = (CHAR *)(lpStream+dwMemPos+1);
+- dwMemPos += insnamelen + 1;
+- AMS2INSTRUMENT *pins = (AMS2INSTRUMENT *)(lpStream + dwMemPos);
+- dwMemPos += sizeof(AMS2INSTRUMENT);
+- if (dwMemPos + 1024 >= dwMemLength) return TRUE;
+- AMS2ENVELOPE *volenv, *panenv, *pitchenv;
+- volenv = (AMS2ENVELOPE *)(lpStream+dwMemPos);
+- dwMemPos += 5 + volenv->points*3;
+- panenv = (AMS2ENVELOPE *)(lpStream+dwMemPos);
+- dwMemPos += 5 + panenv->points*3;
+- pitchenv = (AMS2ENVELOPE *)(lpStream+dwMemPos);
+- dwMemPos += 5 + pitchenv->points*3;
+- INSTRUMENTHEADER *penv = new INSTRUMENTHEADER;
+- if (!penv) return TRUE;
+- memset(smpmap, 0, sizeof(smpmap));
+- memset(penv, 0, sizeof(INSTRUMENTHEADER));
+- for (UINT ismpmap=0; ismpmap<pins->samples; ismpmap++)
+- {
+- if ((ismpmap >= 16) || (m_nSamples+1 >= MAX_SAMPLES)) break;
+- m_nSamples++;
+- smpmap[ismpmap] = m_nSamples;
+- }
+- penv->nGlobalVol = 64;
+- penv->nPan = 128;
+- penv->nPPC = 60;
+- Headers[nIns] = penv;
+- if (insnamelen)
+- {
+- if (insnamelen > 31) insnamelen = 31;
+- memcpy(penv->name, pinsname, insnamelen);
+- penv->name[insnamelen] = 0;
+- }
+- for (UINT inotemap=0; inotemap<120; inotemap++)
+- {
+- penv->NoteMap[inotemap] = inotemap+1;
+- penv->Keyboard[inotemap] = smpmap[pins->notemap[inotemap] & 0x0F];
+- }
+- // Volume Envelope
+- {
+- UINT pos = 0;
+- penv->VolEnv.nNodes = (volenv->points > 16) ? 16 : volenv->points;
+- penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = volenv->sustain;
+- penv->VolEnv.nLoopStart = volenv->loopbegin;
+- penv->VolEnv.nLoopEnd = volenv->loopend;
+- for (int i=0; i<penv->VolEnv.nNodes; i++)
+- {
+- penv->VolEnv.Values[i] = (BYTE)((volenv->info[i*3+2] & 0x7F) >> 1);
+- pos += volenv->info[i*3] + ((volenv->info[i*3+1] & 1) << 8);
+- penv->VolEnv.Ticks[i] = (WORD)pos;
+- }
+- }
+- penv->nFadeOut = (((lpStream[dwMemPos+2] & 0x0F) << 8) | (lpStream[dwMemPos+1])) << 3;
+- UINT envflags = lpStream[dwMemPos+3];
+- if (envflags & 0x01) penv->dwFlags |= ENV_VOLLOOP;
+- if (envflags & 0x02) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (envflags & 0x04) penv->dwFlags |= ENV_VOLUME;
+- dwMemPos += 5;
+- // Read Samples
+- for (UINT ismp=0; ismp<pins->samples; ismp++)
+- {
+- MODINSTRUMENT *psmp = ((ismp < 16) && (smpmap[ismp])) ? &Ins[smpmap[ismp]] : NULL;
+- UINT smpnamelen = lpStream[dwMemPos];
+- if ((psmp) && (smpnamelen) && (smpnamelen <= 22))
+- {
+- memcpy(m_szNames[smpmap[ismp]], lpStream+dwMemPos+1, smpnamelen);
+- }
+- dwMemPos += smpnamelen + 1;
+- if (psmp)
+- {
+- AMS2SAMPLE *pams = (AMS2SAMPLE *)(lpStream+dwMemPos);
+- psmp->nGlobalVol = 64;
+- psmp->nPan = 128;
+- psmp->nLength = pams->length;
+- psmp->nLoopStart = pams->loopstart;
+- psmp->nLoopEnd = pams->loopend;
+- psmp->nC4Speed = pams->c4speed;
+- psmp->RelativeTone = pams->transpose;
+- psmp->nVolume = pams->volume / 2;
+- packedsamples[smpmap[ismp]] = pams->flags;
+- if (pams->flags & 0x04) psmp->uFlags |= CHN_16BIT;
+- if (pams->flags & 0x08) psmp->uFlags |= CHN_LOOP;
+- if (pams->flags & 0x10) psmp->uFlags |= CHN_PINGPONGLOOP;
+- }
+- dwMemPos += sizeof(AMS2SAMPLE);
+- }
+- }
+- if (dwMemPos + 256 >= dwMemLength) return TRUE;
+- // Comments
+- {
+- UINT composernamelen = lpStream[dwMemPos];
+- if (composernamelen)
+- {
+- m_lpszSongComments = new char[composernamelen+1]; // changed from CHAR
+- if (m_lpszSongComments)
+- {
+- memcpy(m_lpszSongComments, lpStream+dwMemPos+1, composernamelen);
+- m_lpszSongComments[composernamelen] = 0;
+- }
+- }
+- dwMemPos += composernamelen + 1;
+- // channel names
+- for (UINT i=0; i<32; i++)
+- {
+- UINT chnnamlen = lpStream[dwMemPos];
+- if ((chnnamlen) && (chnnamlen < MAX_CHANNELNAME))
+- {
+- memcpy(ChnSettings[i].szName, lpStream+dwMemPos+1, chnnamlen);
+- }
+- dwMemPos += chnnamlen + 1;
+- if (dwMemPos + chnnamlen + 256 >= dwMemLength) return TRUE;
+- }
+- // packed comments (ignored)
+- UINT songtextlen = *((LPDWORD)(lpStream+dwMemPos));
+- dwMemPos += songtextlen;
+- if (dwMemPos + 256 >= dwMemLength) return TRUE;
+- }
+- // Order List
+- {
+- for (UINT i=0; i<MAX_ORDERS; i++)
+- {
+- Order[i] = 0xFF;
+- if (dwMemPos + 2 >= dwMemLength) return TRUE;
+- if (i < psh->orders)
+- {
+- Order[i] = lpStream[dwMemPos];
+- dwMemPos += 2;
+- }
+- }
+- }
+- // Pattern Data
+- for (UINT ipat=0; ipat<psh->patterns; ipat++)
+- {
+- if (dwMemPos+8 >= dwMemLength) return TRUE;
+- UINT packedlen = *((LPDWORD)(lpStream+dwMemPos));
+- UINT numrows = 1 + (UINT)(lpStream[dwMemPos+4]);
+- //UINT patchn = 1 + (UINT)(lpStream[dwMemPos+5] & 0x1F);
+- //UINT patcmds = 1 + (UINT)(lpStream[dwMemPos+5] >> 5);
+- UINT patnamlen = lpStream[dwMemPos+6];
+- dwMemPos += 4;
+- if ((ipat < MAX_PATTERNS) && (packedlen < dwMemLength-dwMemPos) && (numrows >= 8))
+- {
+- if ((patnamlen) && (patnamlen < MAX_PATTERNNAME))
+- {
+- char s[MAX_PATTERNNAME]; // changed from CHAR
+- memcpy(s, lpStream+dwMemPos+3, patnamlen);
+- s[patnamlen] = 0;
+- SetPatternName(ipat, s);
+- }
+- PatternSize[ipat] = numrows;
+- PatternAllocSize[ipat] = numrows;
+- Patterns[ipat] = AllocatePattern(numrows, m_nChannels);
+- if (!Patterns[ipat]) return TRUE;
+- // Unpack Pattern Data
+- LPCBYTE psrc = lpStream + dwMemPos;
+- UINT pos = 3 + patnamlen;
+- UINT row = 0;
+- while ((pos < packedlen) && (row < numrows))
+- {
+- MODCOMMAND *m = Patterns[ipat] + row * m_nChannels;
+- UINT byte1 = psrc[pos++];
+- UINT ch = byte1 & 0x1F;
+- // Read Note + Instr
+- if (!(byte1 & 0x40))
+- {
+- UINT byte2 = psrc[pos++];
+- UINT note = byte2 & 0x7F;
+- if (note) m[ch].note = (note > 1) ? (note-1) : 0xFF;
+- m[ch].instr = psrc[pos++];
+- // Read Effect
+- while (byte2 & 0x80)
+- {
+- byte2 = psrc[pos++];
+- if (byte2 & 0x40)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = byte2 & 0x3F;
+- } else
+- {
+- UINT command = byte2 & 0x3F;
+- UINT param = psrc[pos++];
+- if (command == 0x0C)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = param / 2;
+- } else
+- if (command < 0x10)
+- {
+- m[ch].command = command;
+- m[ch].param = param;
+- ConvertModCommand(&m[ch]);
+- } else
+- {
+- // TODO: AMS effects
+- }
+- }
+- }
+- }
+- if (byte1 & 0x80) row++;
+- }
+- }
+- dwMemPos += packedlen;
+- }
+- // Read Samples
+- for (UINT iSmp=1; iSmp<=m_nSamples; iSmp++) if (Ins[iSmp].nLength)
+- {
+- if (dwMemPos >= dwMemLength - 9) return TRUE;
+- UINT flags;
+- if (packedsamples[iSmp] & 0x03)
+- {
+- flags = (Ins[iSmp].uFlags & CHN_16BIT) ? RS_AMS16 : RS_AMS8;
+- } else
+- {
+- flags = (Ins[iSmp].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+- }
+- dwMemPos += ReadSample(&Ins[iSmp], flags, (LPSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+- }
+- return TRUE;
+-}
+-
+-
+-/////////////////////////////////////////////////////////////////////
+-// AMS Sample unpacking
+-
+-void AMSUnpack(const char *psrc, UINT inputlen, char *pdest, UINT dmax, char packcharacter)
+-{
+- UINT tmplen = dmax;
+- signed char *amstmp = new signed char[tmplen];
+-
+- if (!amstmp) return;
+- // Unpack Loop
+- {
+- signed char *p = amstmp;
+- UINT i=0, j=0;
+- while ((i < inputlen) && (j < tmplen))
+- {
+- signed char ch = psrc[i++];
+- if (ch == packcharacter)
+- {
+- BYTE ch2 = psrc[i++];
+- if (ch2)
+- {
+- ch = psrc[i++];
+- while (ch2--)
+- {
+- p[j++] = ch;
+- if (j >= tmplen) break;
+- }
+- } else p[j++] = packcharacter;
+- } else p[j++] = ch;
+- }
+- }
+- // Bit Unpack Loop
+- {
+- signed char *p = amstmp;
+- UINT bitcount = 0x80, dh;
+- UINT k=0;
+- for (UINT i=0; i<dmax; i++)
+- {
+- BYTE al = *p++;
+- dh = 0;
+- for (UINT count=0; count<8; count++)
+- {
+- UINT bl = al & bitcount;
+- bl = ((bl|(bl<<8)) >> ((dh+8-count) & 7)) & 0xFF;
+- bitcount = ((bitcount|(bitcount<<8)) >> 1) & 0xFF;
+- pdest[k++] |= bl;
+- if (k >= dmax)
+- {
+- k = 0;
+- dh++;
+- }
+- }
+- bitcount = ((bitcount|(bitcount<<8)) >> dh) & 0xFF;
+- }
+- }
+- // Delta Unpack
+- {
+- signed char old = 0;
+- for (UINT i=0; i<dmax; i++)
+- {
+- int pos = ((LPBYTE)pdest)[i];
+- if ((pos != 128) && (pos & 0x80)) pos = -(pos & 0x7F);
+- old -= (signed char)pos;
+- pdest[i] = old;
+- }
+- }
+- delete amstmp;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_dbm.cxx audacious-plugins-2.5.4/src/modplug/load_dbm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_dbm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_dbm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,370 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-///////////////////////////////////////////////////////////////
+-//
+-// DigiBooster Pro Module Loader (*.dbm)
+-//
+-// Note: this loader doesn't handle multiple songs
+-//
+-///////////////////////////////////////////////////////////////
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#define DBM_FILE_MAGIC 0x304d4244
+-#define DBM_ID_NAME 0x454d414e
+-#define DBM_NAMELEN 0x2c000000
+-#define DBM_ID_INFO 0x4f464e49
+-#define DBM_INFOLEN 0x0a000000
+-#define DBM_ID_SONG 0x474e4f53
+-#define DBM_ID_INST 0x54534e49
+-#define DBM_ID_VENV 0x564e4556
+-#define DBM_ID_PATT 0x54544150
+-#define DBM_ID_SMPL 0x4c504d53
+-
+-#pragma pack(1)
+-
+-typedef struct DBMFILEHEADER
+-{
+- DWORD dbm_id; // "DBM0" = 0x304d4244
+- WORD trkver; // Tracker version: 02.15
+- WORD reserved;
+- DWORD name_id; // "NAME" = 0x454d414e
+- DWORD name_len; // name length: always 44
+- CHAR songname[44];
+- DWORD info_id; // "INFO" = 0x4f464e49
+- DWORD info_len; // 0x0a000000
+- WORD instruments;
+- WORD samples;
+- WORD songs;
+- WORD patterns;
+- WORD channels;
+- DWORD song_id; // "SONG" = 0x474e4f53
+- DWORD song_len;
+- CHAR songname2[44];
+- WORD orders;
+-// WORD orderlist[0]; // orderlist[orders] in words
+-} DBMFILEHEADER;
+-
+-typedef struct DBMINSTRUMENT
+-{
+- CHAR name[30];
+- WORD sampleno;
+- WORD volume;
+- DWORD finetune;
+- DWORD loopstart;
+- DWORD looplen;
+- WORD panning;
+- WORD flags;
+-} DBMINSTRUMENT;
+-
+-typedef struct DBMENVELOPE
+-{
+- WORD instrument;
+- BYTE flags;
+- BYTE numpoints;
+- BYTE sustain1;
+- BYTE loopbegin;
+- BYTE loopend;
+- BYTE sustain2;
+- WORD volenv[2*32];
+-} DBMENVELOPE;
+-
+-typedef struct DBMPATTERN
+-{
+- WORD rows;
+- DWORD packedsize;
+- BYTE patterndata[2]; // [packedsize]
+-} DBMPATTERN;
+-
+-typedef struct DBMSAMPLE
+-{
+- DWORD flags;
+- DWORD samplesize;
+- BYTE sampledata[2]; // [samplesize]
+-} DBMSAMPLE;
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadDBM(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- DBMFILEHEADER *pfh = (DBMFILEHEADER *)lpStream;
+- DWORD dwMemPos;
+- UINT nOrders, nSamples, nInstruments, nPatterns;
+-
+- if ((!lpStream) || (dwMemLength <= sizeof(DBMFILEHEADER)) || (!pfh->channels)
+- || (pfh->dbm_id != DBM_FILE_MAGIC) || (!pfh->songs) || (pfh->song_id != DBM_ID_SONG)
+- || (pfh->name_id != DBM_ID_NAME) || (pfh->name_len != DBM_NAMELEN)
+- || (pfh->info_id != DBM_ID_INFO) || (pfh->info_len != DBM_INFOLEN)) return FALSE;
+- dwMemPos = sizeof(DBMFILEHEADER);
+- nOrders = bswapBE16(pfh->orders);
+- if (dwMemPos + 2 * nOrders + 8*3 >= dwMemLength) return FALSE;
+- nInstruments = bswapBE16(pfh->instruments);
+- nSamples = bswapBE16(pfh->samples);
+- nPatterns = bswapBE16(pfh->patterns);
+- m_nType = MOD_TYPE_DBM;
+- m_nChannels = bswapBE16(pfh->channels);
+- if (m_nChannels < 4) m_nChannels = 4;
+- if (m_nChannels > 64) m_nChannels = 64;
+- memcpy(m_szNames[0], (pfh->songname[0]) ? pfh->songname : pfh->songname2, 32);
+- m_szNames[0][31] = 0;
+- for (UINT iOrd=0; iOrd < nOrders; iOrd++)
+- {
+- Order[iOrd] = lpStream[dwMemPos+iOrd*2+1];
+- if (iOrd >= MAX_ORDERS-2) break;
+- }
+- dwMemPos += 2*nOrders;
+- while (dwMemPos + 10 < dwMemLength)
+- {
+- DWORD chunk_id = ((LPDWORD)(lpStream+dwMemPos))[0];
+- DWORD chunk_size = bswapBE32(((LPDWORD)(lpStream+dwMemPos))[1]);
+- DWORD chunk_pos;
+-
+- dwMemPos += 8;
+- chunk_pos = dwMemPos;
+- if ((dwMemPos + chunk_size > dwMemLength) || (chunk_size > dwMemLength)) break;
+- dwMemPos += chunk_size;
+- // Instruments
+- if (chunk_id == DBM_ID_INST)
+- {
+- if (nInstruments >= MAX_INSTRUMENTS) nInstruments = MAX_INSTRUMENTS-1;
+- for (UINT iIns=0; iIns<nInstruments; iIns++)
+- {
+- MODINSTRUMENT *psmp;
+- INSTRUMENTHEADER *penv;
+- DBMINSTRUMENT *pih;
+- UINT nsmp;
+-
+- if (chunk_pos + sizeof(DBMINSTRUMENT) > dwMemPos) break;
+- if ((penv = new INSTRUMENTHEADER) == NULL) break;
+- pih = (DBMINSTRUMENT *)(lpStream+chunk_pos);
+- nsmp = bswapBE16(pih->sampleno);
+- psmp = ((nsmp) && (nsmp < MAX_SAMPLES)) ? &Ins[nsmp] : NULL;
+- memset(penv, 0, sizeof(INSTRUMENTHEADER));
+- memcpy(penv->name, pih->name, 30);
+- if (psmp)
+- {
+- memcpy(m_szNames[nsmp], pih->name, 30);
+- m_szNames[nsmp][30] = 0;
+- }
+- Headers[iIns+1] = penv;
+- penv->nFadeOut = 1024; // ???
+- penv->nGlobalVol = 128;
+- penv->nPan = bswapBE16(pih->panning);
+- if ((penv->nPan) && (penv->nPan < 256))
+- penv->dwFlags = ENV_SETPANNING;
+- else
+- penv->nPan = 128;
+- penv->nPPC = 5*12;
+- for (UINT i=0; i<120; i++)
+- {
+- penv->Keyboard[i] = nsmp;
+- penv->NoteMap[i] = i+1;
+- }
+- // Sample Info
+- if (psmp)
+- {
+- DWORD sflags = bswapBE16(pih->flags);
+- psmp->nVolume = bswapBE16(pih->volume) * 4;
+- if ((!psmp->nVolume) || (psmp->nVolume > 256)) psmp->nVolume = 256;
+- psmp->nGlobalVol = 64;
+- psmp->nC4Speed = bswapBE32(pih->finetune);
+- int f2t = FrequencyToTranspose(psmp->nC4Speed);
+- psmp->RelativeTone = f2t >> 7;
+- psmp->nFineTune = f2t & 0x7F;
+- if ((pih->looplen) && (sflags & 3))
+- {
+- psmp->nLoopStart = bswapBE32(pih->loopstart);
+- psmp->nLoopEnd = psmp->nLoopStart + bswapBE32(pih->looplen);
+- psmp->uFlags |= CHN_LOOP;
+- psmp->uFlags &= ~CHN_PINGPONGLOOP;
+- if (sflags & 2) psmp->uFlags |= CHN_PINGPONGLOOP;
+- }
+- }
+- chunk_pos += sizeof(DBMINSTRUMENT);
+- m_nInstruments = iIns+1;
+- }
+- m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- } else
+- // Volume Envelopes
+- if (chunk_id == DBM_ID_VENV)
+- {
+- UINT nEnvelopes = lpStream[chunk_pos+1];
+-
+- chunk_pos += 2;
+- for (UINT iEnv=0; iEnv<nEnvelopes; iEnv++)
+- {
+- DBMENVELOPE *peh;
+- UINT nins;
+-
+- if (chunk_pos + sizeof(DBMENVELOPE) > dwMemPos) break;
+- peh = (DBMENVELOPE *)(lpStream+chunk_pos);
+- nins = bswapBE16(peh->instrument);
+- if ((nins) && (nins < MAX_INSTRUMENTS) && (Headers[nins]) && (peh->numpoints))
+- {
+- INSTRUMENTHEADER *penv = Headers[nins];
+-
+- if (peh->flags & 1) penv->dwFlags |= ENV_VOLUME;
+- if (peh->flags & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (peh->flags & 4) penv->dwFlags |= ENV_VOLLOOP;
+- penv->VolEnv.nNodes = peh->numpoints + 1;
+- if (penv->VolEnv.nNodes > MAX_ENVPOINTS) penv->VolEnv.nNodes = MAX_ENVPOINTS;
+- penv->VolEnv.nLoopStart = peh->loopbegin;
+- penv->VolEnv.nLoopEnd = peh->loopend;
+- penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = peh->sustain1;
+- for (int i=0; i<penv->VolEnv.nNodes; i++)
+- {
+- penv->VolEnv.Ticks[i] = bswapBE16(peh->volenv[i*2]);
+- penv->VolEnv.Values[i] = (BYTE)bswapBE16(peh->volenv[i*2+1]);
+- }
+- }
+- chunk_pos += sizeof(DBMENVELOPE);
+- }
+- } else
+- // Packed Pattern Data
+- if (chunk_id == DBM_ID_PATT)
+- {
+- if (nPatterns > MAX_PATTERNS) nPatterns = MAX_PATTERNS;
+- for (UINT iPat=0; iPat<nPatterns; iPat++)
+- {
+- DBMPATTERN *pph;
+- DWORD pksize;
+- UINT nRows;
+-
+- if (chunk_pos + sizeof(DBMPATTERN) > dwMemPos) break;
+- pph = (DBMPATTERN *)(lpStream+chunk_pos);
+- pksize = bswapBE32(pph->packedsize);
+- if ((chunk_pos + pksize + 6 > dwMemPos) || (pksize > dwMemPos)) break;
+- nRows = bswapBE16(pph->rows);
+- if ((nRows >= 4) && (nRows <= 256))
+- {
+- MODCOMMAND *m = AllocatePattern(nRows, m_nChannels);
+- if (m)
+- {
+- LPBYTE pkdata = (LPBYTE)&pph->patterndata;
+- UINT row = 0;
+- UINT i = 0;
+-
+- PatternSize[iPat] = nRows;
+- PatternAllocSize[iPat] = nRows;
+- Patterns[iPat] = m;
+- while ((i+3<pksize) && (row < nRows))
+- {
+- UINT ch = pkdata[i++];
+-
+- if (ch)
+- {
+- BYTE b = pkdata[i++];
+- ch--;
+- if (ch < m_nChannels)
+- {
+- if (b & 0x01)
+- {
+- UINT note = pkdata[i++];
+-
+- if (note == 0x1F) note = 0xFF; else
+- if ((note) && (note < 0xFE))
+- {
+- note = ((note >> 4)*12) + (note & 0x0F) + 13;
+- }
+- m[ch].note = note;
+- }
+- if (b & 0x02) m[ch].instr = pkdata[i++];
+- if (b & 0x3C)
+- {
+- UINT cmd1 = 0xFF, param1 = 0, cmd2 = 0xFF, param2 = 0;
+- if (b & 0x04) cmd1 = (UINT)pkdata[i++];
+- if (b & 0x08) param1 = pkdata[i++];
+- if (b & 0x10) cmd2 = (UINT)pkdata[i++];
+- if (b & 0x20) param2 = pkdata[i++];
+- if (cmd1 == 0x0C)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = param1;
+- cmd1 = 0xFF;
+- } else
+- if (cmd2 == 0x0C)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = param2;
+- cmd2 = 0xFF;
+- }
+- if ((cmd1 > 0x13) || ((cmd1 >= 0x10) && (cmd2 < 0x10)))
+- {
+- cmd1 = cmd2;
+- param1 = param2;
+- cmd2 = 0xFF;
+- }
+- if (cmd1 <= 0x13)
+- {
+- m[ch].command = cmd1;
+- m[ch].param = param1;
+- ConvertModCommand(&m[ch]);
+- }
+- }
+- } else
+- {
+- if (b & 0x01) i++;
+- if (b & 0x02) i++;
+- if (b & 0x04) i++;
+- if (b & 0x08) i++;
+- if (b & 0x10) i++;
+- if (b & 0x20) i++;
+- }
+- } else
+- {
+- row++;
+- m += m_nChannels;
+- }
+- }
+- }
+- }
+- chunk_pos += 6 + pksize;
+- }
+- } else
+- // Reading Sample Data
+- if (chunk_id == DBM_ID_SMPL)
+- {
+- if (nSamples >= MAX_SAMPLES) nSamples = MAX_SAMPLES-1;
+- m_nSamples = nSamples;
+- for (UINT iSmp=1; iSmp<=nSamples; iSmp++)
+- {
+- MODINSTRUMENT *pins;
+- DBMSAMPLE *psh;
+- DWORD samplesize;
+- DWORD sampleflags;
+-
+- if (chunk_pos + sizeof(DBMSAMPLE) >= dwMemPos) break;
+- psh = (DBMSAMPLE *)(lpStream+chunk_pos);
+- chunk_pos += 8;
+- samplesize = bswapBE32(psh->samplesize);
+- sampleflags = bswapBE32(psh->flags);
+- pins = &Ins[iSmp];
+- pins->nLength = samplesize;
+- if (sampleflags & 2)
+- {
+- pins->uFlags |= CHN_16BIT;
+- samplesize <<= 1;
+- }
+- if ((chunk_pos+samplesize > dwMemPos) || (samplesize > dwMemLength)) break;
+- if (sampleflags & 3)
+- {
+- ReadSample(pins, (pins->uFlags & CHN_16BIT) ? RS_PCM16M : RS_PCM8S,
+- (LPSTR)(psh->sampledata), samplesize);
+- }
+- chunk_pos += samplesize;
+- }
+- }
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_dmf.cxx audacious-plugins-2.5.4/src/modplug/load_dmf.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_dmf.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_dmf.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,607 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-///////////////////////////////////////////////////////
+-// DMF DELUSION DIGITAL MUSIC FILEFORMAT (X-Tracker) //
+-///////////////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#define DMFLOG
+-
+-//#pragma warning(disable:4244)
+-
+-#pragma pack(1)
+-
+-typedef struct DMFHEADER
+-{
+- DWORD id; // "DDMF" = 0x464d4444
+- BYTE version; // 4
+- CHAR trackername[8]; // "XTRACKER"
+- CHAR songname[30];
+- CHAR composer[20];
+- BYTE date[3];
+-} DMFHEADER;
+-
+-typedef struct DMFINFO
+-{
+- DWORD id; // "INFO"
+- DWORD infosize;
+-} DMFINFO;
+-
+-typedef struct DMFSEQU
+-{
+- DWORD id; // "SEQU"
+- DWORD seqsize;
+- WORD loopstart;
+- WORD loopend;
+- WORD sequ[2];
+-} DMFSEQU;
+-
+-typedef struct DMFPATT
+-{
+- DWORD id; // "PATT"
+- DWORD patsize;
+- WORD numpat; // 1-1024
+- BYTE tracks;
+- BYTE firstpatinfo;
+-} DMFPATT;
+-
+-typedef struct DMFTRACK
+-{
+- BYTE tracks;
+- BYTE beat; // [hi|lo] -> hi=ticks per beat, lo=beats per measure
+- WORD ticks; // max 512
+- DWORD jmpsize;
+-} DMFTRACK;
+-
+-typedef struct DMFSMPI
+-{
+- DWORD id;
+- DWORD size;
+- BYTE samples;
+-} DMFSMPI;
+-
+-typedef struct DMFSAMPLE
+-{
+- DWORD len;
+- DWORD loopstart;
+- DWORD loopend;
+- WORD c3speed;
+- BYTE volume;
+- BYTE flags;
+-} DMFSAMPLE;
+-
+-#pragma pack()
+-
+-
+-#ifdef DMFLOG
+-extern void Log(LPCSTR s, ...);
+-#endif
+-
+-
+-BOOL CSoundFile::ReadDMF(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- DMFHEADER *pfh = (DMFHEADER *)lpStream;
+- DMFINFO *psi;
+- DMFSEQU *sequ;
+- DWORD dwMemPos;
+- BYTE infobyte[32];
+- BYTE smplflags[MAX_SAMPLES];
+-
+- if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
+- if ((pfh->id != 0x464d4444) || (!pfh->version) || (pfh->version & 0xF0)) return FALSE;
+- dwMemPos = 66;
+- memcpy(m_szNames[0], pfh->songname, 30);
+- m_szNames[0][30] = 0;
+- m_nType = MOD_TYPE_DMF;
+- m_nChannels = 0;
+-#ifdef DMFLOG
+- Log("DMF version %d: \"%s\": %d bytes (0x%04X)\n", pfh->version, m_szNames[0], dwMemLength, dwMemLength);
+-#endif
+- while (dwMemPos + 7 < dwMemLength)
+- {
+- DWORD id = *((LPDWORD)(lpStream+dwMemPos));
+-
+- switch(id)
+- {
+- // "INFO"
+- case 0x4f464e49:
+- // "CMSG"
+- case 0x47534d43:
+- psi = (DMFINFO *)(lpStream+dwMemPos);
+- if (id == 0x47534d43) dwMemPos++;
+- if ((psi->infosize > dwMemLength) || (psi->infosize + dwMemPos + 8 > dwMemLength)) goto dmfexit;
+- if ((psi->infosize >= 8) && (!m_lpszSongComments))
+- {
+- m_lpszSongComments = new char[psi->infosize]; // changed from CHAR
+- if (m_lpszSongComments)
+- {
+- for (UINT i=0; i<psi->infosize-1; i++)
+- {
+- CHAR c = lpStream[dwMemPos+8+i];
+- if ((i % 40) == 39)
+- m_lpszSongComments[i] = 0x0d;
+- else
+- m_lpszSongComments[i] = (c < ' ') ? ' ' : c;
+- }
+- m_lpszSongComments[psi->infosize-1] = 0;
+- }
+- }
+- dwMemPos += psi->infosize + 8 - 1;
+- break;
+-
+- // "SEQU"
+- case 0x55514553:
+- sequ = (DMFSEQU *)(lpStream+dwMemPos);
+- if ((sequ->seqsize >= dwMemLength) || (dwMemPos + sequ->seqsize + 12 > dwMemLength)) goto dmfexit;
+- {
+- UINT nseq = sequ->seqsize >> 1;
+- if (nseq >= MAX_ORDERS-1) nseq = MAX_ORDERS-1;
+- if (sequ->loopstart < nseq) m_nRestartPos = sequ->loopstart;
+- for (UINT i=0; i<nseq; i++) Order[i] = (BYTE)sequ->sequ[i];
+- }
+- dwMemPos += sequ->seqsize + 8;
+- break;
+-
+- // "PATT"
+- case 0x54544150:
+- if (!m_nChannels)
+- {
+- DMFPATT *patt = (DMFPATT *)(lpStream+dwMemPos);
+- UINT numpat;
+- DWORD dwPos = dwMemPos + 11;
+- if ((patt->patsize >= dwMemLength) || (dwMemPos + patt->patsize + 8 > dwMemLength)) goto dmfexit;
+- numpat = patt->numpat;
+- if (numpat > MAX_PATTERNS) numpat = MAX_PATTERNS;
+- m_nChannels = patt->tracks;
+- if (m_nChannels < patt->firstpatinfo) m_nChannels = patt->firstpatinfo;
+- if (m_nChannels > 32) m_nChannels = 32;
+- if (m_nChannels < 4) m_nChannels = 4;
+- for (UINT npat=0; npat<numpat; npat++)
+- {
+- DMFTRACK *pt = (DMFTRACK *)(lpStream+dwPos);
+- #ifdef DMFLOG
+- Log("Pattern #%d: %d tracks, %d rows\n", npat, pt->tracks, pt->ticks);
+- #endif
+- UINT tracks = pt->tracks;
+- if (tracks > 32) tracks = 32;
+- UINT ticks = pt->ticks;
+- if (ticks > 256) ticks = 256;
+- if (ticks < 16) ticks = 16;
+- dwPos += 8;
+- if ((pt->jmpsize >= dwMemLength) || (dwPos + pt->jmpsize + 4 >= dwMemLength)) break;
+- PatternSize[npat] = (WORD)ticks;
+- PatternAllocSize[npat] = (WORD)ticks;
+- MODCOMMAND *m = AllocatePattern(PatternSize[npat], m_nChannels);
+- if (!m) goto dmfexit;
+- Patterns[npat] = m;
+- DWORD d = dwPos;
+- dwPos += pt->jmpsize;
+- UINT ttype = 1;
+- UINT tempo = 125;
+- UINT glbinfobyte = 0;
+- UINT pbeat = (pt->beat & 0xf0) ? pt->beat>>4 : 8;
+- BOOL tempochange = (pt->beat & 0xf0) ? TRUE : FALSE;
+- memset(infobyte, 0, sizeof(infobyte));
+- for (UINT row=0; row<ticks; row++)
+- {
+- MODCOMMAND *p = &m[row*m_nChannels];
+- // Parse track global effects
+- if (!glbinfobyte)
+- {
+- BYTE info = lpStream[d++];
+- BYTE infoval = 0;
+- if ((info & 0x80) && (d < dwPos)) glbinfobyte = lpStream[d++];
+- info &= 0x7f;
+- if ((info) && (d < dwPos)) infoval = lpStream[d++];
+- switch(info)
+- {
+- case 1: ttype = 0; tempo = infoval; tempochange = TRUE; break;
+- case 2: ttype = 1; tempo = infoval; tempochange = TRUE; break;
+- case 3: pbeat = infoval>>4; tempochange = ttype; break;
+- #ifdef DMFLOG
+- default: if (info) Log("GLB: %02X.%02X\n", info, infoval);
+- #endif
+- }
+- } else
+- {
+- glbinfobyte--;
+- }
+- // Parse channels
+- for (UINT i=0; i<tracks; i++) if (!infobyte[i])
+- {
+- MODCOMMAND cmd = {0,0,0,0,0,0};
+- BYTE info = lpStream[d++];
+- if (info & 0x80) infobyte[i] = lpStream[d++];
+- // Instrument
+- if (info & 0x40)
+- {
+- cmd.instr = lpStream[d++];
+- }
+- // Note
+- if (info & 0x20)
+- {
+- cmd.note = lpStream[d++];
+- if ((cmd.note) && (cmd.note < 0xfe)) cmd.note &= 0x7f;
+- if ((cmd.note) && (cmd.note < 128)) cmd.note += 24;
+- }
+- // Volume
+- if (info & 0x10)
+- {
+- cmd.volcmd = VOLCMD_VOLUME;
+- cmd.vol = (lpStream[d++]+3)>>2;
+- }
+- // Effect 1
+- if (info & 0x08)
+- {
+- BYTE efx = lpStream[d++];
+- BYTE eval = lpStream[d++];
+- switch(efx)
+- {
+- // 1: Key Off
+- case 1: if (!cmd.note) cmd.note = 0xFE; break;
+- // 2: Set Loop
+- // 4: Sample Delay
+- case 4: if (eval&0xe0) { cmd.command = CMD_S3MCMDEX; cmd.param = (eval>>5)|0xD0; } break;
+- // 5: Retrig
+- case 5: if (eval&0xe0) { cmd.command = CMD_RETRIG; cmd.param = (eval>>5); } break;
+- // 6: Offset
+- case 6: cmd.command = CMD_OFFSET; cmd.param = eval; break;
+- #ifdef DMFLOG
+- default: Log("FX1: %02X.%02X\n", efx, eval);
+- #endif
+- }
+- }
+- // Effect 2
+- if (info & 0x04)
+- {
+- BYTE efx = lpStream[d++];
+- BYTE eval = lpStream[d++];
+- switch(efx)
+- {
+- // 1: Finetune
+- case 1: if (eval&0xf0) { cmd.command = CMD_S3MCMDEX; cmd.param = (eval>>4)|0x20; } break;
+- // 2: Note Delay
+- case 2: if (eval&0xe0) { cmd.command = CMD_S3MCMDEX; cmd.param = (eval>>5)|0xD0; } break;
+- // 3: Arpeggio
+- case 3: if (eval) { cmd.command = CMD_ARPEGGIO; cmd.param = eval; } break;
+- // 4: Portamento Up
+- case 4: cmd.command = CMD_PORTAMENTOUP; cmd.param = (eval >= 0xe0) ? 0xdf : eval; break;
+- // 5: Portamento Down
+- case 5: cmd.command = CMD_PORTAMENTODOWN; cmd.param = (eval >= 0xe0) ? 0xdf : eval; break;
+- // 6: Tone Portamento
+- case 6: cmd.command = CMD_TONEPORTAMENTO; cmd.param = eval; break;
+- // 8: Vibrato
+- case 8: cmd.command = CMD_VIBRATO; cmd.param = eval; break;
+- // 12: Note cut
+- case 12: if (eval & 0xe0) { cmd.command = CMD_S3MCMDEX; cmd.param = (eval>>5)|0xc0; }
+- else if (!cmd.note) { cmd.note = 0xfe; } break;
+- #ifdef DMFLOG
+- default: Log("FX2: %02X.%02X\n", efx, eval);
+- #endif
+- }
+- }
+- // Effect 3
+- if (info & 0x02)
+- {
+- BYTE efx = lpStream[d++];
+- BYTE eval = lpStream[d++];
+- switch(efx)
+- {
+- // 1: Vol Slide Up
+- case 1: if (eval == 0xff) break;
+- eval = (eval+3)>>2; if (eval > 0x0f) eval = 0x0f;
+- cmd.command = CMD_VOLUMESLIDE; cmd.param = eval<<4; break;
+- // 2: Vol Slide Down
+- case 2: if (eval == 0xff) break;
+- eval = (eval+3)>>2; if (eval > 0x0f) eval = 0x0f;
+- cmd.command = CMD_VOLUMESLIDE; cmd.param = eval; break;
+- // 7: Set Pan
+- case 7: if (!cmd.volcmd) { cmd.volcmd = VOLCMD_PANNING; cmd.vol = (eval+3)>>2; }
+- else { cmd.command = CMD_PANNING8; cmd.param = eval; } break;
+- // 8: Pan Slide Left
+- case 8: eval = (eval+3)>>2; if (eval > 0x0f) eval = 0x0f;
+- cmd.command = CMD_PANNINGSLIDE; cmd.param = eval<<4; break;
+- // 9: Pan Slide Right
+- case 9: eval = (eval+3)>>2; if (eval > 0x0f) eval = 0x0f;
+- cmd.command = CMD_PANNINGSLIDE; cmd.param = eval; break;
+- #ifdef DMFLOG
+- default: Log("FX3: %02X.%02X\n", efx, eval);
+- #endif
+-
+- }
+- }
+- // Store effect
+- if (i < m_nChannels) p[i] = cmd;
+- if (d > dwPos)
+- {
+- #ifdef DMFLOG
+- Log("Unexpected EOP: row=%d\n", row);
+- #endif
+- break;
+- }
+- } else
+- {
+- infobyte[i]--;
+- }
+-
+- // Find free channel for tempo change
+- if (tempochange)
+- {
+- tempochange = FALSE;
+- UINT speed=6, modtempo=tempo;
+- UINT rpm = ((ttype) && (pbeat)) ? tempo*pbeat : (tempo+1)*15;
+- for (speed=30; speed>1; speed--)
+- {
+- modtempo = rpm*speed/24;
+- if (modtempo <= 200) break;
+- if ((speed < 6) && (modtempo < 256)) break;
+- }
+- #ifdef DMFLOG
+- Log("Tempo change: ttype=%d pbeat=%d tempo=%3d -> speed=%d tempo=%d\n",
+- ttype, pbeat, tempo, speed, modtempo);
+- #endif
+- for (UINT ich=0; ich<m_nChannels; ich++) if (!p[ich].command)
+- {
+- if (speed)
+- {
+- p[ich].command = CMD_SPEED;
+- p[ich].param = (BYTE)speed;
+- speed = 0;
+- } else
+- if ((modtempo >= 32) && (modtempo < 256))
+- {
+- p[ich].command = CMD_TEMPO;
+- p[ich].param = (BYTE)modtempo;
+- modtempo = 0;
+- } else
+- {
+- break;
+- }
+- }
+- }
+- if (d >= dwPos) break;
+- }
+- #ifdef DMFLOG
+- Log(" %d/%d bytes remaining\n", dwPos-d, pt->jmpsize);
+- #endif
+- if (dwPos + 8 >= dwMemLength) break;
+- }
+- dwMemPos += patt->patsize + 8;
+- }
+- break;
+-
+- // "SMPI": Sample Info
+- case 0x49504d53:
+- {
+- DMFSMPI *pds = (DMFSMPI *)(lpStream+dwMemPos);
+- if (pds->size <= dwMemLength - dwMemPos)
+- {
+- DWORD dwPos = dwMemPos + 9;
+- m_nSamples = pds->samples;
+- if (m_nSamples >= MAX_SAMPLES) m_nSamples = MAX_SAMPLES-1;
+- for (UINT iSmp=1; iSmp<=m_nSamples; iSmp++)
+- {
+- UINT namelen = lpStream[dwPos];
+- smplflags[iSmp] = 0;
+- if (dwPos+namelen+1+sizeof(DMFSAMPLE) > dwMemPos+pds->size+8) break;
+- if (namelen)
+- {
+- UINT rlen = (namelen < 32) ? namelen : 31;
+- memcpy(m_szNames[iSmp], lpStream+dwPos+1, rlen);
+- m_szNames[iSmp][rlen] = 0;
+- }
+- dwPos += namelen + 1;
+- DMFSAMPLE *psh = (DMFSAMPLE *)(lpStream+dwPos);
+- MODINSTRUMENT *psmp = &Ins[iSmp];
+- psmp->nLength = psh->len;
+- psmp->nLoopStart = psh->loopstart;
+- psmp->nLoopEnd = psh->loopend;
+- psmp->nC4Speed = psh->c3speed;
+- psmp->nGlobalVol = 64;
+- psmp->nVolume = (psh->volume) ? ((WORD)psh->volume)+1 : (WORD)256;
+- psmp->uFlags = (psh->flags & 2) ? CHN_16BIT : 0;
+- if (psmp->uFlags & CHN_16BIT) psmp->nLength >>= 1;
+- if (psh->flags & 1) psmp->uFlags |= CHN_LOOP;
+- smplflags[iSmp] = psh->flags;
+- dwPos += (pfh->version < 8) ? 22 : 30;
+- #ifdef DMFLOG
+- Log("SMPI %d/%d: len=%d flags=0x%02X\n", iSmp, m_nSamples, psmp->nLength, psh->flags);
+- #endif
+- }
+- }
+- dwMemPos += pds->size + 8;
+- }
+- break;
+-
+- // "SMPD": Sample Data
+- case 0x44504d53:
+- {
+- DWORD dwPos = dwMemPos + 8;
+- UINT ismpd = 0;
+- for (UINT iSmp=1; iSmp<=m_nSamples; iSmp++)
+- {
+- ismpd++;
+- DWORD pksize;
+- if (dwPos + 4 >= dwMemLength)
+- {
+- #ifdef DMFLOG
+- Log("Unexpected EOF at sample %d/%d! (pos=%d)\n", iSmp, m_nSamples, dwPos);
+- #endif
+- break;
+- }
+- pksize = *((LPDWORD)(lpStream+dwPos));
+- #ifdef DMFLOG
+- Log("sample %d: pos=0x%X pksize=%d ", iSmp, dwPos, pksize);
+- Log("len=%d flags=0x%X [%08X]\n", Ins[iSmp].nLength, smplflags[ismpd], *((LPDWORD)(lpStream+dwPos+4)));
+- #endif
+- dwPos += 4;
+- if (pksize > dwMemLength - dwPos)
+- {
+- #ifdef DMFLOG
+- Log("WARNING: pksize=%d, but only %d bytes left\n", pksize, dwMemLength-dwPos);
+- #endif
+- pksize = dwMemLength - dwPos;
+- }
+- if ((pksize) && (iSmp <= m_nSamples))
+- {
+- UINT flags = (Ins[iSmp].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+- if (smplflags[ismpd] & 4) flags = (Ins[iSmp].uFlags & CHN_16BIT) ? RS_DMF16 : RS_DMF8;
+- ReadSample(&Ins[iSmp], flags, (LPSTR)(lpStream+dwPos), pksize);
+- }
+- dwPos += pksize;
+- }
+- dwMemPos = dwPos;
+- }
+- break;
+-
+- // "ENDE": end of file
+- case 0x45444e45:
+- goto dmfexit;
+-
+- // Unrecognized id, or "ENDE" field
+- default:
+- dwMemPos += 4;
+- break;
+- }
+- }
+-dmfexit:
+- if (!m_nChannels)
+- {
+- if (!m_nSamples)
+- {
+- m_nType = MOD_TYPE_NONE;
+- return FALSE;
+- }
+- m_nChannels = 4;
+- }
+- return TRUE;
+-}
+-
+-
+-///////////////////////////////////////////////////////////////////////
+-// DMF Compression
+-
+-#pragma pack(1)
+-
+-typedef struct DMF_HNODE
+-{
+- short int left, right;
+- BYTE value;
+-} DMF_HNODE;
+-
+-typedef struct DMF_HTREE
+-{
+- LPBYTE ibuf, ibufmax;
+- DWORD bitbuf;
+- UINT bitnum;
+- UINT lastnode, nodecount;
+- DMF_HNODE nodes[256];
+-} DMF_HTREE;
+-
+-#pragma pack()
+-
+-
+-// DMF Huffman ReadBits
+-BYTE DMFReadBits(DMF_HTREE *tree, UINT nbits)
+-//-------------------------------------------
+-{
+- BYTE x = 0, bitv = 1;
+- while (nbits--)
+- {
+- if (tree->bitnum)
+- {
+- tree->bitnum--;
+- } else
+- {
+- tree->bitbuf = (tree->ibuf < tree->ibufmax) ? *(tree->ibuf++) : 0;
+- tree->bitnum = 7;
+- }
+- if (tree->bitbuf & 1) x |= bitv;
+- bitv <<= 1;
+- tree->bitbuf >>= 1;
+- }
+- return x;
+-}
+-
+-//
+-// tree: [8-bit value][12-bit index][12-bit index] = 32-bit
+-//
+-
+-void DMFNewNode(DMF_HTREE *tree)
+-//------------------------------
+-{
+- BYTE isleft, isright;
+- UINT actnode;
+-
+- actnode = tree->nodecount;
+- if (actnode > 255) return;
+- tree->nodes[actnode].value = DMFReadBits(tree, 7);
+- isleft = DMFReadBits(tree, 1);
+- isright = DMFReadBits(tree, 1);
+- actnode = tree->lastnode;
+- if (actnode > 255) return;
+- tree->nodecount++;
+- tree->lastnode = tree->nodecount;
+- if (isleft)
+- {
+- tree->nodes[actnode].left = tree->lastnode;
+- DMFNewNode(tree);
+- } else
+- {
+- tree->nodes[actnode].left = -1;
+- }
+- tree->lastnode = tree->nodecount;
+- if (isright)
+- {
+- tree->nodes[actnode].right = tree->lastnode;
+- DMFNewNode(tree);
+- } else
+- {
+- tree->nodes[actnode].right = -1;
+- }
+-}
+-
+-
+-int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen)
+-//----------------------------------------------------------------------
+-{
+- DMF_HTREE tree;
+- UINT actnode;
+- BYTE value, sign, delta = 0;
+-
+- memset(&tree, 0, sizeof(tree));
+- tree.ibuf = ibuf;
+- tree.ibufmax = ibufmax;
+- DMFNewNode(&tree);
+- value = 0;
+- for (UINT i=0; i<maxlen; i++)
+- {
+- actnode = 0;
+- sign = DMFReadBits(&tree, 1);
+- do
+- {
+- if (DMFReadBits(&tree, 1))
+- actnode = tree.nodes[actnode].right;
+- else
+- actnode = tree.nodes[actnode].left;
+- if (actnode > 255) break;
+- delta = tree.nodes[actnode].value;
+- if ((tree.ibuf >= tree.ibufmax) && (!tree.bitnum)) break;
+- } while ((tree.nodes[actnode].left >= 0) && (tree.nodes[actnode].right >= 0));
+- if (sign) delta ^= 0xFF;
+- value += delta;
+- psample[i] = (i) ? value : 0;
+- }
+-#ifdef DMFLOG
+-// Log("DMFUnpack: %d remaining bytes\n", tree.ibufmax-tree.ibuf);
+-#endif
+- return tree.ibuf - ibuf;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_dsm.cxx audacious-plugins-2.5.4/src/modplug/load_dsm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_dsm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_dsm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,237 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-//////////////////////////////////////////////
+-// DSIK Internal Format (DSM) module loader //
+-//////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#pragma pack(1)
+-
+-#define DSMID_RIFF 0x46464952 // "RIFF"
+-#define DSMID_DSMF 0x464d5344 // "DSMF"
+-#define DSMID_SONG 0x474e4f53 // "SONG"
+-#define DSMID_INST 0x54534e49 // "INST"
+-#define DSMID_PATT 0x54544150 // "PATT"
+-
+-
+-typedef struct DSMNOTE
+-{
+- BYTE note,ins,vol,cmd,inf;
+-} DSMNOTE;
+-
+-
+-typedef struct DSMINST
+-{
+- DWORD id_INST;
+- DWORD inst_len;
+- CHAR filename[13];
+- BYTE flags;
+- BYTE flags2;
+- BYTE volume;
+- DWORD length;
+- DWORD loopstart;
+- DWORD loopend;
+- DWORD reserved1;
+- WORD c2spd;
+- WORD reserved2;
+- CHAR samplename[28];
+-} DSMINST;
+-
+-
+-typedef struct DSMFILEHEADER
+-{
+- DWORD id_RIFF; // "RIFF"
+- DWORD riff_len;
+- DWORD id_DSMF; // "DSMF"
+- DWORD id_SONG; // "SONG"
+- DWORD song_len;
+-} DSMFILEHEADER;
+-
+-
+-typedef struct DSMSONG
+-{
+- CHAR songname[28];
+- WORD reserved1;
+- WORD flags;
+- DWORD reserved2;
+- WORD numord;
+- WORD numsmp;
+- WORD numpat;
+- WORD numtrk;
+- BYTE globalvol;
+- BYTE mastervol;
+- BYTE speed;
+- BYTE bpm;
+- BYTE panpos[16];
+- BYTE orders[128];
+-} DSMSONG;
+-
+-typedef struct DSMPATT
+-{
+- DWORD id_PATT;
+- DWORD patt_len;
+- BYTE dummy1;
+- BYTE dummy2;
+-} DSMPATT;
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadDSM(LPCBYTE lpStream, DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- DSMFILEHEADER *pfh = (DSMFILEHEADER *)lpStream;
+- DSMSONG *psong;
+- DWORD dwMemPos;
+- UINT nPat, nSmp;
+-
+- if ((!lpStream) || (dwMemLength < 1024) || (pfh->id_RIFF != DSMID_RIFF)
+- || (pfh->riff_len + 8 > dwMemLength) || (pfh->riff_len < 1024)
+- || (pfh->id_DSMF != DSMID_DSMF) || (pfh->id_SONG != DSMID_SONG)
+- || (pfh->song_len > dwMemLength)) return FALSE;
+- psong = (DSMSONG *)(lpStream + sizeof(DSMFILEHEADER));
+- dwMemPos = sizeof(DSMFILEHEADER) + pfh->song_len;
+- m_nType = MOD_TYPE_DSM;
+- m_nChannels = psong->numtrk;
+- if (m_nChannels < 4) m_nChannels = 4;
+- if (m_nChannels > 16) m_nChannels = 16;
+- m_nSamples = psong->numsmp;
+- if (m_nSamples > MAX_SAMPLES) m_nSamples = MAX_SAMPLES;
+- m_nDefaultSpeed = psong->speed;
+- m_nDefaultTempo = psong->bpm;
+- m_nDefaultGlobalVolume = psong->globalvol << 2;
+- if ((!m_nDefaultGlobalVolume) || (m_nDefaultGlobalVolume > 256)) m_nDefaultGlobalVolume = 256;
+- m_nSongPreAmp = psong->mastervol & 0x7F;
+- for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+- {
+- Order[iOrd] = (BYTE)((iOrd < psong->numord) ? psong->orders[iOrd] : 0xFF);
+- }
+- for (UINT iPan=0; iPan<16; iPan++)
+- {
+- ChnSettings[iPan].nPan = 0x80;
+- if (psong->panpos[iPan] <= 0x80)
+- {
+- ChnSettings[iPan].nPan = psong->panpos[iPan] << 1;
+- }
+- }
+- memcpy(m_szNames[0], psong->songname, 28);
+- nPat = 0;
+- nSmp = 1;
+- while (dwMemPos < dwMemLength - 8)
+- {
+- DSMPATT *ppatt = (DSMPATT *)(lpStream + dwMemPos);
+- DSMINST *pins = (DSMINST *)(lpStream+dwMemPos);
+- // Reading Patterns
+- if (ppatt->id_PATT == DSMID_PATT)
+- {
+- dwMemPos += 8;
+- if (dwMemPos + ppatt->patt_len >= dwMemLength) break;
+- DWORD dwPos = dwMemPos;
+- dwMemPos += ppatt->patt_len;
+- MODCOMMAND *m = AllocatePattern(64, m_nChannels);
+- if (!m) break;
+- PatternSize[nPat] = 64;
+- PatternAllocSize[nPat] = 64;
+- Patterns[nPat] = m;
+- UINT row = 0;
+- while ((row < 64) && (dwPos + 2 <= dwMemPos))
+- {
+- UINT flag = lpStream[dwPos++];
+- if (flag)
+- {
+- UINT ch = (flag & 0x0F) % m_nChannels;
+- if (flag & 0x80)
+- {
+- UINT note = lpStream[dwPos++];
+- if (note)
+- {
+- if (note <= 12*9) note += 12;
+- m[ch].note = (BYTE)note;
+- }
+- }
+- if (flag & 0x40)
+- {
+- m[ch].instr = lpStream[dwPos++];
+- }
+- if (flag & 0x20)
+- {
+- m[ch].volcmd = VOLCMD_VOLUME;
+- m[ch].vol = lpStream[dwPos++];
+- }
+- if (flag & 0x10)
+- {
+- UINT command = lpStream[dwPos++];
+- UINT param = lpStream[dwPos++];
+- switch(command)
+- {
+- // 4-bit Panning
+- case 0x08:
+- switch(param & 0xF0)
+- {
+- case 0x00: param <<= 4; break;
+- case 0x10: command = 0x0A; param = (param & 0x0F) << 4; break;
+- case 0x20: command = 0x0E; param = (param & 0x0F) | 0xA0; break;
+- case 0x30: command = 0x0E; param = (param & 0x0F) | 0x10; break;
+- case 0x40: command = 0x0E; param = (param & 0x0F) | 0x20; break;
+- default: command = 0;
+- }
+- break;
+- // Portamentos
+- case 0x11:
+- case 0x12:
+- command &= 0x0F;
+- break;
+- // 3D Sound (?)
+- case 0x13:
+- command = 'X' - 55;
+- param = 0x91;
+- break;
+- default:
+- // Volume + Offset (?)
+- command = ((command & 0xF0) == 0x20) ? 0x09 : 0;
+- }
+- m[ch].command = (BYTE)command;
+- m[ch].param = (BYTE)param;
+- if (command) ConvertModCommand(&m[ch]);
+- }
+- } else
+- {
+- m += m_nChannels;
+- row++;
+- }
+- }
+- nPat++;
+- } else
+- // Reading Samples
+- if ((nSmp <= m_nSamples) && (pins->id_INST == DSMID_INST))
+- {
+- if (dwMemPos + pins->inst_len >= dwMemLength - 8) break;
+- DWORD dwPos = dwMemPos + sizeof(DSMINST);
+- dwMemPos += 8 + pins->inst_len;
+- memcpy(m_szNames[nSmp], pins->samplename, 28);
+- MODINSTRUMENT *psmp = &Ins[nSmp];
+- memcpy(psmp->name, pins->filename, 13);
+- psmp->nGlobalVol = 64;
+- psmp->nC4Speed = pins->c2spd;
+- psmp->uFlags = (WORD)((pins->flags & 1) ? CHN_LOOP : 0);
+- psmp->nLength = pins->length;
+- psmp->nLoopStart = pins->loopstart;
+- psmp->nLoopEnd = pins->loopend;
+- psmp->nVolume = (WORD)(pins->volume << 2);
+- if (psmp->nVolume > 256) psmp->nVolume = 256;
+- UINT smptype = (pins->flags & 2) ? RS_PCM8S : RS_PCM8U;
+- ReadSample(psmp, smptype, (LPCSTR)(lpStream+dwPos), dwMemLength - dwPos);
+- nSmp++;
+- } else
+- {
+- break;
+- }
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_far.cxx audacious-plugins-2.5.4/src/modplug/load_far.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_far.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_far.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,271 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-////////////////////////////////////////
+-// Farandole (FAR) module loader //
+-////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#define FARFILEMAGIC 0xFE524146 // "FAR"
+-
+-#pragma pack(1)
+-
+-typedef struct FARHEADER1
+-{
+- DWORD id; // file magic FAR=
+- CHAR songname[40]; // songname
+- CHAR magic2[3]; // 13,10,26
+- WORD headerlen; // remaining length of header in bytes
+- BYTE version; // 0xD1
+- BYTE onoff[16];
+- BYTE edit1[9];
+- BYTE speed;
+- BYTE panning[16];
+- BYTE edit2[4];
+- WORD stlen;
+-} FARHEADER1;
+-
+-typedef struct FARHEADER2
+-{
+- BYTE orders[256];
+- BYTE numpat;
+- BYTE snglen;
+- BYTE loopto;
+- WORD patsiz[256];
+-} FARHEADER2;
+-
+-typedef struct FARSAMPLE
+-{
+- CHAR samplename[32];
+- DWORD length;
+- BYTE finetune;
+- BYTE volume;
+- DWORD reppos;
+- DWORD repend;
+- BYTE type;
+- BYTE loop;
+-} FARSAMPLE;
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadFAR(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- FARHEADER1 *pmh1 = (FARHEADER1 *)lpStream;
+- FARHEADER2 *pmh2;
+- DWORD dwMemPos = sizeof(FARHEADER1);
+- UINT headerlen;
+- BYTE samplemap[8];
+-
+- if ((!lpStream) || (dwMemLength < 1024) || (bswapLE32(pmh1->id) != FARFILEMAGIC)
+- || (pmh1->magic2[0] != 13) || (pmh1->magic2[1] != 10) || (pmh1->magic2[2] != 26)) return FALSE;
+- headerlen = bswapLE16(pmh1->headerlen);
+- pmh1->stlen = bswapLE16( pmh1->stlen ); /* inplace byteswap -- Toad */
+- if ((headerlen >= dwMemLength) || (dwMemPos + pmh1->stlen + sizeof(FARHEADER2) >= dwMemLength)) return FALSE;
+- // Globals
+- m_nType = MOD_TYPE_FAR;
+- m_nChannels = 16;
+- m_nInstruments = 0;
+- m_nSamples = 0;
+- m_nSongPreAmp = 0x20;
+- m_nDefaultSpeed = pmh1->speed;
+- m_nDefaultTempo = 80;
+- m_nDefaultGlobalVolume = 256;
+-
+- memcpy(m_szNames[0], pmh1->songname, 32);
+- // Channel Setting
+- for (UINT nchpan=0; nchpan<16; nchpan++)
+- {
+- ChnSettings[nchpan].dwFlags = 0;
+- ChnSettings[nchpan].nPan = ((pmh1->panning[nchpan] & 0x0F) << 4) + 8;
+- ChnSettings[nchpan].nVolume = 64;
+- }
+- // Reading comment
+- if (pmh1->stlen)
+- {
+- UINT szLen = pmh1->stlen;
+- if (szLen > dwMemLength - dwMemPos) szLen = dwMemLength - dwMemPos;
+- if ((m_lpszSongComments = new char[szLen + 1]) != NULL)
+- {
+- memcpy(m_lpszSongComments, lpStream+dwMemPos, szLen);
+- m_lpszSongComments[szLen] = 0;
+- }
+- dwMemPos += pmh1->stlen;
+- }
+- // Reading orders
+- pmh2 = (FARHEADER2 *)(lpStream + dwMemPos);
+- dwMemPos += sizeof(FARHEADER2);
+- if (dwMemPos >= dwMemLength) return TRUE;
+- for (UINT iorder=0; iorder<MAX_ORDERS; iorder++)
+- {
+- Order[iorder] = (iorder <= pmh2->snglen) ? pmh2->orders[iorder] : 0xFF;
+- }
+- m_nRestartPos = pmh2->loopto;
+- // Reading Patterns
+- dwMemPos += headerlen - (869 + pmh1->stlen);
+- if (dwMemPos >= dwMemLength) return TRUE;
+-
+- // byteswap pattern data -- Toad
+- UINT psfix = 0 ;
+- while( psfix++ < 256 )
+- {
+- pmh2->patsiz[psfix] = bswapLE16( pmh2->patsiz[psfix] ) ;
+- }
+- // end byteswap of pattern data
+-
+- WORD *patsiz = (WORD *)pmh2->patsiz;
+- for (UINT ipat=0; ipat<256; ipat++) if (patsiz[ipat])
+- {
+- UINT patlen = patsiz[ipat];
+- if ((ipat >= MAX_PATTERNS) || (patsiz[ipat] < 2))
+- {
+- dwMemPos += patlen;
+- continue;
+- }
+- if (dwMemPos + patlen >= dwMemLength) return TRUE;
+- UINT rows = (patlen - 2) >> 6;
+- if (!rows)
+- {
+- dwMemPos += patlen;
+- continue;
+- }
+- if (rows > 256) rows = 256;
+- if (rows < 16) rows = 16;
+- PatternSize[ipat] = rows;
+- PatternAllocSize[ipat] = rows;
+- if ((Patterns[ipat] = AllocatePattern(rows, m_nChannels)) == NULL) return TRUE;
+- MODCOMMAND *m = Patterns[ipat];
+- UINT patbrk = lpStream[dwMemPos];
+- const BYTE *p = lpStream + dwMemPos + 2;
+- UINT max = rows*16*4;
+- if (max > patlen-2) max = patlen-2;
+- for (UINT len=0; len<max; len += 4, m++)
+- {
+- BYTE note = p[len];
+- BYTE ins = p[len+1];
+- BYTE vol = p[len+2];
+- BYTE eff = p[len+3];
+- if (note)
+- {
+- m->instr = ins + 1;
+- m->note = note + 36;
+- }
+- if (vol & 0x0F)
+- {
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = (vol & 0x0F) << 2;
+- if (m->vol <= 4) m->vol = 0;
+- }
+- switch(eff & 0xF0)
+- {
+- // 1.x: Portamento Up
+- case 0x10:
+- m->command = CMD_PORTAMENTOUP;
+- m->param = eff & 0x0F;
+- break;
+- // 2.x: Portamento Down
+- case 0x20:
+- m->command = CMD_PORTAMENTODOWN;
+- m->param = eff & 0x0F;
+- break;
+- // 3.x: Tone-Portamento
+- case 0x30:
+- m->command = CMD_TONEPORTAMENTO;
+- m->param = (eff & 0x0F) << 2;
+- break;
+- // 4.x: Retrigger
+- case 0x40:
+- m->command = CMD_RETRIG;
+- m->param = 6 / (1+(eff&0x0F)) + 1;
+- break;
+- // 5.x: Set Vibrato Depth
+- case 0x50:
+- m->command = CMD_VIBRATO;
+- m->param = (eff & 0x0F);
+- break;
+- // 6.x: Set Vibrato Speed
+- case 0x60:
+- m->command = CMD_VIBRATO;
+- m->param = (eff & 0x0F) << 4;
+- break;
+- // 7.x: Vol Slide Up
+- case 0x70:
+- m->command = CMD_VOLUMESLIDE;
+- m->param = (eff & 0x0F) << 4;
+- break;
+- // 8.x: Vol Slide Down
+- case 0x80:
+- m->command = CMD_VOLUMESLIDE;
+- m->param = (eff & 0x0F);
+- break;
+- // A.x: Port to vol
+- case 0xA0:
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = ((eff & 0x0F) << 2) + 4;
+- break;
+- // B.x: Set Balance
+- case 0xB0:
+- m->command = CMD_PANNING8;
+- m->param = (eff & 0x0F) << 4;
+- break;
+- // F.x: Set Speed
+- case 0xF0:
+- m->command = CMD_SPEED;
+- m->param = eff & 0x0F;
+- break;
+- default:
+- if ((patbrk) && (patbrk+1 == (len >> 6)) && (patbrk+1 != rows-1))
+- {
+- m->command = CMD_PATTERNBREAK;
+- patbrk = 0;
+- }
+- }
+- }
+- dwMemPos += patlen;
+- }
+- // Reading samples
+- if (dwMemPos + 8 >= dwMemLength) return TRUE;
+- memcpy(samplemap, lpStream+dwMemPos, 8);
+- dwMemPos += 8;
+- MODINSTRUMENT *pins = &Ins[1];
+- for (UINT ismp=0; ismp<64; ismp++, pins++) if (samplemap[ismp >> 3] & (1 << (ismp & 7)))
+- {
+- if (dwMemPos + sizeof(FARSAMPLE) > dwMemLength) return TRUE;
+- FARSAMPLE *pfs = (FARSAMPLE *)(lpStream + dwMemPos);
+- dwMemPos += sizeof(FARSAMPLE);
+- m_nSamples = ismp + 1;
+- memcpy(m_szNames[ismp+1], pfs->samplename, 32);
+- pfs->length = bswapLE32( pfs->length ) ; /* endian fix - Toad */
+- pins->nLength = pfs->length ;
+- pins->nLoopStart = bswapLE32(pfs->reppos) ;
+- pins->nLoopEnd = bswapLE32(pfs->repend) ;
+- pins->nFineTune = 0;
+- pins->nC4Speed = 8363*2;
+- pins->nGlobalVol = 64;
+- pins->nVolume = pfs->volume << 4;
+- pins->uFlags = 0;
+- if ((pins->nLength > 3) && (dwMemPos + 4 < dwMemLength))
+- {
+- if (pfs->type & 1)
+- {
+- pins->uFlags |= CHN_16BIT;
+- pins->nLength >>= 1;
+- pins->nLoopStart >>= 1;
+- pins->nLoopEnd >>= 1;
+- }
+- if ((pfs->loop & 8) && (pins->nLoopEnd > 4)) pins->uFlags |= CHN_LOOP;
+- ReadSample(pins, (pins->uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S,
+- (LPSTR)(lpStream+dwMemPos), dwMemLength - dwMemPos);
+- }
+- dwMemPos += pfs->length;
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_it.cxx audacious-plugins-2.5.4/src/modplug/load_it.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_it.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_it.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,975 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-#include "it_defs.h"
+-
+-/* blah, -mrsb.
+-this is a schism header */
+-#include "midi.h"
+-
+-#ifdef MSC_VER
+-#pragma warning(disable:4244)
+-#endif
+-
+-BYTE autovibit2xm[8] =
+-{ 0, 3, 1, 4, 2, 0, 0, 0 };
+-
+-BYTE autovibxm2it[8] =
+-{ 0, 2, 4, 1, 3, 0, 0, 0 };
+-
+-//////////////////////////////////////////////////////////
+-// Impulse Tracker IT file support (import only)
+-
+-
+-static inline UINT ConvertVolParam(UINT value)
+-//--------------------------------------------
+-{
+- return (value > 9) ? 9 : value;
+-}
+-
+-
+-BOOL CSoundFile::ITInstrToMPT(const void *p, INSTRUMENTHEADER *penv, UINT trkvers)
+-//--------------------------------------------------------------------------------
+-{
+- if (trkvers < 0x0200)
+- {
+- const ITOLDINSTRUMENT *pis = (const ITOLDINSTRUMENT *)p;
+- memcpy(penv->name, pis->name, 26);
+- memcpy(penv->filename, pis->filename, 12);
+- penv->nFadeOut = bswapLE16(pis->fadeout) << 6;
+- penv->nGlobalVol = 128;
+- for (UINT j=0; j<120; j++)
+- {
+- UINT note = pis->keyboard[j*2];
+- UINT ins = pis->keyboard[j*2+1];
+- if (ins < MAX_SAMPLES) penv->Keyboard[j] = ins;
+- if (note < 128) penv->NoteMap[j] = note+1;
+- else if (note >= 0xFE) penv->NoteMap[j] = note;
+- }
+- if (pis->flags & 0x01) penv->dwFlags |= ENV_VOLUME;
+- if (pis->flags & 0x02) penv->dwFlags |= ENV_VOLLOOP;
+- if (pis->flags & 0x04) penv->dwFlags |= ENV_VOLSUSTAIN;
+- penv->VolEnv.nLoopStart = pis->vls;
+- penv->VolEnv.nLoopEnd = pis->vle;
+- penv->VolEnv.nSustainStart = pis->sls;
+- penv->VolEnv.nSustainEnd = pis->sle;
+- penv->VolEnv.nNodes = 25;
+- for (UINT ev=0; ev<25; ev++)
+- {
+- if ((penv->VolEnv.Ticks[ev] = pis->nodes[ev*2]) == 0xFF)
+- {
+- penv->VolEnv.nNodes = ev;
+- break;
+- }
+- penv->VolEnv.Values[ev] = pis->nodes[ev*2+1];
+- }
+- penv->nNNA = pis->nna;
+- penv->nDCT = pis->dnc;
+- penv->nPan = 0x80;
+- } else
+- {
+- const ITINSTRUMENT *pis = (const ITINSTRUMENT *)p;
+- memcpy(penv->name, pis->name, 26);
+- memcpy(penv->filename, pis->filename, 12);
+- penv->nMidiProgram = pis->mpr;
+- penv->nMidiChannel = pis->mch;
+- penv->wMidiBank = bswapLE16(pis->mbank);
+- penv->nFadeOut = bswapLE16(pis->fadeout) << 5;
+- penv->nGlobalVol = pis->gbv;
+- if (penv->nGlobalVol > 128) penv->nGlobalVol = 128;
+- for (UINT j=0; j<120; j++)
+- {
+- UINT note = pis->keyboard[j*2];
+- UINT ins = pis->keyboard[j*2+1];
+- if (ins < MAX_SAMPLES) penv->Keyboard[j] = ins;
+- if (note < 128) penv->NoteMap[j] = note+1;
+- else if (note >= 0xFE) penv->NoteMap[j] = note;
+- }
+- // Volume Envelope
+- if (pis->volenv.flags & 1) penv->dwFlags |= ENV_VOLUME;
+- if (pis->volenv.flags & 2) penv->dwFlags |= ENV_VOLLOOP;
+- if (pis->volenv.flags & 4) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (pis->volenv.flags & 8) penv->dwFlags |= ENV_VOLCARRY;
+- penv->VolEnv.nNodes = pis->volenv.num;
+- if (penv->VolEnv.nNodes > 25) penv->VolEnv.nNodes = 25;
+-
+- penv->VolEnv.nLoopStart = pis->volenv.lpb;
+- penv->VolEnv.nLoopEnd = pis->volenv.lpe;
+- penv->VolEnv.nSustainStart = pis->volenv.slb;
+- penv->VolEnv.nSustainEnd = pis->volenv.sle;
+- // Panning Envelope
+- if (pis->panenv.flags & 1) penv->dwFlags |= ENV_PANNING;
+- if (pis->panenv.flags & 2) penv->dwFlags |= ENV_PANLOOP;
+- if (pis->panenv.flags & 4) penv->dwFlags |= ENV_PANSUSTAIN;
+- if (pis->panenv.flags & 8) penv->dwFlags |= ENV_PANCARRY;
+- penv->PanEnv.nNodes = pis->panenv.num;
+- if (penv->PanEnv.nNodes > 25) penv->PanEnv.nNodes = 25;
+- penv->PanEnv.nLoopStart = pis->panenv.lpb;
+- penv->PanEnv.nLoopEnd = pis->panenv.lpe;
+- penv->PanEnv.nSustainStart = pis->panenv.slb;
+- penv->PanEnv.nSustainEnd = pis->panenv.sle;
+- // Pitch Envelope
+- if (pis->pitchenv.flags & 1) penv->dwFlags |= ENV_PITCH;
+- if (pis->pitchenv.flags & 2) penv->dwFlags |= ENV_PITCHLOOP;
+- if (pis->pitchenv.flags & 4) penv->dwFlags |= ENV_PITCHSUSTAIN;
+- if (pis->pitchenv.flags & 8) penv->dwFlags |= ENV_PITCHCARRY;
+- if (pis->pitchenv.flags & 0x80) penv->dwFlags |= ENV_FILTER;
+- penv->PitchEnv.nNodes = pis->pitchenv.num;
+- if (penv->PitchEnv.nNodes > 25) penv->PitchEnv.nNodes = 25;
+- penv->PitchEnv.nLoopStart = pis->pitchenv.lpb;
+- penv->PitchEnv.nLoopEnd = pis->pitchenv.lpe;
+- penv->PitchEnv.nSustainStart = pis->pitchenv.slb;
+- penv->PitchEnv.nSustainEnd = pis->pitchenv.sle;
+- // Envelopes Data
+- for (UINT ev=0; ev<25; ev++)
+- {
+- penv->VolEnv.Values[ev] = pis->volenv.data[ev*3];
+- penv->VolEnv.Ticks[ev] = (pis->volenv.data[ev*3+2] << 8) | (pis->volenv.data[ev*3+1]);
+- penv->PanEnv.Values[ev] = pis->panenv.data[ev*3] + 32;
+- penv->PanEnv.Ticks[ev] = (pis->panenv.data[ev*3+2] << 8) | (pis->panenv.data[ev*3+1]);
+- penv->PitchEnv.Values[ev] = pis->pitchenv.data[ev*3] + 32;
+- penv->PitchEnv.Ticks[ev] = (pis->pitchenv.data[ev*3+2] << 8) | (pis->pitchenv.data[ev*3+1]);
+- }
+- penv->nNNA = pis->nna % 4;
+- penv->nDCT = pis->dct % 4;
+- penv->nDNA = pis->dca % 3;
+- penv->nPPS = pis->pps;
+- penv->nPPC = pis->ppc;
+- penv->nIFC = pis->ifc;
+- penv->nIFR = pis->ifr;
+- penv->nVolSwing = pis->rv;
+- penv->nPanSwing = pis->rp;
+- penv->nPan = (pis->dfp & 0x7F) << 2;
+- if (penv->nPan > 256) penv->nPan = 128;
+- if (pis->dfp < 0x80) penv->dwFlags |= ENV_SETPANNING;
+- }
+- if ((penv->VolEnv.nLoopStart >= 25) || (penv->VolEnv.nLoopEnd >= 25)) penv->dwFlags &= ~ENV_VOLLOOP;
+- if ((penv->VolEnv.nSustainStart >= 25) || (penv->VolEnv.nSustainEnd >= 25)) penv->dwFlags &= ~ENV_VOLSUSTAIN;
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::ReadIT(const BYTE *lpStream, DWORD dwMemLength)
+-//--------------------------------------------------------------
+-{
+- ITFILEHEADER pifh = *(ITFILEHEADER *)lpStream;
+- DWORD dwMemPos = sizeof(ITFILEHEADER);
+- DWORD inspos[MAX_INSTRUMENTS];
+- DWORD smppos[MAX_SAMPLES];
+- DWORD patpos[MAX_PATTERNS];
+- BYTE chnmask[64];
+- MODCOMMAND lastvalue[64];
+-
+- if ((!lpStream) || (dwMemLength < 0xc2)) return FALSE;
+-
+- pifh.id = bswapLE32(pifh.id);
+- if (pifh.id == 0x49504D49) {
+- if (dwMemLength < 554) return FALSE;
+-
+- WORD tv;
+- INSTRUMENTHEADER *zenv = new INSTRUMENTHEADER;
+- if (!zenv) return FALSE;
+- memset(zenv, 0, sizeof(INSTRUMENTHEADER));
+- memcpy(&tv, lpStream+0x1C, 2); /* trkvers */
+- if (!ITInstrToMPT(lpStream, zenv, tv)) {
+- delete zenv;
+- return FALSE;
+- }
+-
+- /* okay, we need samples now */
+- unsigned int q = 554;
+- BYTE expect_samples = lpStream[0x1E];
+-
+- m_nType = MOD_TYPE_IT;
+- m_nInstruments = 1;
+- m_nSamples = expect_samples;
+- m_dwSongFlags = SONG_INSTRUMENTMODE | SONG_LINEARSLIDES /* eh? */;
+-
+- memcpy(m_szNames[0], lpStream + 0x20, 26);
+- m_szNames[0][26] = 0;
+-
+- if (q+(80*expect_samples) >= dwMemLength) {
+- delete zenv;
+- return FALSE;
+- }
+-
+- for (UINT nsmp = 0; nsmp < expect_samples; nsmp++) {
+-
+- ITSAMPLESTRUCT pis = *(ITSAMPLESTRUCT *)(lpStream+q);
+- q += 80; /* length of ITS header */
+-
+- pis.id = bswapLE32(pis.id);
+- pis.length = bswapLE32(pis.length);
+- pis.loopbegin = bswapLE32(pis.loopbegin);
+- pis.loopend = bswapLE32(pis.loopend);
+- pis.C5Speed = bswapLE32(pis.C5Speed);
+- pis.susloopbegin = bswapLE32(pis.susloopbegin);
+- pis.susloopend = bswapLE32(pis.susloopend);
+- pis.samplepointer = bswapLE32(pis.samplepointer);
+-
+- if (pis.id == 0x53504D49)
+- {
+- MODINSTRUMENT *pins = &Ins[nsmp+1];
+- memcpy(pins->name, pis.filename, 12);
+- pins->uFlags = 0;
+- pins->nLength = 0;
+- pins->nLoopStart = pis.loopbegin;
+- pins->nLoopEnd = pis.loopend;
+- pins->nSustainStart = pis.susloopbegin;
+- pins->nSustainEnd = pis.susloopend;
+- pins->nC4Speed = pis.C5Speed;
+- if (!pins->nC4Speed) pins->nC4Speed = 8363;
+- //if (pis.C5Speed < 256) pins->nC4Speed = 256;
+- pins->nVolume = pis.vol << 2;
+- if (pins->nVolume > 256) pins->nVolume = 256;
+- pins->nGlobalVol = pis.gvl;
+- if (pins->nGlobalVol > 64) pins->nGlobalVol = 64;
+- if (pis.flags & 0x10) pins->uFlags |= CHN_LOOP;
+- if (pis.flags & 0x20) pins->uFlags |= CHN_SUSTAINLOOP;
+- if (pis.flags & 0x40) pins->uFlags |= CHN_PINGPONGLOOP;
+- if (pis.flags & 0x80) pins->uFlags |= CHN_PINGPONGSUSTAIN;
+- pins->nPan = (pis.dfp & 0x7F) << 2;
+- if (pins->nPan > 256) pins->nPan = 256;
+- if (pis.dfp & 0x80) pins->uFlags |= CHN_PANNING;
+- pins->nVibType = autovibit2xm[pis.vit & 7];
+- pins->nVibRate = pis.vis;
+- pins->nVibDepth = pis.vid & 0x7F;
+- pins->nVibSweep = pis.vir;
+- if ((pis.samplepointer) && (pis.samplepointer < dwMemLength) && (pis.length))
+- {
+- pins->nLength = pis.length;
+- if (pins->nLength > MAX_SAMPLE_LENGTH) pins->nLength = MAX_SAMPLE_LENGTH;
+- UINT flags = (pis.cvt & 1) ? RS_PCM8S : RS_PCM8U;
+- if (pis.flags & 2)
+- {
+- flags += 5;
+- if (pis.flags & 4) flags |= RSF_STEREO;
+- pins->uFlags |= CHN_16BIT;
+- // IT 2.14 16-bit packed sample ?
+- if (pis.flags & 8) flags = ((pifh.cmwt >= 0x215) && (pis.cvt & 4)) ? RS_IT21516 : RS_IT21416;
+- } else
+- {
+- if (pis.flags & 4) flags |= RSF_STEREO;
+- if (pis.cvt == 0xFF) flags = RS_ADPCM4; else
+- // IT 2.14 8-bit packed sample ?
+- if (pis.flags & 8) flags = ((pifh.cmwt >= 0x215) && (pis.cvt & 4)) ? RS_IT2158 : RS_IT2148;
+- }
+- ReadSample(&Ins[nsmp+1], flags, (LPSTR)(lpStream+pis.samplepointer), dwMemLength - pis.samplepointer);
+- }
+- }
+- memcpy(m_szNames[nsmp+1], pis.name, 26);
+-
+- }
+-
+- Headers[1] = zenv;
+- return TRUE;
+- }
+-
+-
+- pifh.ordnum = bswapLE16(pifh.ordnum);
+- pifh.insnum = bswapLE16(pifh.insnum);
+- pifh.smpnum = bswapLE16(pifh.smpnum);
+- pifh.patnum = bswapLE16(pifh.patnum);
+- pifh.cwtv = bswapLE16(pifh.cwtv);
+- pifh.cmwt = bswapLE16(pifh.cmwt);
+- pifh.flags = bswapLE16(pifh.flags);
+- pifh.special = bswapLE16(pifh.special);
+- pifh.msglength = bswapLE16(pifh.msglength);
+- pifh.msgoffset = bswapLE32(pifh.msgoffset);
+- pifh.reserved2 = bswapLE32(pifh.reserved2);
+-
+-
+-
+- if ((pifh.id != 0x4D504D49) || (pifh.insnum >= MAX_INSTRUMENTS)
+- || (pifh.smpnum >= MAX_INSTRUMENTS)) return FALSE;
+- if (dwMemPos + pifh.ordnum + pifh.insnum*4
+- + pifh.smpnum*4 + pifh.patnum*4 > dwMemLength) return FALSE;
+- m_nType = MOD_TYPE_IT;
+- if (!(pifh.flags & 0x01)) m_dwSongFlags |= SONG_NOSTEREO;
+- if (pifh.flags & 0x04) m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- if (pifh.flags & 0x08) m_dwSongFlags |= SONG_LINEARSLIDES;
+- if (pifh.flags & 0x10) m_dwSongFlags |= SONG_ITOLDEFFECTS;
+- if (pifh.flags & 0x20) m_dwSongFlags |= SONG_ITCOMPATMODE;
+- if (pifh.flags & 0x40) {
+- midi_flags |= MIDI_PITCH_BEND;
+- midi_pitch_depth = pifh.pwd;
+- }
+- if (pifh.flags & 0x80) m_dwSongFlags |= SONG_EMBEDMIDICFG;
+- if (pifh.flags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE;
+- memcpy(m_szNames[0], pifh.songname, 26);
+- m_szNames[0][26] = 0;
+- if (pifh.cwtv >= 0x0213) {
+- m_rowHighlightMinor = pifh.hilight_minor;
+- m_rowHighlightMajor = pifh.hilight_major;
+- } else {
+- m_rowHighlightMinor = 4;
+- m_rowHighlightMajor = 16;
+- }
+- // Global Volume
+- m_nDefaultGlobalVolume = pifh.globalvol << 1;
+- if (m_nDefaultGlobalVolume > 256) m_nDefaultGlobalVolume = 256;
+- if (pifh.speed) m_nDefaultSpeed = pifh.speed;
+- if (pifh.tempo) m_nDefaultTempo = pifh.tempo;
+- m_nSongPreAmp = pifh.mv;
+- if (m_nSongPreAmp > 128)
+- m_nSongPreAmp = 128;
+- m_nStereoSeparation = pifh.sep;
+- // Reading Channels Pan Positions
+- for (int ipan=0; ipan<64; ipan++) if (pifh.chnpan[ipan] != 0xFF)
+- {
+- ChnSettings[ipan].nVolume = pifh.chnvol[ipan];
+- ChnSettings[ipan].nPan = 128;
+- if (pifh.chnpan[ipan] & 0x80) ChnSettings[ipan].dwFlags |= CHN_MUTE;
+- UINT n = pifh.chnpan[ipan] & 0x7F;
+- if (n <= 64) ChnSettings[ipan].nPan = n << 2;
+- if (n == 100) ChnSettings[ipan].dwFlags |= CHN_SURROUND;
+- }
+- if (m_nChannels < 4) m_nChannels = 4;
+- // Reading Song Message
+- if ((pifh.special & 0x01) && (pifh.msglength) && (pifh.msgoffset + pifh.msglength < dwMemLength))
+- {
+- m_lpszSongComments = new char[pifh.msglength+1];
+- if (m_lpszSongComments)
+- {
+- memcpy(m_lpszSongComments, lpStream+pifh.msgoffset, pifh.msglength);
+- m_lpszSongComments[pifh.msglength] = 0;
+- }
+- }
+- // Reading orders
+- UINT nordsize = pifh.ordnum;
+- if (nordsize > MAX_ORDERS) nordsize = MAX_ORDERS;
+- memcpy(Order, lpStream+dwMemPos, nordsize);
+-
+- dwMemPos += pifh.ordnum;
+- // Reading Instrument Offsets
+- memset(inspos, 0, sizeof(inspos));
+- UINT inspossize = pifh.insnum;
+- if (inspossize > MAX_INSTRUMENTS) inspossize = MAX_INSTRUMENTS;
+- inspossize <<= 2;
+- memcpy(inspos, lpStream+dwMemPos, inspossize);
+- for (UINT j=0; j < (inspossize>>2); j++)
+- {
+- inspos[j] = bswapLE32(inspos[j]);
+- }
+- dwMemPos += pifh.insnum * 4;
+- // Reading Samples Offsets
+- memset(smppos, 0, sizeof(smppos));
+- UINT smppossize = pifh.smpnum;
+- if (smppossize > MAX_SAMPLES) smppossize = MAX_SAMPLES;
+- smppossize <<= 2;
+- memcpy(smppos, lpStream+dwMemPos, smppossize);
+- for (UINT j=0; j < (smppossize>>2); j++)
+- {
+- smppos[j] = bswapLE32(smppos[j]);
+- }
+- dwMemPos += pifh.smpnum * 4;
+- // Reading Patterns Offsets
+- memset(patpos, 0, sizeof(patpos));
+- UINT patpossize = pifh.patnum;
+- if (patpossize > MAX_PATTERNS) patpossize = MAX_PATTERNS;
+- patpossize <<= 2;
+- memcpy(patpos, lpStream+dwMemPos, patpossize);
+- for (UINT j=0; j < (patpossize>>2); j++)
+- {
+- patpos[j] = bswapLE32(patpos[j]);
+- }
+- dwMemPos += pifh.patnum * 4;
+-
+- for (UINT i = 0; i < pifh.ordnum; i++) {
+- if (Order[i] >= pifh.patnum && Order[i] < MAX_PATTERNS) {
+- pifh.patnum = Order[i];
+- for (UINT j = patpossize; j < (unsigned)(pifh.patnum>>2); j++)
+- patpos[j] = 0;
+- patpossize = pifh.patnum;
+- }
+- }
+-
+-
+- // Reading IT Extra Info
+- if (dwMemPos + 2 < dwMemLength)
+- {
+- UINT nflt = bswapLE16(*((WORD *)(lpStream + dwMemPos)));
+- dwMemPos += 2;
+- if (dwMemPos + nflt * 8 < dwMemLength) dwMemPos += nflt * 8;
+- }
+- // Reading Midi Output & Macros
+- if (m_dwSongFlags & SONG_EMBEDMIDICFG)
+- {
+- if (dwMemPos + sizeof(MODMIDICFG) < dwMemLength)
+- {
+- memcpy(&m_MidiCfg, lpStream+dwMemPos, sizeof(MODMIDICFG));
+- dwMemPos += sizeof(MODMIDICFG);
+- } else {
+- ResetMidiCfg();
+- }
+- } else {
+- ResetMidiCfg();
+- }
+-#if 0
+- // Read pattern names: "PNAM"
+- if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e50))
+- {
+- UINT len = bswapLE32(*((DWORD *)(lpStream+dwMemPos+4)));
+- dwMemPos += 8;
+- if ((dwMemPos + len <= dwMemLength) && (len <= MAX_PATTERNS*MAX_PATTERNNAME) && (len >= MAX_PATTERNNAME))
+- {
+- m_lpszPatternNames = new char[len];
+- if (m_lpszPatternNames)
+- {
+- m_nPatternNames = len / MAX_PATTERNNAME;
+- memcpy(m_lpszPatternNames, lpStream+dwMemPos, len);
+- }
+- dwMemPos += len;
+- }
+- }
+-#endif
+- // 4-channels minimum
+- m_nChannels = 4;
+-#if 0
+- // Read channel names: "CNAM"
+- if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e43))
+- {
+- UINT len = bswapLE32(*((DWORD *)(lpStream+dwMemPos+4)));
+- dwMemPos += 8;
+- if ((dwMemPos + len <= dwMemLength) && (len <= 64*MAX_CHANNELNAME))
+- {
+- UINT n = len / MAX_CHANNELNAME;
+- if (n > m_nChannels) m_nChannels = n;
+- for (UINT i=0; i<n; i++)
+- {
+- memcpy(ChnSettings[i].szName, (lpStream+dwMemPos+i*MAX_CHANNELNAME), MAX_CHANNELNAME);
+- ChnSettings[i].szName[MAX_CHANNELNAME-1] = 0;
+- }
+- dwMemPos += len;
+- }
+- }
+- // Read mix plugins information
+- if (dwMemPos + 8 < dwMemLength)
+- {
+- dwMemPos += LoadMixPlugins(lpStream+dwMemPos, dwMemLength-dwMemPos);
+- }
+-#endif
+- // Checking for unused channels
+- UINT npatterns = pifh.patnum;
+- if (npatterns > MAX_PATTERNS) npatterns = MAX_PATTERNS;
+- for (UINT patchk=0; patchk<npatterns; patchk++)
+- {
+- memset(chnmask, 0, sizeof(chnmask));
+- if ((!patpos[patchk]) || ((DWORD)patpos[patchk] + 4 >= dwMemLength)) continue;
+- UINT len = bswapLE16(*((WORD *)(lpStream+patpos[patchk])));
+- UINT rows = bswapLE16(*((WORD *)(lpStream+patpos[patchk]+2)));
+- if ((rows < 4) || (rows > 256)) continue;
+- if (patpos[patchk]+8+len > dwMemLength) continue;
+- UINT i = 0;
+- const BYTE *p = lpStream+patpos[patchk]+8;
+- UINT nrow = 0;
+- while (nrow<rows)
+- {
+- if (i >= len) break;
+- BYTE b = p[i++];
+- if (!b)
+- {
+- nrow++;
+- continue;
+- }
+- UINT ch = b & 0x7F;
+- if (ch) ch = (ch - 1) & 0x3F;
+- if (b & 0x80)
+- {
+- if (i >= len) break;
+- chnmask[ch] = p[i++];
+- }
+- // Channel used
+- if (chnmask[ch] & 0x0F)
+- {
+- if ((ch >= m_nChannels) && (ch < 64)) m_nChannels = ch+1;
+- }
+- // Note
+- if (chnmask[ch] & 1) i++;
+- // Instrument
+- if (chnmask[ch] & 2) i++;
+- // Volume
+- if (chnmask[ch] & 4) i++;
+- // Effect
+- if (chnmask[ch] & 8) i += 2;
+- if (i >= len) break;
+- }
+- }
+- // Reading Instruments
+- m_nInstruments = pifh.insnum;
+- if (m_nInstruments >= MAX_INSTRUMENTS) m_nInstruments = MAX_INSTRUMENTS-1;
+- for (UINT nins=0; nins<m_nInstruments; nins++)
+- {
+- if ((inspos[nins] > 0) && (inspos[nins] < dwMemLength - sizeof(ITOLDINSTRUMENT)))
+- {
+- INSTRUMENTHEADER *penv = new INSTRUMENTHEADER;
+- if (!penv) continue;
+- Headers[nins+1] = penv;
+- memset(penv, 0, sizeof(INSTRUMENTHEADER));
+- ITInstrToMPT(lpStream + inspos[nins], penv, pifh.cmwt);
+- }
+- }
+- // Reading Samples
+- m_nSamples = pifh.smpnum;
+- if (m_nSamples >= MAX_SAMPLES) m_nSamples = MAX_SAMPLES-1;
+- for (UINT nsmp=0; nsmp<pifh.smpnum; nsmp++) if ((smppos[nsmp]) && (smppos[nsmp] + sizeof(ITSAMPLESTRUCT) <= dwMemLength))
+- {
+- ITSAMPLESTRUCT pis = *(ITSAMPLESTRUCT *)(lpStream+smppos[nsmp]);
+- pis.id = bswapLE32(pis.id);
+- pis.length = bswapLE32(pis.length);
+- pis.loopbegin = bswapLE32(pis.loopbegin);
+- pis.loopend = bswapLE32(pis.loopend);
+- pis.C5Speed = bswapLE32(pis.C5Speed);
+- pis.susloopbegin = bswapLE32(pis.susloopbegin);
+- pis.susloopend = bswapLE32(pis.susloopend);
+- pis.samplepointer = bswapLE32(pis.samplepointer);
+-
+- if (pis.id == 0x53504D49)
+- {
+- MODINSTRUMENT *pins = &Ins[nsmp+1];
+- memcpy(pins->name, pis.filename, 12);
+- pins->uFlags = 0;
+- pins->nLength = 0;
+- pins->nLoopStart = pis.loopbegin;
+- pins->nLoopEnd = pis.loopend;
+- pins->nSustainStart = pis.susloopbegin;
+- pins->nSustainEnd = pis.susloopend;
+- pins->nC4Speed = pis.C5Speed;
+- if (!pins->nC4Speed) pins->nC4Speed = 8363;
+- //if (pis.C5Speed < 256) pins->nC4Speed = 256;
+- pins->nVolume = pis.vol << 2;
+- if (pins->nVolume > 256) pins->nVolume = 256;
+- pins->nGlobalVol = pis.gvl;
+- if (pins->nGlobalVol > 64) pins->nGlobalVol = 64;
+- if (pis.flags & 0x10) pins->uFlags |= CHN_LOOP;
+- if (pis.flags & 0x20) pins->uFlags |= CHN_SUSTAINLOOP;
+- if (pis.flags & 0x40) pins->uFlags |= CHN_PINGPONGLOOP;
+- if (pis.flags & 0x80) pins->uFlags |= CHN_PINGPONGSUSTAIN;
+- pins->nPan = (pis.dfp & 0x7F) << 2;
+- if (pins->nPan > 256) pins->nPan = 256;
+- if (pis.dfp & 0x80) pins->uFlags |= CHN_PANNING;
+- pins->nVibType = autovibit2xm[pis.vit & 7];
+- pins->nVibRate = pis.vis;
+- pins->nVibDepth = pis.vid & 0x7F;
+- pins->nVibSweep = pis.vir;
+- if ((pis.samplepointer) && (pis.samplepointer < dwMemLength) && (pis.length))
+- {
+- pins->nLength = pis.length;
+- if (pins->nLength > MAX_SAMPLE_LENGTH) pins->nLength = MAX_SAMPLE_LENGTH;
+- UINT flags = (pis.cvt & 1) ? RS_PCM8S : RS_PCM8U;
+- if (pis.flags & 2)
+- {
+- flags += 5;
+- if (pis.flags & 4) flags |= RSF_STEREO;
+- pins->uFlags |= CHN_16BIT;
+- // IT 2.14 16-bit packed sample ?
+- if (pis.flags & 8) flags = ((pifh.cmwt >= 0x215) && (pis.cvt & 4)) ? RS_IT21516 : RS_IT21416;
+- } else
+- {
+- if (pis.flags & 4) flags |= RSF_STEREO;
+- if (pis.cvt == 0xFF) flags = RS_ADPCM4; else
+- // IT 2.14 8-bit packed sample ?
+- if (pis.flags & 8) flags = ((pifh.cmwt >= 0x215) && (pis.cvt & 4)) ? RS_IT2158 : RS_IT2148;
+- }
+- ReadSample(&Ins[nsmp+1], flags, (LPSTR)(lpStream+pis.samplepointer), dwMemLength - pis.samplepointer);
+- }
+- }
+- memcpy(m_szNames[nsmp+1], pis.name, 26);
+- }
+- // Reading Patterns
+- for (UINT npat=0; npat<npatterns; npat++)
+- {
+- if ((!patpos[npat]) || ((DWORD)patpos[npat] + 4 >= dwMemLength))
+- {
+- PatternSize[npat] = 64;
+- PatternAllocSize[npat] = 64;
+- Patterns[npat] = AllocatePattern(64, m_nChannels);
+- continue;
+- }
+-
+- UINT len = bswapLE16(*((WORD *)(lpStream+patpos[npat])));
+- UINT rows = bswapLE16(*((WORD *)(lpStream+patpos[npat]+2)));
+- if ((rows < 4) || (rows > 256)) continue;
+- if (patpos[npat]+8+len > dwMemLength) continue;
+- PatternSize[npat] = rows;
+- PatternAllocSize[npat] = rows;
+- if ((Patterns[npat] = AllocatePattern(rows, m_nChannels)) == NULL) continue;
+- memset(lastvalue, 0, sizeof(lastvalue));
+- memset(chnmask, 0, sizeof(chnmask));
+- MODCOMMAND *m = Patterns[npat];
+- UINT i = 0;
+- const BYTE *p = lpStream+patpos[npat]+8;
+- UINT nrow = 0;
+- while (nrow<rows)
+- {
+- if (i >= len) break;
+- BYTE b = p[i++];
+- if (!b)
+- {
+- nrow++;
+- m+=m_nChannels;
+- continue;
+- }
+- UINT ch = b & 0x7F;
+- if (ch) ch = (ch - 1) & 0x3F;
+- if (b & 0x80)
+- {
+- if (i >= len) break;
+- chnmask[ch] = p[i++];
+- }
+- if ((chnmask[ch] & 0x10) && (ch < m_nChannels))
+- {
+- m[ch].note = lastvalue[ch].note;
+- }
+- if ((chnmask[ch] & 0x20) && (ch < m_nChannels))
+- {
+- m[ch].instr = lastvalue[ch].instr;
+- }
+- if ((chnmask[ch] & 0x40) && (ch < m_nChannels))
+- {
+- m[ch].volcmd = lastvalue[ch].volcmd;
+- m[ch].vol = lastvalue[ch].vol;
+- }
+- if ((chnmask[ch] & 0x80) && (ch < m_nChannels))
+- {
+- m[ch].command = lastvalue[ch].command;
+- m[ch].param = lastvalue[ch].param;
+- }
+- if (chnmask[ch] & 1) // Note
+- {
+- if (i >= len) break;
+- UINT note = p[i++];
+- if (ch < m_nChannels)
+- {
+- if (note < 0x80) note++;
+- m[ch].note = note;
+- lastvalue[ch].note = note;
+- }
+- }
+- if (chnmask[ch] & 2)
+- {
+- if (i >= len) break;
+- UINT instr = p[i++];
+- if (ch < m_nChannels)
+- {
+- m[ch].instr = instr;
+- lastvalue[ch].instr = instr;
+- }
+- }
+- if (chnmask[ch] & 4)
+- {
+- if (i >= len) break;
+- UINT vol = p[i++];
+- if (ch < m_nChannels)
+- {
+- // 0-64: Set Volume
+- if (vol <= 64) { m[ch].volcmd = VOLCMD_VOLUME; m[ch].vol = vol; } else
+- // 128-192: Set Panning
+- if ((vol >= 128) && (vol <= 192)) { m[ch].volcmd = VOLCMD_PANNING; m[ch].vol = vol - 128; } else
+- // 65-74: Fine Volume Up
+- if (vol < 75) { m[ch].volcmd = VOLCMD_FINEVOLUP; m[ch].vol = vol - 65; } else
+- // 75-84: Fine Volume Down
+- if (vol < 85) { m[ch].volcmd = VOLCMD_FINEVOLDOWN; m[ch].vol = vol - 75; } else
+- // 85-94: Volume Slide Up
+- if (vol < 95) { m[ch].volcmd = VOLCMD_VOLSLIDEUP; m[ch].vol = vol - 85; } else
+- // 95-104: Volume Slide Down
+- if (vol < 105) { m[ch].volcmd = VOLCMD_VOLSLIDEDOWN; m[ch].vol = vol - 95; } else
+- // 105-114: Pitch Slide Up
+- if (vol < 115) { m[ch].volcmd = VOLCMD_PORTADOWN; m[ch].vol = vol - 105; } else
+- // 115-124: Pitch Slide Down
+- if (vol < 125) { m[ch].volcmd = VOLCMD_PORTAUP; m[ch].vol = vol - 115; } else
+- // 193-202: Portamento To
+- if ((vol >= 193) && (vol <= 202)) { m[ch].volcmd = VOLCMD_TONEPORTAMENTO; m[ch].vol = vol - 193; } else
+- // 203-212: Vibrato
+- if ((vol >= 203) && (vol <= 212)) { m[ch].volcmd = VOLCMD_VIBRATO; m[ch].vol = vol - 203; }
+- lastvalue[ch].volcmd = m[ch].volcmd;
+- lastvalue[ch].vol = m[ch].vol;
+- }
+- }
+- // Reading command/param
+- if (chnmask[ch] & 8)
+- {
+- if (i > len - 2) break;
+- UINT cmd = p[i++];
+- UINT param = p[i++];
+- if (ch < m_nChannels)
+- {
+- if (cmd)
+- {
+- m[ch].command = cmd;
+- m[ch].param = param;
+- S3MConvert(&m[ch], TRUE);
+- lastvalue[ch].command = m[ch].command;
+- lastvalue[ch].param = m[ch].param;
+- }
+- }
+- }
+- }
+- }
+- for (UINT ncu=0; ncu<MAX_BASECHANNELS; ncu++)
+- {
+- if (ncu>=m_nChannels)
+- {
+- ChnSettings[ncu].nVolume = 64;
+- ChnSettings[ncu].dwFlags &= ~CHN_MUTE;
+- }
+- }
+- m_nMinPeriod = 8;
+- m_nMaxPeriod = 0xF000;
+- return TRUE;
+-}
+-
+-
+-//////////////////////////////////////////////////////////////////////////////
+-// IT 2.14 compression
+-
+-DWORD ITReadBits(DWORD &bitbuf, UINT &bitnum, LPBYTE &ibuf, CHAR n)
+-//-----------------------------------------------------------------
+-{
+- DWORD retval = 0;
+- UINT i = n;
+-
+- if (n > 0)
+- {
+- do
+- {
+- if (!bitnum)
+- {
+- bitbuf = *ibuf++;
+- bitnum = 8;
+- }
+- retval >>= 1;
+- retval |= bitbuf << 31;
+- bitbuf >>= 1;
+- bitnum--;
+- i--;
+- } while (i);
+- i = n;
+- }
+- return (retval >> (32-i));
+-}
+-
+-#define IT215_SUPPORT
+-void ITUnpack8Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215)
+-//-------------------------------------------------------------------------------------------
+-{
+- signed char *pDst = pSample;
+- LPBYTE pSrc = lpMemFile;
+- DWORD wCount = 0;
+- DWORD bitbuf = 0;
+- UINT bitnum = 0;
+- BYTE bLeft = 0, bTemp = 0, bTemp2 = 0;
+-
+- while (dwLen)
+- {
+- if (!wCount)
+- {
+- wCount = 0x8000;
+- pSrc += 2;
+- bLeft = 9;
+- bTemp = bTemp2 = 0;
+- bitbuf = bitnum = 0;
+- }
+- DWORD d = wCount;
+- if (d > dwLen) d = dwLen;
+- // Unpacking
+- DWORD dwPos = 0;
+- do
+- {
+- WORD wBits = (WORD)ITReadBits(bitbuf, bitnum, pSrc, bLeft);
+- if (bLeft < 7)
+- {
+- DWORD i = 1 << (bLeft-1);
+- DWORD j = wBits & 0xFFFF;
+- if (i != j) goto UnpackByte;
+- wBits = (WORD)(ITReadBits(bitbuf, bitnum, pSrc, 3) + 1) & 0xFF;
+- bLeft = ((BYTE)wBits < bLeft) ? (BYTE)wBits : (BYTE)((wBits+1) & 0xFF);
+- goto Next;
+- }
+- if (bLeft < 9)
+- {
+- WORD i = (0xFF >> (9 - bLeft)) + 4;
+- WORD j = i - 8;
+- if ((wBits <= j) || (wBits > i)) goto UnpackByte;
+- wBits -= j;
+- bLeft = ((BYTE)(wBits & 0xFF) < bLeft) ? (BYTE)(wBits & 0xFF) : (BYTE)((wBits+1) & 0xFF);
+- goto Next;
+- }
+- if (bLeft >= 10) goto SkipByte;
+- if (wBits >= 256)
+- {
+- bLeft = (BYTE)(wBits + 1) & 0xFF;
+- goto Next;
+- }
+- UnpackByte:
+- if (bLeft < 8)
+- {
+- BYTE shift = 8 - bLeft;
+- signed char c = (signed char)(wBits << shift);
+- c >>= shift;
+- wBits = (WORD)c;
+- }
+- wBits += bTemp;
+- bTemp = (BYTE)wBits;
+- bTemp2 += bTemp;
+-#ifdef IT215_SUPPORT
+- pDst[dwPos] = (b215) ? bTemp2 : bTemp;
+-#else
+- pDst[dwPos] = bTemp;
+-#endif
+- SkipByte:
+- dwPos++;
+- Next:
+- if (pSrc >= lpMemFile+dwMemLength+1) return;
+- } while (dwPos < d);
+- // Move On
+- wCount -= d;
+- dwLen -= d;
+- pDst += d;
+- }
+-}
+-
+-
+-void ITUnpack16Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215)
+-//--------------------------------------------------------------------------------------------
+-{
+- signed short *pDst = (signed short *)pSample;
+- LPBYTE pSrc = lpMemFile;
+- DWORD wCount = 0;
+- DWORD bitbuf = 0;
+- UINT bitnum = 0;
+- BYTE bLeft = 0;
+- signed short wTemp = 0, wTemp2 = 0;
+-
+- while (dwLen)
+- {
+- if (!wCount)
+- {
+- wCount = 0x4000;
+- pSrc += 2;
+- bLeft = 17;
+- wTemp = wTemp2 = 0;
+- bitbuf = bitnum = 0;
+- }
+- DWORD d = wCount;
+- if (d > dwLen) d = dwLen;
+- // Unpacking
+- DWORD dwPos = 0;
+- do
+- {
+- DWORD dwBits = ITReadBits(bitbuf, bitnum, pSrc, bLeft);
+- if (bLeft < 7)
+- {
+- DWORD i = 1 << (bLeft-1);
+- DWORD j = dwBits;
+- if (i != j) goto UnpackByte;
+- dwBits = ITReadBits(bitbuf, bitnum, pSrc, 4) + 1;
+- bLeft = ((BYTE)(dwBits & 0xFF) < bLeft) ? (BYTE)(dwBits & 0xFF) : (BYTE)((dwBits+1) & 0xFF);
+- goto Next;
+- }
+- if (bLeft < 17)
+- {
+- DWORD i = (0xFFFF >> (17 - bLeft)) + 8;
+- DWORD j = (i - 16) & 0xFFFF;
+- if ((dwBits <= j) || (dwBits > (i & 0xFFFF))) goto UnpackByte;
+- dwBits -= j;
+- bLeft = ((BYTE)(dwBits & 0xFF) < bLeft) ? (BYTE)(dwBits & 0xFF) : (BYTE)((dwBits+1) & 0xFF);
+- goto Next;
+- }
+- if (bLeft >= 18) goto SkipByte;
+- if (dwBits >= 0x10000)
+- {
+- bLeft = (BYTE)(dwBits + 1) & 0xFF;
+- goto Next;
+- }
+- UnpackByte:
+- if (bLeft < 16)
+- {
+- BYTE shift = 16 - bLeft;
+- signed short c = (signed short)(dwBits << shift);
+- c >>= shift;
+- dwBits = (DWORD)c;
+- }
+- dwBits += wTemp;
+- wTemp = (signed short)dwBits;
+- wTemp2 += wTemp;
+-#ifdef IT215_SUPPORT
+- pDst[dwPos] = (b215) ? wTemp2 : wTemp;
+-#else
+- pDst[dwPos] = wTemp;
+-#endif
+- SkipByte:
+- dwPos++;
+- Next:
+- if (pSrc >= lpMemFile+dwMemLength+1) return;
+- } while (dwPos < d);
+- // Move On
+- wCount -= d;
+- dwLen -= d;
+- pDst += d;
+- if (pSrc >= lpMemFile+dwMemLength) break;
+- }
+-}
+-
+-UINT CSoundFile::LoadMixPlugins(const void *pData, UINT nLen)
+-//-----------------------------------------------------------
+-{
+- const BYTE *p = (const BYTE *)pData;
+- UINT nPos = 0;
+-
+- while (nPos+8 < nLen)
+- {
+- DWORD nPluginSize;
+- UINT nPlugin;
+-
+- nPluginSize = bswapLE32(*(DWORD *)(p+nPos+4));
+- if (nPluginSize > nLen-nPos-8) break;;
+- if ((bswapLE32(*(DWORD *)(p+nPos))) == 0x58464843)
+- {
+- for (UINT ch=0; ch<64; ch++) if (ch*4 < nPluginSize)
+- {
+- ChnSettings[ch].nMixPlugin = bswapLE32(*(DWORD *)(p+nPos+8+ch*4));
+- }
+- } else
+- {
+- if ((p[nPos] != 'F') || (p[nPos+1] != 'X')
+- || (p[nPos+2] < '0') || (p[nPos+3] < '0'))
+- {
+- break;
+- }
+- nPlugin = (p[nPos+2]-'0')*10 + (p[nPos+3]-'0');
+- if ((nPlugin < MAX_MIXPLUGINS) && (nPluginSize >= sizeof(SNDMIXPLUGININFO)+4))
+- {
+- DWORD dwExtra = bswapLE32(*(DWORD *)(p+nPos+8+sizeof(SNDMIXPLUGININFO)));
+- m_MixPlugins[nPlugin].Info = *(const SNDMIXPLUGININFO *)(p+nPos+8);
+- m_MixPlugins[nPlugin].Info.dwPluginId1 = bswapLE32(m_MixPlugins[nPlugin].Info.dwPluginId1);
+- m_MixPlugins[nPlugin].Info.dwPluginId2 = bswapLE32(m_MixPlugins[nPlugin].Info.dwPluginId2);
+- m_MixPlugins[nPlugin].Info.dwInputRouting = bswapLE32(m_MixPlugins[nPlugin].Info.dwInputRouting);
+- m_MixPlugins[nPlugin].Info.dwOutputRouting = bswapLE32(m_MixPlugins[nPlugin].Info.dwOutputRouting);
+- for (UINT j=0; j<4; j++)
+- {
+- m_MixPlugins[nPlugin].Info.dwReserved[j] = bswapLE32(m_MixPlugins[nPlugin].Info.dwReserved[j]);
+- }
+- if ((dwExtra) && (dwExtra <= nPluginSize-sizeof(SNDMIXPLUGININFO)-4))
+- {
+- m_MixPlugins[nPlugin].nPluginDataSize = 0;
+- m_MixPlugins[nPlugin].pPluginData = new signed char [dwExtra];
+- if (m_MixPlugins[nPlugin].pPluginData)
+- {
+- m_MixPlugins[nPlugin].nPluginDataSize = dwExtra;
+- memcpy(m_MixPlugins[nPlugin].pPluginData, p+nPos+8+sizeof(SNDMIXPLUGININFO)+4, dwExtra);
+- }
+- }
+- }
+- }
+- nPos += nPluginSize + 8;
+- }
+- return nPos;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_mdl.cxx audacious-plugins-2.5.4/src/modplug/load_mdl.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_mdl.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_mdl.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,538 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-//////////////////////////////////////////////
+-// DigiTracker (MDL) module loader //
+-//////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-typedef struct MDLSONGHEADER
+-{
+- DWORD id; // "DMDL" = 0x4C444D44
+- BYTE version;
+-} MDLSONGHEADER;
+-
+-
+-typedef struct MDLINFOBLOCK
+-{
+- CHAR songname[32];
+- CHAR composer[20];
+- WORD norders;
+- WORD repeatpos;
+- BYTE globalvol;
+- BYTE speed;
+- BYTE tempo;
+- BYTE channelinfo[32];
+- BYTE seq[256];
+-} MDLINFOBLOCK;
+-
+-
+-typedef struct MDLPATTERNDATA
+-{
+- BYTE channels;
+- BYTE lastrow; // nrows = lastrow+1
+- CHAR name[16];
+- WORD data[1];
+-} MDLPATTERNDATA;
+-
+-
+-void ConvertMDLCommand(MODCOMMAND *m, UINT eff, UINT data)
+-//--------------------------------------------------------
+-{
+- UINT command = 0, param = data;
+- switch(eff)
+- {
+- case 0x01: command = CMD_PORTAMENTOUP; break;
+- case 0x02: command = CMD_PORTAMENTODOWN; break;
+- case 0x03: command = CMD_TONEPORTAMENTO; break;
+- case 0x04: command = CMD_VIBRATO; break;
+- case 0x05: command = CMD_ARPEGGIO; break;
+- case 0x07: command = (param < 0x20) ? CMD_SPEED : CMD_TEMPO; break;
+- case 0x08: command = CMD_PANNING8; param <<= 1; break;
+- case 0x0B: command = CMD_POSITIONJUMP; break;
+- case 0x0C: command = CMD_GLOBALVOLUME; break;
+- case 0x0D: command = CMD_PATTERNBREAK; param = (data & 0x0F) + (data>>4)*10; break;
+- case 0x0E:
+- command = CMD_S3MCMDEX;
+- switch(data & 0xF0)
+- {
+- case 0x00: command = 0; break; // What is E0x in MDL (there is a bunch) ?
+- case 0x10: if (param & 0x0F) { param |= 0xF0; command = CMD_PANNINGSLIDE; } else command = 0; break;
+- case 0x20: if (param & 0x0F) { param = (param << 4) | 0x0F; command = CMD_PANNINGSLIDE; } else command = 0; break;
+- case 0x30: param = (data & 0x0F) | 0x10; break; // glissando
+- case 0x40: param = (data & 0x0F) | 0x30; break; // vibrato waveform
+- case 0x60: param = (data & 0x0F) | 0xB0; break;
+- case 0x70: param = (data & 0x0F) | 0x40; break; // tremolo waveform
+- case 0x90: command = CMD_RETRIG; param &= 0x0F; break;
+- case 0xA0: param = (data & 0x0F) << 4; command = CMD_GLOBALVOLSLIDE; break;
+- case 0xB0: param = data & 0x0F; command = CMD_GLOBALVOLSLIDE; break;
+- case 0xF0: param = ((data >> 8) & 0x0F) | 0xA0; break;
+- }
+- break;
+- case 0x0F: command = CMD_SPEED; break;
+-
+- case 0x10:
+- if ((param & 0xF0) != 0xE0) {
+- command = CMD_VOLUMESLIDE;
+- if ((param & 0xF0) == 0xF0) {
+- param = ((param << 4) | 0x0F);
+- } else {
+- param >>= 2;
+- if (param > 0xF)
+- param = 0xF;
+- param <<= 4;
+- }
+- }
+- break;
+- case 0x20:
+- if ((param & 0xF0) != 0xE0) {
+- command = CMD_VOLUMESLIDE;
+- if ((param & 0xF0) != 0xF0) {
+- param >>= 2;
+- if (param > 0xF)
+- param = 0xF;
+- }
+- }
+- break;
+-
+- case 0x30: command = CMD_RETRIG; break;
+- case 0x40: command = CMD_TREMOLO; break;
+- case 0x50: command = CMD_TREMOR; break;
+- case 0xEF: if (param > 0xFF) param = 0xFF; command = CMD_OFFSET; break;
+- }
+- if (command)
+- {
+- m->command = command;
+- m->param = param;
+- }
+-}
+-
+-
+-void UnpackMDLTrack(MODCOMMAND *pat, UINT nChannels, UINT nRows, UINT nTrack, const BYTE *lpTracks)
+-//-------------------------------------------------------------------------------------------------
+-{
+- MODCOMMAND cmd, *m = pat;
+- UINT len = *((WORD *)lpTracks);
+- UINT pos = 0, row = 0, i;
+- lpTracks += 2;
+- for (UINT ntrk=1; ntrk<nTrack; ntrk++)
+- {
+- lpTracks += len;
+- len = *((WORD *)lpTracks);
+- lpTracks += 2;
+- }
+- cmd.note = cmd.instr = 0;
+- cmd.volcmd = cmd.vol = 0;
+- cmd.command = cmd.param = 0;
+- while ((row < nRows) && (pos < len))
+- {
+- UINT xx;
+- BYTE b = lpTracks[pos++];
+- xx = b >> 2;
+- switch(b & 0x03)
+- {
+- case 0x01:
+- for (i=0; i<=xx; i++)
+- {
+- if (row) *m = *(m-nChannels);
+- m += nChannels;
+- row++;
+- if (row >= nRows) break;
+- }
+- break;
+-
+- case 0x02:
+- if (xx < row) *m = pat[nChannels*xx];
+- m += nChannels;
+- row++;
+- break;
+-
+- case 0x03:
+- {
+- cmd.note = (xx & 0x01) ? lpTracks[pos++] : 0;
+- cmd.instr = (xx & 0x02) ? lpTracks[pos++] : 0;
+- cmd.volcmd = cmd.vol = 0;
+- cmd.command = cmd.param = 0;
+- if ((cmd.note < 120-12) && (cmd.note)) cmd.note += 12;
+- UINT volume = (xx & 0x04) ? lpTracks[pos++] : 0;
+- UINT commands = (xx & 0x08) ? lpTracks[pos++] : 0;
+- UINT command1 = commands & 0x0F;
+- UINT command2 = commands & 0xF0;
+- UINT param1 = (xx & 0x10) ? lpTracks[pos++] : 0;
+- UINT param2 = (xx & 0x20) ? lpTracks[pos++] : 0;
+- if ((command1 == 0x0E) && ((param1 & 0xF0) == 0xF0) && (!command2))
+- {
+- param1 = ((param1 & 0x0F) << 8) | param2;
+- command1 = 0xEF;
+- command2 = param2 = 0;
+- }
+- if (volume)
+- {
+- cmd.volcmd = VOLCMD_VOLUME;
+- cmd.vol = (volume+1) >> 2;
+- }
+- ConvertMDLCommand(&cmd, command1, param1);
+- if ((cmd.command != CMD_SPEED)
+- && (cmd.command != CMD_TEMPO)
+- && (cmd.command != CMD_PATTERNBREAK))
+- ConvertMDLCommand(&cmd, command2, param2);
+- *m = cmd;
+- m += nChannels;
+- row++;
+- }
+- break;
+-
+- // Empty Slots
+- default:
+- row += xx+1;
+- m += (xx+1)*nChannels;
+- if (row >= nRows) break;
+- }
+- }
+-}
+-
+-
+-
+-BOOL CSoundFile::ReadMDL(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- DWORD dwMemPos, dwPos, blocklen, dwTrackPos;
+- const MDLSONGHEADER *pmsh = (const MDLSONGHEADER *)lpStream;
+- MDLINFOBLOCK *pmib;
+- MDLPATTERNDATA *pmpd;
+- UINT i,j, norders = 0, npatterns = 0, ntracks = 0;
+- UINT ninstruments = 0, nsamples = 0;
+- WORD block;
+- WORD patterntracks[MAX_PATTERNS*32];
+- BYTE smpinfo[MAX_SAMPLES];
+- BYTE insvolenv[MAX_INSTRUMENTS];
+- BYTE inspanenv[MAX_INSTRUMENTS];
+- LPCBYTE pvolenv, ppanenv, ppitchenv;
+- UINT nvolenv, npanenv, npitchenv;
+-
+- if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
+- if ((bswapLE32(pmsh->id) != 0x4C444D44) || ((pmsh->version & 0xF0) > 0x10)) return FALSE;
+- memset(patterntracks, 0, sizeof(patterntracks));
+- memset(smpinfo, 0, sizeof(smpinfo));
+- memset(insvolenv, 0, sizeof(insvolenv));
+- memset(inspanenv, 0, sizeof(inspanenv));
+- dwMemPos = 5;
+- dwTrackPos = 0;
+- pvolenv = ppanenv = ppitchenv = NULL;
+- nvolenv = npanenv = npitchenv = 0;
+- m_nSamples = m_nInstruments = 0;
+- m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- while (dwMemPos+6 < dwMemLength)
+- {
+- block = *((WORD *)(lpStream+dwMemPos));
+- blocklen = *((DWORD *)(lpStream+dwMemPos+2));
+- block = bswapLE16(block);
+- blocklen = bswapLE32(blocklen);
+- dwMemPos += 6;
+- if (dwMemPos + blocklen > dwMemLength)
+- {
+- if (dwMemPos == 11) return FALSE;
+- break;
+- }
+- switch(block)
+- {
+- // IN: infoblock
+- case 0x4E49:
+- pmib = (MDLINFOBLOCK *)(lpStream+dwMemPos);
+- memcpy(m_szNames[0], pmib->songname, 32);
+- norders = bswapLE16(pmib->norders);
+- if (norders > MAX_ORDERS) norders = MAX_ORDERS;
+- m_nRestartPos = bswapLE16(pmib->repeatpos);
+- m_nDefaultGlobalVolume = pmib->globalvol;
+- if (m_nDefaultGlobalVolume == 255)
+- m_nDefaultGlobalVolume++;
+- m_nDefaultTempo = pmib->tempo;
+- m_nDefaultSpeed = pmib->speed;
+- m_nChannels = 4;
+- for (i=0; i<32; i++)
+- {
+- ChnSettings[i].nVolume = 64;
+- ChnSettings[i].nPan = (pmib->channelinfo[i] & 0x7F) << 1;
+- if (pmib->channelinfo[i] & 0x80)
+- ChnSettings[i].dwFlags |= CHN_MUTE;
+- else
+- m_nChannels = i+1;
+- }
+- for (j=0; j<norders; j++) Order[j] = pmib->seq[j];
+- break;
+- // ME: song message
+- case 0x454D:
+- if (blocklen)
+- {
+- if (m_lpszSongComments) delete m_lpszSongComments;
+- m_lpszSongComments = new char[blocklen];
+- if (m_lpszSongComments)
+- {
+- memcpy(m_lpszSongComments, lpStream+dwMemPos, blocklen);
+- m_lpszSongComments[blocklen-1] = 0;
+- }
+- }
+- break;
+- // PA: Pattern Data
+- case 0x4150:
+- npatterns = lpStream[dwMemPos];
+- if (npatterns > MAX_PATTERNS) npatterns = MAX_PATTERNS;
+- dwPos = dwMemPos + 1;
+- for (i=0; i<npatterns; i++)
+- {
+- if (dwPos+18 >= dwMemLength) break;
+- pmpd = (MDLPATTERNDATA *)(lpStream + dwPos);
+- if (pmpd->channels > 32) break;
+- PatternSize[i] = pmpd->lastrow+1;
+- PatternAllocSize[i] = pmpd->lastrow+1;
+- if (m_nChannels < pmpd->channels) m_nChannels = pmpd->channels;
+- dwPos += 18 + 2*pmpd->channels;
+- for (j=0; j<pmpd->channels; j++)
+- {
+- patterntracks[i*32+j] = bswapLE16(pmpd->data[j]);
+- }
+- }
+- break;
+- // TR: Track Data
+- case 0x5254:
+- if (dwTrackPos) break;
+- ntracks = *((WORD *)(lpStream+dwMemPos));
+- ntracks = bswapLE16(ntracks);
+- dwTrackPos = dwMemPos+2;
+- break;
+- // II: Instruments
+- case 0x4949:
+- ninstruments = lpStream[dwMemPos];
+- dwPos = dwMemPos+1;
+- for (i=0; i<ninstruments; i++)
+- {
+- UINT nins = lpStream[dwPos];
+- if ((nins >= MAX_INSTRUMENTS) || (!nins)) break;
+- if (m_nInstruments < nins) m_nInstruments = nins;
+- if (!Headers[nins])
+- {
+- UINT note = 12;
+- if ((Headers[nins] = new INSTRUMENTHEADER) == NULL) break;
+- INSTRUMENTHEADER *penv = Headers[nins];
+- memset(penv, 0, sizeof(INSTRUMENTHEADER));
+- memcpy(penv->name, lpStream+dwPos+2, 32);
+- penv->nGlobalVol = 128;
+- penv->nPPC = 5*12;
+- for (j=0; j<lpStream[dwPos+1]; j++)
+- {
+- const BYTE *ps = lpStream+dwPos+34+14*j;
+- while ((note < (UINT)(ps[1]+12)) && (note < 120))
+- {
+- penv->NoteMap[note] = note+1;
+- if (ps[0] < MAX_SAMPLES)
+- {
+- int ismp = ps[0];
+- penv->Keyboard[note] = ps[0];
+- Ins[ismp].nVolume = ps[2];
+- Ins[ismp].nPan = ps[4] << 1;
+- Ins[ismp].nVibType = ps[11];
+- Ins[ismp].nVibSweep = ps[10];
+- Ins[ismp].nVibDepth = ps[9];
+- Ins[ismp].nVibRate = ps[8];
+- }
+- penv->nFadeOut = (ps[7] << 8) | ps[6];
+- if (penv->nFadeOut == 0xFFFF) penv->nFadeOut = 0;
+- note++;
+- }
+- // Use volume envelope ?
+- if (ps[3] & 0x80)
+- {
+- penv->dwFlags |= ENV_VOLUME;
+- insvolenv[nins] = (ps[3] & 0x3F) + 1;
+- }
+- // Use panning envelope ?
+- if (ps[5] & 0x80)
+- {
+- penv->dwFlags |= ENV_PANNING;
+- inspanenv[nins] = (ps[5] & 0x3F) + 1;
+- }
+- }
+- }
+- dwPos += 34 + 14*lpStream[dwPos+1];
+- }
+- for (j=1; j<=m_nInstruments; j++) if (!Headers[j])
+- {
+- Headers[j] = new INSTRUMENTHEADER;
+- if (Headers[j]) memset(Headers[j], 0, sizeof(INSTRUMENTHEADER));
+- }
+- break;
+- // VE: Volume Envelope
+- case 0x4556:
+- if ((nvolenv = lpStream[dwMemPos]) == 0) break;
+- if (dwMemPos + nvolenv*32 + 1 <= dwMemLength) pvolenv = lpStream + dwMemPos + 1;
+- break;
+- // PE: Panning Envelope
+- case 0x4550:
+- if ((npanenv = lpStream[dwMemPos]) == 0) break;
+- if (dwMemPos + npanenv*32 + 1 <= dwMemLength) ppanenv = lpStream + dwMemPos + 1;
+- break;
+- // FE: Pitch Envelope
+- case 0x4546:
+- if ((npitchenv = lpStream[dwMemPos]) == 0) break;
+- if (dwMemPos + npitchenv*32 + 1 <= dwMemLength) ppitchenv = lpStream + dwMemPos + 1;
+- break;
+- // IS: Sample Infoblock
+- case 0x5349:
+- nsamples = lpStream[dwMemPos];
+- dwPos = dwMemPos+1;
+- for (i=0; i<nsamples; i++, dwPos += 59)
+- {
+- UINT nins = lpStream[dwPos];
+- if ((nins >= MAX_SAMPLES) || (!nins)) continue;
+- if (m_nSamples < nins) m_nSamples = nins;
+- MODINSTRUMENT *pins = &Ins[nins];
+- memcpy(m_szNames[nins], lpStream+dwPos+1, 32);
+- memcpy(pins->name, lpStream+dwPos+33, 8);
+- pins->nC4Speed = *((DWORD *)(lpStream+dwPos+41));
+- pins->nC4Speed = bswapLE32(pins->nC4Speed);
+- pins->nLength = *((DWORD *)(lpStream+dwPos+45));
+- pins->nLength = bswapLE32(pins->nLength);
+- pins->nLoopStart = *((DWORD *)(lpStream+dwPos+49));
+- pins->nLoopStart = bswapLE32(pins->nLoopStart);
+- pins->nLoopEnd = pins->nLoopStart + *((DWORD *)(lpStream+dwPos+53));
+- pins->nLoopEnd = bswapLE32(pins->nLoopEnd);
+- if (pins->nLoopEnd > pins->nLoopStart) pins->uFlags |= CHN_LOOP;
+- pins->nGlobalVol = 64;
+- if (lpStream[dwPos+58] & 0x01)
+- {
+- pins->uFlags |= CHN_16BIT;
+- pins->nLength >>= 1;
+- pins->nLoopStart >>= 1;
+- pins->nLoopEnd >>= 1;
+- }
+- if (lpStream[dwPos+58] & 0x02) pins->uFlags |= CHN_PINGPONGLOOP;
+- smpinfo[nins] = (lpStream[dwPos+58] >> 2) & 3;
+- }
+- break;
+- // SA: Sample Data
+- case 0x4153:
+- dwPos = dwMemPos;
+- for (i=1; i<=m_nSamples; i++) if ((Ins[i].nLength) && (!Ins[i].pSample) && (smpinfo[i] != 3) && (dwPos < dwMemLength))
+- {
+- MODINSTRUMENT *pins = &Ins[i];
+- UINT flags = (pins->uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+- if (!smpinfo[i])
+- {
+- dwPos += ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwMemLength - dwPos);
+- } else
+- {
+- DWORD dwLen = *((DWORD *)(lpStream+dwPos));
+- dwLen = bswapLE32(dwLen);
+- dwPos += 4;
+- if ((dwPos+dwLen <= dwMemLength) && (dwLen > 4))
+- {
+- flags = (pins->uFlags & CHN_16BIT) ? RS_MDL16 : RS_MDL8;
+- ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwLen);
+- }
+- dwPos += dwLen;
+- }
+- }
+- break;
+- }
+- dwMemPos += blocklen;
+- }
+- // Unpack Patterns
+- if ((dwTrackPos) && (npatterns) && (m_nChannels) && (ntracks))
+- {
+- for (UINT ipat=0; ipat<npatterns; ipat++)
+- {
+- if ((Patterns[ipat] = AllocatePattern(PatternSize[ipat], m_nChannels)) == NULL) break;
+- for (UINT chn=0; chn<m_nChannels; chn++) if ((patterntracks[ipat*32+chn]) && (patterntracks[ipat*32+chn] <= ntracks))
+- {
+- MODCOMMAND *m = Patterns[ipat] + chn;
+- UnpackMDLTrack(m, m_nChannels, PatternSize[ipat], patterntracks[ipat*32+chn], lpStream+dwTrackPos);
+- }
+- }
+- }
+- // Set up envelopes
+- for (UINT iIns=1; iIns<=m_nInstruments; iIns++) if (Headers[iIns])
+- {
+- INSTRUMENTHEADER *penv = Headers[iIns];
+- // Setup volume envelope
+- if ((nvolenv) && (pvolenv) && (insvolenv[iIns]))
+- {
+- LPCBYTE pve = pvolenv;
+- for (UINT nve=0; nve<nvolenv; nve++, pve+=33) if (pve[0]+1 == insvolenv[iIns])
+- {
+- WORD vtick = 1;
+- penv->VolEnv.nNodes = 15;
+- for (UINT iv=0; iv<15; iv++)
+- {
+- if (iv) vtick += pve[iv*2+1];
+- penv->VolEnv.Ticks[iv] = vtick;
+- penv->VolEnv.Values[iv] = pve[iv*2+2];
+- if (!pve[iv*2+1])
+- {
+- penv->VolEnv.nNodes = iv+1;
+- break;
+- }
+- }
+- penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = pve[31] & 0x0F;
+- if (pve[31] & 0x10) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (pve[31] & 0x20) penv->dwFlags |= ENV_VOLLOOP;
+- penv->VolEnv.nLoopStart = pve[32] & 0x0F;
+- penv->VolEnv.nLoopEnd = pve[32] >> 4;
+- }
+- }
+- // Setup panning envelope
+- if ((npanenv) && (ppanenv) && (inspanenv[iIns]))
+- {
+- LPCBYTE ppe = ppanenv;
+- for (UINT npe=0; npe<npanenv; npe++, ppe+=33) if (ppe[0]+1 == inspanenv[iIns])
+- {
+- WORD vtick = 1;
+- penv->PanEnv.nNodes = 15;
+- for (UINT iv=0; iv<15; iv++)
+- {
+- if (iv) vtick += ppe[iv*2+1];
+- penv->PanEnv.Ticks[iv] = vtick;
+- penv->PanEnv.Values[iv] = ppe[iv*2+2];
+- if (!ppe[iv*2+1])
+- {
+- penv->PanEnv.nNodes = iv+1;
+- break;
+- }
+- }
+- if (ppe[31] & 0x10) penv->dwFlags |= ENV_PANSUSTAIN;
+- if (ppe[31] & 0x20) penv->dwFlags |= ENV_PANLOOP;
+- penv->PanEnv.nLoopStart = ppe[32] & 0x0F;
+- penv->PanEnv.nLoopEnd = ppe[32] >> 4;
+- }
+- }
+- }
+- m_dwSongFlags |= SONG_LINEARSLIDES;
+- m_nType = MOD_TYPE_MDL;
+- return TRUE;
+-}
+-
+-
+-/////////////////////////////////////////////////////////////////////////
+-// MDL Sample Unpacking
+-
+-// MDL Huffman ReadBits compression
+-WORD MDLReadBits(DWORD &bitbuf, UINT &bitnum, LPBYTE &ibuf, CHAR n)
+-//-----------------------------------------------------------------
+-{
+- WORD v = (WORD)(bitbuf & ((1 << n) - 1) );
+- bitbuf >>= n;
+- bitnum -= n;
+- if (bitnum <= 24)
+- {
+- bitbuf |= (((DWORD)(*ibuf++)) << bitnum);
+- bitnum += 8;
+- }
+- return v;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_med.cxx audacious-plugins-2.5.4/src/modplug/load_med.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_med.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_med.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,919 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#define MED_LOG
+-
+-#ifdef MED_LOG
+-extern void Log(LPCSTR s, ...);
+-#endif
+-
+-//////////////////////////////////////////////////////////
+-// OctaMed MED file support (import only)
+-
+-// flags
+-#define MMD_FLAG_FILTERON 0x1
+-#define MMD_FLAG_JUMPINGON 0x2
+-#define MMD_FLAG_JUMP8TH 0x4
+-#define MMD_FLAG_INSTRSATT 0x8 // instruments are attached (this is a module)
+-#define MMD_FLAG_VOLHEX 0x10
+-#define MMD_FLAG_STSLIDE 0x20 // SoundTracker mode for slides
+-#define MMD_FLAG_8CHANNEL 0x40 // OctaMED 8 channel song
+-#define MMD_FLAG_SLOWHQ 0x80 // HQ slows playing speed (V2-V4 compatibility)
+-// flags2
+-#define MMD_FLAG2_BMASK 0x1F
+-#define MMD_FLAG2_BPM 0x20
+-#define MMD_FLAG2_MIX 0x80 // uses Mixing (V7+)
+-// flags3:
+-#define MMD_FLAG3_STEREO 0x1 // mixing in Stereo mode
+-#define MMD_FLAG3_FREEPAN 0x2 // free panning
+-#define MMD_FLAG3_GM 0x4 // module designed for GM/XG compatibility
+-
+-
+-// generic MMD tags
+-#define MMDTAG_END 0
+-#define MMDTAG_PTR 0x80000000 // data needs relocation
+-#define MMDTAG_MUSTKNOW 0x40000000 // loader must fail if this isn't recognized
+-#define MMDTAG_MUSTWARN 0x20000000 // loader must warn if this isn't recognized
+-
+-// ExpData tags
+-// # of effect groups, including the global group (will
+-// override settings in MMDSong struct), default = 1
+-#define MMDTAG_EXP_NUMFXGROUPS 1
+-#define MMDTAG_TRK_NAME (MMDTAG_PTR|1) // trackinfo tags
+-#define MMDTAG_TRK_NAMELEN 2 // namelen includes zero term.
+-#define MMDTAG_TRK_FXGROUP 3
+-// effectinfo tags
+-#define MMDTAG_FX_ECHOTYPE 1
+-#define MMDTAG_FX_ECHOLEN 2
+-#define MMDTAG_FX_ECHODEPTH 3
+-#define MMDTAG_FX_STEREOSEP 4
+-#define MMDTAG_FX_GROUPNAME (MMDTAG_PTR|5) // the Global Effects group shouldn't have name saved!
+-#define MMDTAG_FX_GRPNAMELEN 6 // namelen includes zero term.
+-
+-#pragma pack(1)
+-
+-typedef struct tagMEDMODULEHEADER
+-{
+- DWORD id; // MMD1-MMD3
+- DWORD modlen; // Size of file
+- DWORD song; // Position in file for this song
+- WORD psecnum;
+- WORD pseq;
+- DWORD blockarr; // Position in file for blocks
+- DWORD mmdflags;
+- DWORD smplarr; // Position in file for samples
+- DWORD reserved;
+- DWORD expdata; // Absolute offset in file for ExpData (0 if not present)
+- DWORD reserved2;
+- WORD pstate;
+- WORD pblock;
+- WORD pline;
+- WORD pseqnum;
+- WORD actplayline;
+- BYTE counter;
+- BYTE extra_songs; // # of songs - 1
+-} MEDMODULEHEADER;
+-
+-
+-typedef struct tagMMD0SAMPLE
+-{
+- WORD rep, replen;
+- BYTE midich;
+- BYTE midipreset;
+- BYTE svol;
+- signed char strans;
+-} MMD0SAMPLE;
+-
+-
+-// Sample header is immediately followed by sample data...
+-typedef struct tagMMDSAMPLEHEADER
+-{
+- DWORD length; // length of *one* *unpacked* channel in *bytes*
+- WORD type;
+- // if non-negative
+- // bits 0-3 reserved for multi-octave instruments, not supported on the PC
+- // 0x10: 16 bit (otherwise 8 bit)
+- // 0x20: Stereo (otherwise mono)
+- // 0x40: Uses DeltaCode
+- // 0x80: Packed data
+- // -1: Synth
+- // -2: Hybrid
+- // if type indicates packed data, these fields follow, otherwise we go right to the data
+- WORD packtype; // Only 1 = ADPCM is supported
+- WORD subtype; // Packing subtype
+- // ADPCM subtype
+- // 1: g723_40
+- // 2: g721
+- // 3: g723_24
+- BYTE commonflags; // flags common to all packtypes (none defined so far)
+- BYTE packerflags; // flags for the specific packtype
+- ULONG leftchlen; // packed length of left channel in bytes
+- ULONG rightchlen; // packed length of right channel in bytes (ONLY PRESENT IN STEREO SAMPLES)
+- BYTE SampleData[1]; // Sample Data
+-} MMDSAMPLEHEADER;
+-
+-
+-// MMD0/MMD1 song header
+-typedef struct tagMMD0SONGHEADER
+-{
+- MMD0SAMPLE sample[63];
+- WORD numblocks; // # of blocks
+- WORD songlen; // # of entries used in playseq
+- BYTE playseq[256]; // Play sequence
+- WORD deftempo; // BPM tempo
+- signed char playtransp; // Play transpose
+- BYTE flags; // 0x10: Hex Volumes | 0x20: ST/NT/PT Slides | 0x40: 8 Channels song
+- BYTE flags2; // [b4-b0]+1: Tempo LPB, 0x20: tempo mode, 0x80: mix_conv=on
+- BYTE tempo2; // tempo TPL
+- BYTE trkvol[16]; // track volumes
+- BYTE mastervol; // master volume
+- BYTE numsamples; // # of samples (max=63)
+-} MMD0SONGHEADER;
+-
+-
+-// MMD2/MMD3 song header
+-typedef struct tagMMD2SONGHEADER
+-{
+- MMD0SAMPLE sample[63];
+- WORD numblocks; // # of blocks
+- WORD numsections; // # of sections
+- DWORD playseqtable; // filepos of play sequence
+- DWORD sectiontable; // filepos of sections table (WORD array)
+- DWORD trackvols; // filepos of tracks volume (BYTE array)
+- WORD numtracks; // # of tracks (max 64)
+- WORD numpseqs; // # of play sequences
+- DWORD trackpans; // filepos of tracks pan values (BYTE array)
+- LONG flags3; // 0x1:stereo_mix, 0x2:free_panning, 0x4:GM/XG compatibility
+- WORD voladj; // vol_adjust (set to 100 if 0)
+- WORD channels; // # of channels (4 if =0)
+- BYTE mix_echotype; // 1:normal,2:xecho
+- BYTE mix_echodepth; // 1..6
+- WORD mix_echolen; // > 0
+- signed char mix_stereosep; // -4..4
+- BYTE pad0[223];
+- WORD deftempo; // BPM tempo
+- signed char playtransp; // play transpose
+- BYTE flags; // 0x1:filteron, 0x2:jumpingon, 0x4:jump8th, 0x8:instr_attached, 0x10:hex_vol, 0x20:PT_slides, 0x40:8ch_conv,0x80:hq slows playing speed
+- BYTE flags2; // 0x80:mix_conv=on, [b4-b0]+1:tempo LPB, 0x20:tempo_mode
+- BYTE tempo2; // tempo TPL
+- BYTE pad1[16];
+- BYTE mastervol; // master volume
+- BYTE numsamples; // # of samples (max 63)
+-} MMD2SONGHEADER;
+-
+-// For MMD0 the note information is held in 3 bytes, byte0, byte1, byte2. For reference we
+-// number the bits in each byte 0..7, where 0 is the low bit.
+-// The note is held as bits 5..0 of byte0
+-// The instrument is encoded in 6 bits, bits 7 and 6 of byte0 and bits 7,6,5,4 of byte1
+-// The command number is bits 3,2,1,0 of byte1, command data is in byte2:
+-// For command 0, byte2 represents the second data byte, otherwise byte2
+-// represents the first data byte.
+-typedef struct tagMMD0BLOCK
+-{
+- BYTE numtracks;
+- BYTE lines; // File value is 1 less than actual, so 0 -> 1 line
+-} MMD0BLOCK; // BYTE data[lines+1][tracks][3];
+-
+-
+-// For MMD1,MMD2,MMD3 the note information is carried in 4 bytes, byte0, byte1,
+-// byte2 and byte3
+-// The note is held as byte0 (values above 0x84 are ignored)
+-// The instrument is held as byte1
+-// The command number is held as byte2, command data is in byte3
+-// For commands 0 and 0x19 byte3 represents the second data byte,
+-// otherwise byte2 represents the first data byte.
+-typedef struct tagMMD1BLOCK
+-{
+- WORD numtracks; // Number of tracks, may be > 64, but then that data is skipped.
+- WORD lines; // Stored value is 1 less than actual, so 0 -> 1 line
+- DWORD info; // Offset of BlockInfo (if 0, no block_info is present)
+-} MMD1BLOCK;
+-
+-
+-typedef struct tagMMD1BLOCKINFO
+-{
+- DWORD hlmask; // Unimplemented - ignore
+- DWORD blockname; // file offset of block name
+- DWORD blocknamelen; // length of block name (including term. 0)
+- DWORD pagetable; // file offset of command page table
+- DWORD cmdexttable; // file offset of command extension table
+- DWORD reserved[4]; // future expansion
+-} MMD1BLOCKINFO;
+-
+-
+-// A set of play sequences is stored as an array of ULONG files offsets
+-// Each offset points to the play sequence itself.
+-typedef struct tagMMD2PLAYSEQ
+-{
+- CHAR name[32];
+- DWORD command_offs; // filepos of command table
+- DWORD reserved;
+- WORD length;
+- WORD seq[512]; // skip if > 0x8000
+-} MMD2PLAYSEQ;
+-
+-
+-// A command table contains commands that effect a particular play sequence
+-// entry. The only commands read in are STOP or POSJUMP, all others are ignored
+-// POSJUMP is presumed to have extra bytes containing a WORD for the position
+-typedef struct tagMMDCOMMAND
+-{
+- WORD offset; // Offset within current sequence entry
+- BYTE cmdnumber; // STOP (537) or POSJUMP (538) (others skipped)
+- BYTE extra_count;
+- BYTE extra_bytes[4];// [extra_count];
+-} MMDCOMMAND; // Last entry has offset == 0xFFFF, cmd_number == 0 and 0 extrabytes
+-
+-
+-typedef struct tagMMD0EXP
+-{
+- DWORD nextmod; // File offset of next Hdr
+- DWORD exp_smp; // Pointer to extra instrument data
+- WORD s_ext_entries; // Number of extra instrument entries
+- WORD s_ext_entrsz; // Size of extra instrument data
+- DWORD annotxt;
+- DWORD annolen;
+- DWORD iinfo; // Instrument names
+- WORD i_ext_entries;
+- WORD i_ext_entrsz;
+- DWORD jumpmask;
+- DWORD rgbtable;
+- BYTE channelsplit[4]; // Only used if 8ch_conv (extra channel for every nonzero entry)
+- DWORD n_info;
+- DWORD songname; // Song name
+- DWORD songnamelen;
+- DWORD dumps;
+- DWORD mmdinfo;
+- DWORD mmdrexx;
+- DWORD mmdcmd3x;
+- DWORD trackinfo_ofs; // ptr to song->numtracks ptrs to tag lists
+- DWORD effectinfo_ofs; // ptr to group ptrs
+- DWORD tag_end;
+-} MMD0EXP;
+-
+-#pragma pack()
+-
+-
+-
+-static void MedConvert(MODCOMMAND *p, const MMD0SONGHEADER *pmsh)
+-//---------------------------------------------------------------
+-{
+- const BYTE bpmvals[9] = { 179,164,152,141,131,123,116,110,104};
+-
+- UINT command = p->command;
+- UINT param = p->param;
+- switch(command)
+- {
+- case 0x00: if (param) command = CMD_ARPEGGIO; else command = 0; break;
+- case 0x01: command = CMD_PORTAMENTOUP; break;
+- case 0x02: command = CMD_PORTAMENTODOWN; break;
+- case 0x03: command = CMD_TONEPORTAMENTO; break;
+- case 0x04: command = CMD_VIBRATO; break;
+- case 0x05: command = CMD_TONEPORTAVOL; break;
+- case 0x06: command = CMD_VIBRATOVOL; break;
+- case 0x07: command = CMD_TREMOLO; break;
+- case 0x0A: if (param & 0xF0) param &= 0xF0; command = CMD_VOLUMESLIDE; if (!param) command = 0; break;
+- case 0x0B: command = CMD_POSITIONJUMP; break;
+- case 0x0C: command = CMD_VOLUME;
+- if (pmsh->flags & MMD_FLAG_VOLHEX)
+- {
+- if (param < 0x80)
+- {
+- param = (param+1) / 2;
+- } else command = 0;
+- } else
+- {
+- if (param <= 0x99)
+- {
+- param = (param >> 4)*10+((param & 0x0F) % 10);
+- if (param > 64) param = 64;
+- } else command = 0;
+- }
+- break;
+- case 0x09: command = (param < 0x20) ? CMD_SPEED : CMD_TEMPO; break;
+- case 0x0D: if (param & 0xF0) param &= 0xF0; command = CMD_VOLUMESLIDE; if (!param) command = 0; break;
+- case 0x0F: // Set Tempo / Special
+- // F.00 = Pattern Break
+- if (!param) command = CMD_PATTERNBREAK; else
+- // F.01 - F.F0: Set tempo/speed
+- if (param <= 0xF0)
+- {
+- if (pmsh->flags & MMD_FLAG_8CHANNEL)
+- {
+- param = (param > 10) ? 99 : bpmvals[param-1];
+- } else
+- // F.01 - F.0A: Set Speed
+- if (param <= 0x0A)
+- {
+- command = CMD_SPEED;
+- } else
+- // Old tempo
+- if (!(pmsh->flags2 & MMD_FLAG2_BPM))
+- {
+- param = _muldiv(param, 5*715909, 2*474326);
+- }
+- // F.0B - F.F0: Set Tempo (assumes LPB=4)
+- if (param > 0x0A)
+- {
+- command = CMD_TEMPO;
+- if (param < 0x21) param = 0x21;
+- if (param > 240) param = 240;
+- }
+- } else
+- switch(param)
+- {
+- // F.F1: Retrig 2x
+- case 0xF1:
+- command = CMD_MODCMDEX;
+- param = 0x93;
+- break;
+- // F.F2: Note Delay 2x
+- case 0xF2:
+- command = CMD_MODCMDEX;
+- param = 0xD3;
+- break;
+- // F.F3: Retrig 3x
+- case 0xF3:
+- command = CMD_MODCMDEX;
+- param = 0x92;
+- break;
+- // F.F4: Note Delay 1/3
+- case 0xF4:
+- command = CMD_MODCMDEX;
+- param = 0xD2;
+- break;
+- // F.F5: Note Delay 2/3
+- case 0xF5:
+- command = CMD_MODCMDEX;
+- param = 0xD4;
+- break;
+- // F.F8: Filter Off
+- case 0xF8:
+- command = CMD_MODCMDEX;
+- param = 0x00;
+- break;
+- // F.F9: Filter On
+- case 0xF9:
+- command = CMD_MODCMDEX;
+- param = 0x01;
+- break;
+- // F.FD: Very fast tone-portamento
+- case 0xFD:
+- command = CMD_TONEPORTAMENTO;
+- param = 0xFF;
+- break;
+- // F.FE: End Song
+- case 0xFE:
+- command = CMD_SPEED;
+- param = 0;
+- break;
+- // F.FF: Note Cut
+- case 0xFF:
+- command = CMD_MODCMDEX;
+- param = 0xC0;
+- break;
+- default:
+-#ifdef MED_LOG
+- Log("Unknown Fxx command: cmd=0x%02X param=0x%02X\n", command, param);
+-#endif
+- param = command = 0;
+- }
+- break;
+- // 11.0x: Fine Slide Up
+- case 0x11:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0x10;
+- break;
+- // 12.0x: Fine Slide Down
+- case 0x12:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0x20;
+- break;
+- // 14.xx: Vibrato
+- case 0x14:
+- command = CMD_VIBRATO;
+- break;
+- // 15.xx: FineTune
+- case 0x15:
+- command = CMD_MODCMDEX;
+- param &= 0x0F;
+- param |= 0x50;
+- break;
+- // 16.xx: Pattern Loop
+- case 0x16:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0x60;
+- break;
+- // 18.xx: Note Cut
+- case 0x18:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0xC0;
+- break;
+- // 19.xx: Sample Offset
+- case 0x19:
+- command = CMD_OFFSET;
+- break;
+- // 1A.0x: Fine Volume Up
+- case 0x1A:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0xA0;
+- break;
+- // 1B.0x: Fine Volume Down
+- case 0x1B:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0xB0;
+- break;
+- // 1D.xx: Pattern Break
+- case 0x1D:
+- command = CMD_PATTERNBREAK;
+- break;
+- // 1E.0x: Pattern Delay
+- case 0x1E:
+- command = CMD_MODCMDEX;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0xE0;
+- break;
+- // 1F.xy: Retrig
+- case 0x1F:
+- command = CMD_RETRIG;
+- param &= 0x0F;
+- break;
+- // 2E.xx: set panning
+- case 0x2E:
+- command = CMD_MODCMDEX;
+- param = ((param + 0x10) & 0xFF) >> 1;
+- if (param > 0x0F) param = 0x0F;
+- param |= 0x80;
+- break;
+- default:
+-#ifdef MED_LOG
+- // 0x2E ?
+- Log("Unknown command: cmd=0x%02X param=0x%02X\n", command, param);
+-#endif
+- command = param = 0;
+- }
+- p->command = command;
+- p->param = param;
+-}
+-
+-
+-BOOL CSoundFile::ReadMed(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- const MEDMODULEHEADER *pmmh;
+- const MMD0SONGHEADER *pmsh;
+- const MMD2SONGHEADER *pmsh2;
+- const MMD0EXP *pmex;
+- DWORD dwBlockArr, dwSmplArr, dwExpData, wNumBlocks;
+- LPDWORD pdwTable;
+- CHAR version;
+- UINT deftempo;
+- int playtransp = 0;
+-
+- if ((!lpStream) || (dwMemLength < 0x200)) return FALSE;
+- pmmh = (MEDMODULEHEADER *)lpStream;
+- if (((pmmh->id & 0x00FFFFFF) != 0x444D4D) || (!pmmh->song)) return FALSE;
+- // Check for 'MMDx'
+- DWORD dwSong = bswapBE32(pmmh->song);
+- if ((dwSong >= dwMemLength) || (dwSong + sizeof(MMD0SONGHEADER) >= dwMemLength)) return FALSE;
+- version = (signed char)((pmmh->id >> 24) & 0xFF);
+- if ((version < '0') || (version > '3')) return FALSE;
+-#ifdef MED_LOG
+- Log("\nLoading MMD%c module (flags=0x%02X)...\n", version, bswapBE32(pmmh->mmdflags));
+- Log(" modlen = %d\n", bswapBE32(pmmh->modlen));
+- Log(" song = 0x%08X\n", bswapBE32(pmmh->song));
+- Log(" psecnum = %d\n", bswapBE16(pmmh->psecnum));
+- Log(" pseq = %d\n", bswapBE16(pmmh->pseq));
+- Log(" blockarr = 0x%08X\n", bswapBE32(pmmh->blockarr));
+- Log(" mmdflags = 0x%08X\n", bswapBE32(pmmh->mmdflags));
+- Log(" smplarr = 0x%08X\n", bswapBE32(pmmh->smplarr));
+- Log(" reserved = 0x%08X\n", bswapBE32(pmmh->reserved));
+- Log(" expdata = 0x%08X\n", bswapBE32(pmmh->expdata));
+- Log(" reserved2= 0x%08X\n", bswapBE32(pmmh->reserved2));
+- Log(" pstate = %d\n", bswapBE16(pmmh->pstate));
+- Log(" pblock = %d\n", bswapBE16(pmmh->pblock));
+- Log(" pline = %d\n", bswapBE16(pmmh->pline));
+- Log(" pseqnum = %d\n", bswapBE16(pmmh->pseqnum));
+- Log(" actplayline=%d\n", bswapBE16(pmmh->actplayline));
+- Log(" counter = %d\n", pmmh->counter);
+- Log(" extra_songs = %d\n", pmmh->extra_songs);
+- Log("\n");
+-#endif
+- m_nType = MOD_TYPE_MED;
+- m_nSongPreAmp = 0x20;
+- dwBlockArr = bswapBE32(pmmh->blockarr);
+- dwSmplArr = bswapBE32(pmmh->smplarr);
+- dwExpData = bswapBE32(pmmh->expdata);
+- if ((dwExpData) && (dwExpData+sizeof(MMD0EXP) < dwMemLength))
+- pmex = (MMD0EXP *)(lpStream+dwExpData);
+- else
+- pmex = NULL;
+- pmsh = (MMD0SONGHEADER *)(lpStream + dwSong);
+- pmsh2 = (MMD2SONGHEADER *)pmsh;
+-#ifdef MED_LOG
+- if (version < '2')
+- {
+- Log("MMD0 Header:\n");
+- Log(" numblocks = %d\n", bswapBE16(pmsh->numblocks));
+- Log(" songlen = %d\n", bswapBE16(pmsh->songlen));
+- Log(" playseq = ");
+- for (UINT idbg1=0; idbg1<16; idbg1++) Log("%2d, ", pmsh->playseq[idbg1]);
+- Log("...\n");
+- Log(" deftempo = 0x%04X\n", bswapBE16(pmsh->deftempo));
+- Log(" playtransp = %d\n", (signed char)pmsh->playtransp);
+- Log(" flags(1,2) = 0x%02X, 0x%02X\n", pmsh->flags, pmsh->flags2);
+- Log(" tempo2 = %d\n", pmsh->tempo2);
+- Log(" trkvol = ");
+- for (UINT idbg2=0; idbg2<16; idbg2++) Log("0x%02X, ", pmsh->trkvol[idbg2]);
+- Log("...\n");
+- Log(" mastervol = 0x%02X\n", pmsh->mastervol);
+- Log(" numsamples = %d\n", pmsh->numsamples);
+- } else
+- {
+- Log("MMD2 Header:\n");
+- Log(" numblocks = %d\n", bswapBE16(pmsh2->numblocks));
+- Log(" numsections= %d\n", bswapBE16(pmsh2->numsections));
+- Log(" playseqptr = 0x%04X\n", bswapBE32(pmsh2->playseqtable));
+- Log(" sectionptr = 0x%04X\n", bswapBE32(pmsh2->sectiontable));
+- Log(" trackvols = 0x%04X\n", bswapBE32(pmsh2->trackvols));
+- Log(" numtracks = %d\n", bswapBE16(pmsh2->numtracks));
+- Log(" numpseqs = %d\n", bswapBE16(pmsh2->numpseqs));
+- Log(" trackpans = 0x%04X\n", bswapBE32(pmsh2->trackpans));
+- Log(" flags3 = 0x%08X\n", bswapBE32(pmsh2->flags3));
+- Log(" voladj = %d\n", bswapBE16(pmsh2->voladj));
+- Log(" channels = %d\n", bswapBE16(pmsh2->channels));
+- Log(" echotype = %d\n", pmsh2->mix_echotype);
+- Log(" echodepth = %d\n", pmsh2->mix_echodepth);
+- Log(" echolen = %d\n", bswapBE16(pmsh2->mix_echolen));
+- Log(" stereosep = %d\n", (signed char)pmsh2->mix_stereosep);
+- Log(" deftempo = 0x%04X\n", bswapBE16(pmsh2->deftempo));
+- Log(" playtransp = %d\n", (signed char)pmsh2->playtransp);
+- Log(" flags(1,2) = 0x%02X, 0x%02X\n", pmsh2->flags, pmsh2->flags2);
+- Log(" tempo2 = %d\n", pmsh2->tempo2);
+- Log(" mastervol = 0x%02X\n", pmsh2->mastervol);
+- Log(" numsamples = %d\n", pmsh->numsamples);
+- }
+- Log("\n");
+-#endif
+- wNumBlocks = bswapBE16(pmsh->numblocks);
+- m_nChannels = 4;
+- m_nSamples = pmsh->numsamples;
+- if (m_nSamples > 63) m_nSamples = 63;
+- m_nStereoSeparation = ((pmsh2->mix_stereosep < 0) ? -32 : 32) * pmsh2->mix_stereosep;
+- // Tempo
+- m_nDefaultTempo = 125;
+- deftempo = bswapBE16(pmsh->deftempo);
+- if (!deftempo) deftempo = 125;
+- if (pmsh->flags2 & MMD_FLAG2_BPM)
+- {
+- UINT tempo_tpl = (pmsh->flags2 & MMD_FLAG2_BMASK) + 1;
+- if (!tempo_tpl) tempo_tpl = 4;
+- deftempo *= tempo_tpl;
+- deftempo /= 4;
+- #ifdef MED_LOG
+- Log("newtempo: %3d bpm (bpm=%3d lpb=%2d)\n", deftempo, bswapBE16(pmsh->deftempo), (pmsh->flags2 & MMD_FLAG2_BMASK)+1);
+- #endif
+- } else
+- {
+- deftempo = _muldiv(deftempo, 5*715909, 2*474326);
+- #ifdef MED_LOG
+- Log("oldtempo: %3d bpm (bpm=%3d)\n", deftempo, bswapBE16(pmsh->deftempo));
+- #endif
+- }
+- // Speed
+- m_nDefaultSpeed = pmsh->tempo2;
+- if (!m_nDefaultSpeed) m_nDefaultSpeed = 6;
+- if (deftempo < 0x21) deftempo = 0x21;
+- if (deftempo > 255)
+- {
+- while ((m_nDefaultSpeed > 3) && (deftempo > 260))
+- {
+- deftempo = (deftempo * (m_nDefaultSpeed - 1)) / m_nDefaultSpeed;
+- m_nDefaultSpeed--;
+- }
+- if (deftempo > 255) deftempo = 255;
+- }
+- m_nDefaultTempo = deftempo;
+- // Reading Samples
+- for (UINT iSHdr=0; iSHdr<m_nSamples; iSHdr++)
+- {
+- MODINSTRUMENT *pins = &Ins[iSHdr+1];
+- pins->nLoopStart = bswapBE16(pmsh->sample[iSHdr].rep) << 1;
+- pins->nLoopEnd = pins->nLoopStart + (bswapBE16(pmsh->sample[iSHdr].replen) << 1);
+- pins->nVolume = (pmsh->sample[iSHdr].svol << 2);
+- pins->nGlobalVol = 64;
+- if (pins->nVolume > 256) pins->nVolume = 256;
+- pins->RelativeTone = -12 * pmsh->sample[iSHdr].strans;
+- pins->nPan = 128;
+- if (pins->nLoopEnd) pins->uFlags |= CHN_LOOP;
+- }
+- // Common Flags
+- if (!(pmsh->flags & 0x20)) m_dwSongFlags |= SONG_FASTVOLSLIDES;
+- // Reading play sequence
+- if (version < '2')
+- {
+- UINT nbo = pmsh->songlen >> 8;
+- if (nbo >= MAX_ORDERS) nbo = MAX_ORDERS-1;
+- if (!nbo) nbo = 1;
+- memcpy(Order, pmsh->playseq, nbo);
+- playtransp = pmsh->playtransp;
+- } else
+- {
+- UINT nOrders, nSections;
+- UINT nTrks = bswapBE16(pmsh2->numtracks);
+- if ((nTrks >= 4) && (nTrks <= 32)) m_nChannels = nTrks;
+- DWORD playseqtable = bswapBE32(pmsh2->playseqtable);
+- UINT numplayseqs = bswapBE16(pmsh2->numpseqs);
+- if (!numplayseqs) numplayseqs = 1;
+- nOrders = 0;
+- nSections = bswapBE16(pmsh2->numsections);
+- DWORD sectiontable = bswapBE32(pmsh2->sectiontable);
+- if ((!nSections) || (!sectiontable) || (sectiontable >= dwMemLength-2)) nSections = 1;
+- nOrders = 0;
+- for (UINT iSection=0; iSection<nSections; iSection++)
+- {
+- UINT nplayseq = 0;
+- if ((sectiontable) && (sectiontable < dwMemLength-2))
+- {
+- nplayseq = lpStream[sectiontable+1];
+- sectiontable += 2; // WORDs
+- } else
+- {
+- nSections = 0;
+- }
+- UINT pseq = 0;
+-
+- if ((playseqtable) && (playseqtable + nplayseq*4 < dwMemLength))
+- {
+- pseq = bswapBE32(((LPDWORD)(lpStream+playseqtable))[nplayseq]);
+- }
+- if ((pseq) && (pseq < dwMemLength - sizeof(MMD2PLAYSEQ)))
+- {
+- MMD2PLAYSEQ *pmps = (MMD2PLAYSEQ *)(lpStream + pseq);
+- if (!m_szNames[0][0]) memcpy(m_szNames[0], pmps->name, 31);
+- UINT n = bswapBE16(pmps->length);
+- if (pseq+n <= dwMemLength)
+- {
+- for (UINT i=0; i<n; i++)
+- {
+- UINT seqval = pmps->seq[i] >> 8;
+- if ((seqval < wNumBlocks) && (nOrders < MAX_ORDERS-1))
+- {
+- Order[nOrders++] = seqval;
+- }
+- }
+- }
+- }
+- }
+- playtransp = pmsh2->playtransp;
+- while (nOrders < MAX_ORDERS) Order[nOrders++] = 0xFF;
+- }
+- // Reading Expansion structure
+- if (pmex)
+- {
+- // Channel Split
+- if ((m_nChannels == 4) && (pmsh->flags & 0x40))
+- {
+- for (UINT i8ch=0; i8ch<4; i8ch++)
+- {
+- if (pmex->channelsplit[i8ch]) m_nChannels++;
+- }
+- }
+- // Song Comments
+- UINT annotxt = bswapBE32(pmex->annotxt);
+- UINT annolen = bswapBE32(pmex->annolen);
+- if ((annotxt) && (annolen) && (annotxt+annolen <= dwMemLength))
+- {
+- m_lpszSongComments = new char[annolen+1];
+- memcpy(m_lpszSongComments, lpStream+annotxt, annolen);
+- m_lpszSongComments[annolen] = 0;
+- }
+- // Song Name
+- UINT songname = bswapBE32(pmex->songname);
+- UINT songnamelen = bswapBE32(pmex->songnamelen);
+- if ((songname) && (songnamelen) && (songname+songnamelen <= dwMemLength))
+- {
+- if (songnamelen > 31) songnamelen = 31;
+- memcpy(m_szNames[0], lpStream+songname, songnamelen);
+- }
+- // Sample Names
+- DWORD smpinfoex = bswapBE32(pmex->iinfo);
+- if (smpinfoex)
+- {
+- DWORD iinfoptr = bswapBE32(pmex->iinfo);
+- UINT ientries = bswapBE16(pmex->i_ext_entries);
+- UINT ientrysz = bswapBE16(pmex->i_ext_entrsz);
+-
+- if ((iinfoptr) && (ientrysz < 256) && (iinfoptr + ientries*ientrysz < dwMemLength))
+- {
+- LPCSTR psznames = (LPCSTR)(lpStream + iinfoptr);
+- UINT maxnamelen = ientrysz;
+- if (maxnamelen > 32) maxnamelen = 32;
+- for (UINT i=0; i<ientries; i++) if (i < m_nSamples)
+- {
+- lstrcpyn(m_szNames[i+1], psznames + i*ientrysz, maxnamelen);
+- }
+- }
+- }
+- // Track Names
+- DWORD trackinfo_ofs = bswapBE32(pmex->trackinfo_ofs);
+- if ((trackinfo_ofs) && (trackinfo_ofs + m_nChannels * 4 < dwMemLength))
+- {
+- DWORD *ptrktags = (DWORD *)(lpStream + trackinfo_ofs);
+- for (UINT i=0; i<m_nChannels; i++)
+- {
+- DWORD trknameofs = 0, trknamelen = 0;
+- DWORD trktagofs = bswapBE32(ptrktags[i]);
+- if (trktagofs)
+- {
+- while (trktagofs+8 < dwMemLength)
+- {
+- DWORD ntag = bswapBE32(*(DWORD *)(lpStream + trktagofs));
+- if (ntag == MMDTAG_END) break;
+- DWORD tagdata = bswapBE32(*(DWORD *)(lpStream + trktagofs + 4));
+- switch(ntag)
+- {
+- case MMDTAG_TRK_NAMELEN: trknamelen = tagdata; break;
+- case MMDTAG_TRK_NAME: trknameofs = tagdata; break;
+- }
+- trktagofs += 8;
+- }
+- if (trknamelen > MAX_CHANNELNAME) trknamelen = MAX_CHANNELNAME;
+- if ((trknameofs) && (trknameofs + trknamelen < dwMemLength))
+- {
+- lstrcpyn(ChnSettings[i].szName, (LPCSTR)(lpStream+trknameofs), MAX_CHANNELNAME);
+- }
+- }
+- }
+- }
+- }
+- // Reading samples
+- if (dwSmplArr > dwMemLength - 4*m_nSamples) return TRUE;
+- pdwTable = (LPDWORD)(lpStream + dwSmplArr);
+- for (UINT iSmp=0; iSmp<m_nSamples; iSmp++) if (pdwTable[iSmp])
+- {
+- UINT dwPos = bswapBE32(pdwTable[iSmp]);
+- if ((dwPos >= dwMemLength) || (dwPos + sizeof(MMDSAMPLEHEADER) >= dwMemLength)) continue;
+- MMDSAMPLEHEADER *psdh = (MMDSAMPLEHEADER *)(lpStream + dwPos);
+- UINT len = bswapBE32(psdh->length);
+- #ifdef MED_LOG
+- Log("SampleData %d: stype=0x%02X len=%d\n", iSmp, bswapBE16(psdh->type), len);
+- #endif
+- if ((len > MAX_SAMPLE_LENGTH) || (dwPos + len + 6 > dwMemLength)) len = 0;
+- UINT flags = RS_PCM8S, stype = bswapBE16(psdh->type);
+- LPSTR psdata = (LPSTR)(lpStream + dwPos + 6);
+- if (stype & 0x80)
+- {
+- psdata += (stype & 0x20) ? 14 : 6;
+- } else
+- {
+- if (stype & 0x10)
+- {
+- Ins[iSmp+1].uFlags |= CHN_16BIT;
+- len /= 2;
+- flags = (stype & 0x20) ? RS_STPCM16M : RS_PCM16M;
+- } else
+- {
+- flags = (stype & 0x20) ? RS_STPCM8S : RS_PCM8S;
+- }
+- if (stype & 0x20) len /= 2;
+- }
+- Ins[iSmp+1].nLength = len;
+- ReadSample(&Ins[iSmp+1], flags, psdata, dwMemLength - dwPos - 6);
+- }
+- // Reading patterns (blocks)
+- if (wNumBlocks > MAX_PATTERNS) wNumBlocks = MAX_PATTERNS;
+- if ((!dwBlockArr) || (dwBlockArr > dwMemLength - 4*wNumBlocks)) return TRUE;
+- pdwTable = (LPDWORD)(lpStream + dwBlockArr);
+- playtransp += (version == '3') ? 24 : 48;
+- for (UINT iBlk=0; iBlk<wNumBlocks; iBlk++)
+- {
+- UINT dwPos = bswapBE32(pdwTable[iBlk]);
+- if ((!dwPos) || (dwPos >= dwMemLength) || (dwPos >= dwMemLength - 8)) continue;
+- UINT lines = 64, tracks = 4;
+- if (version == '0')
+- {
+- const MMD0BLOCK *pmb = (const MMD0BLOCK *)(lpStream + dwPos);
+- lines = pmb->lines + 1;
+- tracks = pmb->numtracks;
+- if (!tracks) tracks = m_nChannels;
+- if ((Patterns[iBlk] = AllocatePattern(lines, m_nChannels)) == NULL) continue;
+- PatternSize[iBlk] = lines;
+- PatternAllocSize[iBlk] = lines;
+- MODCOMMAND *p = Patterns[iBlk];
+- LPBYTE s = (LPBYTE)(lpStream + dwPos + 2);
+- UINT maxlen = tracks*lines*3;
+- if (maxlen + dwPos > dwMemLength - 2) break;
+- for (UINT y=0; y<lines; y++)
+- {
+- for (UINT x=0; x<tracks; x++, s+=3) if (x < m_nChannels)
+- {
+- BYTE note = s[0] & 0x3F;
+- BYTE instr = s[1] >> 4;
+- if (s[0] & 0x80) instr |= 0x10;
+- if (s[0] & 0x40) instr |= 0x20;
+- if ((note) && (note <= 132)) p->note = note + playtransp;
+- p->instr = instr;
+- p->command = s[1] & 0x0F;
+- p->param = s[2];
+- // if (!iBlk) Log("%02X.%02X.%02X | ", s[0], s[1], s[2]);
+- MedConvert(p, pmsh);
+- p++;
+- }
+- //if (!iBlk) Log("\n");
+- }
+- } else
+- {
+- MMD1BLOCK *pmb = (MMD1BLOCK *)(lpStream + dwPos);
+- #ifdef MED_LOG
+- Log("MMD1BLOCK: lines=%2d, tracks=%2d, offset=0x%04X\n",
+- bswapBE16(pmb->lines), bswapBE16(pmb->numtracks), bswapBE32(pmb->info));
+- #endif
+- MMD1BLOCKINFO *pbi = NULL;
+- BYTE *pcmdext = NULL;
+- lines = (pmb->lines >> 8) + 1;
+- tracks = pmb->numtracks >> 8;
+- if (!tracks) tracks = m_nChannels;
+- if ((Patterns[iBlk] = AllocatePattern(lines, m_nChannels)) == NULL) continue;
+- PatternSize[iBlk] = (WORD)lines;
+- PatternAllocSize[iBlk] = (WORD)lines;
+- DWORD dwBlockInfo = bswapBE32(pmb->info);
+- if ((dwBlockInfo) && (dwBlockInfo < dwMemLength - sizeof(MMD1BLOCKINFO)))
+- {
+- pbi = (MMD1BLOCKINFO *)(lpStream + dwBlockInfo);
+- #ifdef MED_LOG
+- Log(" BLOCKINFO: blockname=0x%04X namelen=%d pagetable=0x%04X &cmdexttable=0x%04X\n",
+- bswapBE32(pbi->blockname), bswapBE32(pbi->blocknamelen), bswapBE32(pbi->pagetable), bswapBE32(pbi->cmdexttable));
+- #endif
+- if ((pbi->blockname) && (pbi->blocknamelen))
+- {
+- DWORD nameofs = bswapBE32(pbi->blockname);
+- UINT namelen = bswapBE32(pbi->blocknamelen);
+- if ((nameofs < dwMemLength) && (nameofs+namelen < dwMemLength))
+- {
+- SetPatternName(iBlk, (LPCSTR)(lpStream+nameofs));
+- }
+- }
+- if (pbi->cmdexttable)
+- {
+- DWORD cmdexttable = bswapBE32(pbi->cmdexttable);
+- if (cmdexttable < dwMemLength - 4)
+- {
+- cmdexttable = bswapBE32(*(DWORD *)(lpStream + cmdexttable));
+- if ((cmdexttable) && (cmdexttable <= dwMemLength - lines*tracks))
+- {
+- pcmdext = (BYTE *)(lpStream + cmdexttable);
+- }
+- }
+- }
+- }
+- MODCOMMAND *p = Patterns[iBlk];
+- LPBYTE s = (LPBYTE)(lpStream + dwPos + 8);
+- UINT maxlen = tracks*lines*4;
+- if (maxlen + dwPos > dwMemLength - 8) break;
+- for (UINT y=0; y<lines; y++)
+- {
+- for (UINT x=0; x<tracks; x++, s+=4) if (x < m_nChannels)
+- {
+- BYTE note = s[0];
+- if ((note) && (note <= 132))
+- {
+- int rnote = note + playtransp;
+- if (rnote < 1) rnote = 1;
+- if (rnote > 120) rnote = 120;
+- p->note = (BYTE)rnote;
+- }
+- p->instr = s[1];
+- p->command = s[2];
+- p->param = s[3];
+- if (pcmdext) p->vol = pcmdext[x];
+- MedConvert(p, pmsh);
+- p++;
+- }
+- if (pcmdext) pcmdext += tracks;
+- }
+- }
+- }
+- // Setup channel pan positions
+- for (UINT iCh=0; iCh<m_nChannels; iCh++)
+- {
+- ChnSettings[iCh].nPan = (((iCh&3) == 1) || ((iCh&3) == 2)) ? 0xC0 : 0x40;
+- ChnSettings[iCh].nVolume = 64;
+- }
+- return TRUE;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_mod.cxx audacious-plugins-2.5.4/src/modplug/load_mod.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_mod.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_mod.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,358 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-extern WORD ProTrackerPeriodTable[6*12];
+-
+-//////////////////////////////////////////////////////////
+-// ProTracker / NoiseTracker MOD/NST file support
+-
+-void CSoundFile::ConvertModCommand(MODCOMMAND *m) const
+-//-----------------------------------------------------
+-{
+- UINT command = m->command, param = m->param;
+-
+- switch(command)
+- {
+- case 0x00: if (param) command = CMD_ARPEGGIO; break;
+- case 0x01: command = CMD_PORTAMENTOUP; break;
+- case 0x02: command = CMD_PORTAMENTODOWN; break;
+- case 0x03: command = CMD_TONEPORTAMENTO; break;
+- case 0x04: command = CMD_VIBRATO; break;
+- case 0x05: command = CMD_TONEPORTAVOL; if (param & 0xF0) param &= 0xF0; break;
+- case 0x06: command = CMD_VIBRATOVOL; if (param & 0xF0) param &= 0xF0; break;
+- case 0x07: command = CMD_TREMOLO; break;
+- case 0x08: command = CMD_PANNING8; break;
+- case 0x09: command = CMD_OFFSET; break;
+- case 0x0A: command = CMD_VOLUMESLIDE; if (param & 0xF0) param &= 0xF0; break;
+- case 0x0B: command = CMD_POSITIONJUMP; break;
+- case 0x0C: command = CMD_VOLUME; break;
+- case 0x0D: command = CMD_PATTERNBREAK; param = ((param >> 4) * 10) + (param & 0x0F); break;
+- case 0x0E: command = CMD_MODCMDEX; break;
+- case 0x0F: command = (param <= (UINT)((m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? 0x1F : 0x20)) ? CMD_SPEED : CMD_TEMPO;
+- if ((param == 0xFF) && (m_nSamples == 15)) command = 0; break;
+- // Extension for XM extended effects
+- case 'G' - 55: command = CMD_GLOBALVOLUME; break;
+- case 'H' - 55: command = CMD_GLOBALVOLSLIDE; if (param & 0xF0) param &= 0xF0; break;
+- case 'K' - 55: command = CMD_KEYOFF; break;
+- case 'L' - 55: command = CMD_SETENVPOSITION; break;
+- case 'M' - 55: command = CMD_CHANNELVOLUME; break;
+- case 'N' - 55: command = CMD_CHANNELVOLSLIDE; break;
+- case 'P' - 55: command = CMD_PANNINGSLIDE; if (param & 0xF0) param &= 0xF0; break;
+- case 'R' - 55: command = CMD_RETRIG; break;
+- case 'T' - 55: command = CMD_TREMOR; break;
+- case 'X' - 55: command = CMD_XFINEPORTAUPDOWN; break;
+- case 'Y' - 55: command = CMD_PANBRELLO; break;
+- case 'Z' - 55: command = CMD_MIDI; break;
+- default: command = 0;
+- }
+- m->command = command;
+- m->param = param;
+-}
+-
+-
+-WORD CSoundFile::ModSaveCommand(const MODCOMMAND *m, BOOL bXM) const
+-//------------------------------------------------------------------
+-{
+- UINT command = m->command & 0x3F, param = m->param;
+-
+- switch(command)
+- {
+- case 0: command = param = 0; break;
+- case CMD_ARPEGGIO: command = 0; break;
+- case CMD_PORTAMENTOUP:
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM))
+- {
+- if ((param & 0xF0) == 0xE0) { command=0x0E; param=((param & 0x0F) >> 2)|0x10; break; }
+- else if ((param & 0xF0) == 0xF0) { command=0x0E; param &= 0x0F; param|=0x10; break; }
+- }
+- command = 0x01;
+- break;
+- case CMD_PORTAMENTODOWN:
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM))
+- {
+- if ((param & 0xF0) == 0xE0) { command=0x0E; param=((param & 0x0F) >> 2)|0x20; break; }
+- else if ((param & 0xF0) == 0xF0) { command=0x0E; param &= 0x0F; param|=0x20; break; }
+- }
+- command = 0x02;
+- break;
+- case CMD_TONEPORTAMENTO: command = 0x03; break;
+- case CMD_VIBRATO: command = 0x04; break;
+- case CMD_TONEPORTAVOL: command = 0x05; break;
+- case CMD_VIBRATOVOL: command = 0x06; break;
+- case CMD_TREMOLO: command = 0x07; break;
+- case CMD_PANNING8:
+- command = 0x08;
+- if (bXM)
+- {
+- if ((m_nType != MOD_TYPE_IT) && (m_nType != MOD_TYPE_XM) && (param <= 0x80))
+- {
+- param <<= 1;
+- if (param > 255) param = 255;
+- }
+- } else
+- {
+- if ((m_nType == MOD_TYPE_IT) || (m_nType == MOD_TYPE_XM)) param >>= 1;
+- }
+- break;
+- case CMD_OFFSET: command = 0x09; break;
+- case CMD_VOLUMESLIDE: command = 0x0A; break;
+- case CMD_POSITIONJUMP: command = 0x0B; break;
+- case CMD_VOLUME: command = 0x0C; break;
+- case CMD_PATTERNBREAK: command = 0x0D; param = ((param / 10) << 4) | (param % 10); break;
+- case CMD_MODCMDEX: command = 0x0E; break;
+- case CMD_SPEED: command = 0x0F; if (param > 0x20) param = 0x20; break;
+- case CMD_TEMPO: if (param > 0x20) { command = 0x0F; break; } return 0;
+- case CMD_GLOBALVOLUME: command = 'G' - 55; break;
+- case CMD_GLOBALVOLSLIDE: command = 'H' - 55; break;
+- case CMD_KEYOFF: command = 'K' - 55; break;
+- case CMD_SETENVPOSITION: command = 'L' - 55; break;
+- case CMD_CHANNELVOLUME: command = 'M' - 55; break;
+- case CMD_CHANNELVOLSLIDE: command = 'N' - 55; break;
+- case CMD_PANNINGSLIDE: command = 'P' - 55; break;
+- case CMD_RETRIG: command = 'R' - 55; break;
+- case CMD_TREMOR: command = 'T' - 55; break;
+- case CMD_XFINEPORTAUPDOWN: command = 'X' - 55; break;
+- case CMD_PANBRELLO: command = 'Y' - 55; break;
+- case CMD_MIDI: command = 'Z' - 55; break;
+- case CMD_S3MCMDEX:
+- switch(param & 0xF0)
+- {
+- case 0x10: command = 0x0E; param = (param & 0x0F) | 0x30; break;
+- case 0x20: command = 0x0E; param = (param & 0x0F) | 0x50; break;
+- case 0x30: command = 0x0E; param = (param & 0x0F) | 0x40; break;
+- case 0x40: command = 0x0E; param = (param & 0x0F) | 0x70; break;
+- case 0x90: command = 'X' - 55; break;
+- case 0xB0: command = 0x0E; param = (param & 0x0F) | 0x60; break;
+- case 0xA0:
+- case 0x50:
+- case 0x70:
+- case 0x60: command = param = 0; break;
+- default: command = 0x0E; break;
+- }
+- break;
+- default: command = param = 0;
+- }
+- return (WORD)((command << 8) | (param));
+-}
+-
+-
+-#pragma pack(1)
+-
+-typedef struct _MODSAMPLE
+-{
+- CHAR name[22];
+- WORD length;
+- BYTE finetune;
+- BYTE volume;
+- WORD loopstart;
+- WORD looplen;
+-} MODSAMPLE, *PMODSAMPLE;
+-
+-typedef struct _MODMAGIC
+-{
+- BYTE nOrders;
+- BYTE nRestartPos;
+- BYTE Orders[128];
+- char Magic[4]; // changed from CHAR
+-} MODMAGIC, *PMODMAGIC;
+-
+-#pragma pack()
+-
+-BOOL IsMagic(LPCSTR s1, LPCSTR s2)
+-{
+- return ((*(DWORD *)s1) == (*(DWORD *)s2)) ? TRUE : FALSE;
+-}
+-
+-
+-BOOL CSoundFile::ReadMod(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- char s[1024]; // changed from CHAR
+- DWORD dwMemPos, dwTotalSampleLen;
+- PMODMAGIC pMagic;
+- UINT nErr;
+-
+- if ((!lpStream) || (dwMemLength < 0x600)) return FALSE;
+- dwMemPos = 20;
+- m_nSamples = 31;
+- m_nChannels = 4;
+- pMagic = (PMODMAGIC)(lpStream+dwMemPos+sizeof(MODSAMPLE)*31);
+- // Check Mod Magic
+- memcpy(s, pMagic->Magic, 4);
+- if ((IsMagic(s, "M.K.")) || (IsMagic(s, "M!K!"))
+- || (IsMagic(s, "M&K!")) || (IsMagic(s, "N.T."))) m_nChannels = 4; else
+- if ((IsMagic(s, "CD81")) || (IsMagic(s, "OKTA"))) m_nChannels = 8; else
+- if ((s[0]=='F') && (s[1]=='L') && (s[2]=='T') && (s[3]>='4') && (s[3]<='9')) m_nChannels = s[3] - '0'; else
+- if ((s[0]>='4') && (s[0]<='9') && (s[1]=='C') && (s[2]=='H') && (s[3]=='N')) m_nChannels = s[0] - '0'; else
+- if ((s[0]=='1') && (s[1]>='0') && (s[1]<='9') && (s[2]=='C') && (s[3]=='H')) m_nChannels = s[1] - '0' + 10; else
+- if ((s[0]=='2') && (s[1]>='0') && (s[1]<='9') && (s[2]=='C') && (s[3]=='H')) m_nChannels = s[1] - '0' + 20; else
+- if ((s[0]=='3') && (s[1]>='0') && (s[1]<='2') && (s[2]=='C') && (s[3]=='H')) m_nChannels = s[1] - '0' + 30; else
+- if ((s[0]=='T') && (s[1]=='D') && (s[2]=='Z') && (s[3]>='4') && (s[3]<='9')) m_nChannels = s[3] - '0'; else
+- if (IsMagic(s,"16CN")) m_nChannels = 16; else
+- if (IsMagic(s,"32CN")) m_nChannels = 32; else m_nSamples = 15;
+- // Load Samples
+- nErr = 0;
+- dwTotalSampleLen = 0;
+- for (UINT i=1; i<=m_nSamples; i++)
+- {
+- PMODSAMPLE pms = (PMODSAMPLE)(lpStream+dwMemPos);
+- MODINSTRUMENT *psmp = &Ins[i];
+- UINT loopstart, looplen;
+-
+- memcpy(m_szNames[i], pms->name, 22);
+- m_szNames[i][22] = 0;
+- psmp->uFlags = 0;
+- psmp->nLength = bswapBE16(pms->length)*2;
+- dwTotalSampleLen += psmp->nLength;
+- psmp->nFineTune = MOD2XMFineTune(pms->finetune & 0x0F);
+- psmp->nVolume = 4*pms->volume;
+- if (psmp->nVolume > 256) { psmp->nVolume = 256; nErr++; }
+- psmp->nGlobalVol = 64;
+- psmp->nPan = 128;
+- loopstart = bswapBE16(pms->loopstart)*2;
+- looplen = bswapBE16(pms->looplen)*2;
+- // Fix loops
+- if ((looplen > 2) && (loopstart+looplen > psmp->nLength)
+- && (loopstart/2+looplen <= psmp->nLength))
+- {
+- loopstart /= 2;
+- }
+- psmp->nLoopStart = loopstart;
+- psmp->nLoopEnd = loopstart + looplen;
+- if (psmp->nLength < 2) psmp->nLength = 0;
+- if (psmp->nLength)
+- {
+- UINT derr = 0;
+- if (psmp->nLoopStart >= psmp->nLength) { psmp->nLoopStart = psmp->nLength-1; derr|=1; }
+- if (psmp->nLoopEnd > psmp->nLength) { psmp->nLoopEnd = psmp->nLength; derr |= 1; }
+- if (psmp->nLoopStart > psmp->nLoopEnd) derr |= 1;
+- if (psmp->nLoopEnd > psmp->nLoopStart)
+- {
+- psmp->uFlags |= CHN_LOOP;
+- }
+- }
+- dwMemPos += sizeof(MODSAMPLE);
+- }
+- if ((m_nSamples == 15) && (dwTotalSampleLen > dwMemLength * 4)) return FALSE;
+- pMagic = (PMODMAGIC)(lpStream+dwMemPos);
+- dwMemPos += sizeof(MODMAGIC);
+- if (m_nSamples == 15) dwMemPos -= 4;
+- memset(Order, 0,sizeof(Order));
+- memcpy(Order, pMagic->Orders, 128);
+-
+- UINT nbp, nbpbuggy, nbpbuggy2, norders;
+-
+- norders = pMagic->nOrders;
+- if ((!norders) || (norders > 0x80))
+- {
+- norders = 0x80;
+- while ((norders > 1) && (!Order[norders-1])) norders--;
+- }
+- nbpbuggy = 0;
+- nbpbuggy2 = 0;
+- nbp = 0;
+- for (UINT iord=0; iord<128; iord++)
+- {
+- UINT i = Order[iord];
+- if ((i < 0x80) && (nbp <= i))
+- {
+- nbp = i+1;
+- if (iord<norders) nbpbuggy = nbp;
+- }
+- if (i >= nbpbuggy2) nbpbuggy2 = i+1;
+- }
+- for (UINT iend=norders; iend<MAX_ORDERS; iend++) Order[iend] = 0xFF;
+- norders--;
+- m_nRestartPos = pMagic->nRestartPos;
+- if (m_nRestartPos >= 0x78) m_nRestartPos = 0;
+- if (m_nRestartPos + 1 >= (UINT)norders) m_nRestartPos = 0;
+- if (!nbp) return FALSE;
+- DWORD dwWowTest = dwTotalSampleLen+dwMemPos;
+- if ((IsMagic(pMagic->Magic, "M.K.")) && (dwWowTest + nbp*8*256 == dwMemLength)) m_nChannels = 8;
+- if ((nbp != nbpbuggy) && (dwWowTest + nbp*m_nChannels*256 != dwMemLength))
+- {
+- if (dwWowTest + nbpbuggy*m_nChannels*256 == dwMemLength) nbp = nbpbuggy;
+- else nErr += 8;
+- } else
+- if ((nbpbuggy2 > nbp) && (dwWowTest + nbpbuggy2*m_nChannels*256 == dwMemLength))
+- {
+- nbp = nbpbuggy2;
+- }
+- if ((dwWowTest < 0x600) || (dwWowTest > dwMemLength)) nErr += 8;
+- if ((m_nSamples == 15) && (nErr >= 16)) return FALSE;
+- // Default settings
+- m_nType = MOD_TYPE_MOD;
+- m_nDefaultSpeed = 6;
+- m_nDefaultTempo = 125;
+- m_nMinPeriod = 14 << 2;
+- m_nMaxPeriod = 3424 << 2;
+- memcpy(m_szNames, lpStream, 20);
+- // Setting channels pan
+- for (UINT ich=0; ich<m_nChannels; ich++)
+- {
+- ChnSettings[ich].nVolume = 64;
+- ChnSettings[ich].nPan = (((ich&3)==1) || ((ich&3)==2)) ? 256 : 0;
+- }
+- m_nStereoSeparation = (gdwSoundSetup & SNDMIX_MAXDEFAULTPAN) ? 128 : 64;
+-
+- // Reading channels
+- for (UINT ipat=0; ipat<nbp; ipat++)
+- {
+- if (ipat < MAX_PATTERNS)
+- {
+- if ((Patterns[ipat] = AllocatePattern(64, m_nChannels)) == NULL) break;
+- PatternSize[ipat] = 64;
+- PatternAllocSize[ipat] = 64;
+- if (dwMemPos + m_nChannels*256 >= dwMemLength) break;
+- MODCOMMAND *m = Patterns[ipat];
+- LPCBYTE p = lpStream + dwMemPos;
+- for (UINT j=m_nChannels*64; j; m++,p+=4,j--)
+- {
+- BYTE A0=p[0], A1=p[1], A2=p[2], A3=p[3];
+- UINT n = ((((UINT)A0 & 0x0F) << 8) | (A1));
+- if ((n) && (n != 0xFFF)) m->note = GetNoteFromPeriod(n << 2);
+- m->instr = ((UINT)A2 >> 4) | (A0 & 0x10);
+- m->command = A2 & 0x0F;
+- m->param = A3;
+- if ((m->command) || (m->param)) ConvertModCommand(m);
+- }
+- }
+- dwMemPos += m_nChannels*256;
+- }
+- // Reading instruments
+- DWORD dwErrCheck = 0;
+- for (UINT ismp=1; ismp<=m_nSamples; ismp++) if (Ins[ismp].nLength)
+- {
+- LPSTR p = (LPSTR)(lpStream+dwMemPos);
+- UINT flags = 0;
+- if (dwMemPos + 5 >= dwMemLength) break;
+- if (!strnicmp(p, "ADPCM", 5))
+- {
+- flags = 3;
+- p += 5;
+- dwMemPos += 5;
+- }
+- DWORD dwSize = ReadSample(&Ins[ismp], flags, p, dwMemLength - dwMemPos);
+- if (dwSize)
+- {
+- dwMemPos += dwSize;
+- dwErrCheck++;
+- }
+- }
+-#ifdef MODPLUG_TRACKER
+- return TRUE;
+-#else
+- return (dwErrCheck) ? TRUE : FALSE;
+-#endif
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_mt2.cxx audacious-plugins-2.5.4/src/modplug/load_mt2.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_mt2.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_mt2.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,637 +0,0 @@
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#define MT2DEBUG
+-
+-#pragma pack(1)
+-
+-typedef struct _MT2FILEHEADER
+-{
+- DWORD dwMT20; // 0x3032544D "MT20"
+- DWORD dwSpecial;
+- WORD wVersion;
+- CHAR szTrackerName[32]; // "MadTracker 2.0"
+- CHAR szSongName[64];
+- WORD nOrders;
+- WORD wRestart;
+- WORD wPatterns;
+- WORD wChannels;
+- WORD wSamplesPerTick;
+- BYTE bTicksPerLine;
+- BYTE bLinesPerBeat;
+- DWORD fulFlags; // b0=packed patterns
+- WORD wInstruments;
+- WORD wSamples;
+- BYTE Orders[256];
+-} MT2FILEHEADER;
+-
+-typedef struct _MT2PATTERN
+-{
+- WORD wLines;
+- DWORD wDataLen;
+-} MT2PATTERN;
+-
+-typedef struct _MT2COMMAND
+-{
+- BYTE note; // 0=nothing, 97=note off
+- BYTE instr;
+- BYTE vol;
+- BYTE pan;
+- BYTE fxcmd;
+- BYTE fxparam1;
+- BYTE fxparam2;
+-} MT2COMMAND;
+-
+-typedef struct _MT2DRUMSDATA
+-{
+- WORD wDrumPatterns;
+- WORD wDrumSamples[8];
+- BYTE DrumPatternOrder[256];
+-} MT2DRUMSDATA;
+-
+-typedef struct _MT2AUTOMATION
+-{
+- DWORD dwFlags;
+- DWORD dwEffectId;
+- DWORD nEnvPoints;
+-} MT2AUTOMATION;
+-
+-typedef struct _MT2INSTRUMENT
+-{
+- CHAR szName[32];
+- DWORD dwDataLen;
+- WORD wSamples;
+- BYTE GroupsMapping[96];
+- BYTE bVibType;
+- BYTE bVibSweep;
+- BYTE bVibDepth;
+- BYTE bVibRate;
+- WORD wFadeOut;
+- WORD wNNA;
+- WORD wInstrFlags;
+- WORD wEnvFlags1;
+- WORD wEnvFlags2;
+-} MT2INSTRUMENT;
+-
+-typedef struct _MT2ENVELOPE
+-{
+- BYTE nFlags;
+- BYTE nPoints;
+- BYTE nSustainPos;
+- BYTE nLoopStart;
+- BYTE nLoopEnd;
+- BYTE bReserved[3];
+- BYTE EnvData[64];
+-} MT2ENVELOPE;
+-
+-typedef struct _MT2SYNTH
+-{
+- BYTE nSynthId;
+- BYTE nFxId;
+- WORD wCutOff;
+- BYTE nResonance;
+- BYTE nAttack;
+- BYTE nDecay;
+- BYTE bReserved[25];
+-} MT2SYNTH;
+-
+-typedef struct _MT2SAMPLE
+-{
+- CHAR szName[32];
+- DWORD dwDataLen;
+- DWORD dwLength;
+- DWORD dwFrequency;
+- BYTE nQuality;
+- BYTE nChannels;
+- BYTE nFlags;
+- BYTE nLoop;
+- DWORD dwLoopStart;
+- DWORD dwLoopEnd;
+- WORD wVolume;
+- BYTE nPan;
+- BYTE nBaseNote;
+- WORD wSamplesPerBeat;
+-} MT2SAMPLE;
+-
+-typedef struct _MT2GROUP
+-{
+- BYTE nSmpNo;
+- BYTE nVolume; // 0-128
+- BYTE nFinePitch;
+- BYTE Reserved[5];
+-} MT2GROUP;
+-
+-#pragma pack()
+-
+-
+-static VOID ConvertMT2Command(CSoundFile *that, MODCOMMAND *m, MT2COMMAND *p)
+-//---------------------------------------------------------------------------
+-{
+- // Note
+- m->note = 0;
+- if (p->note) m->note = (p->note > 96) ? 0xFF : p->note+12;
+- // Instrument
+- m->instr = p->instr;
+- // Volume Column
+- if ((p->vol >= 0x10) && (p->vol <= 0x90))
+- {
+- m->volcmd = VOLCMD_VOLUME;
+- m->vol = (p->vol - 0x10) >> 1;
+- } else
+- if ((p->vol >= 0xA0) && (p->vol <= 0xAF))
+- {
+- m->volcmd = VOLCMD_VOLSLIDEDOWN;
+- m->vol = (p->vol & 0x0f);
+- } else
+- if ((p->vol >= 0xB0) && (p->vol <= 0xBF))
+- {
+- m->volcmd = VOLCMD_VOLSLIDEUP;
+- m->vol = (p->vol & 0x0f);
+- } else
+- if ((p->vol >= 0xC0) && (p->vol <= 0xCF))
+- {
+- m->volcmd = VOLCMD_FINEVOLDOWN;
+- m->vol = (p->vol & 0x0f);
+- } else
+- if ((p->vol >= 0xD0) && (p->vol <= 0xDF))
+- {
+- m->volcmd = VOLCMD_FINEVOLUP;
+- m->vol = (p->vol & 0x0f);
+- } else
+- {
+- m->volcmd = 0;
+- m->vol = 0;
+- }
+- // Effects
+- m->command = 0;
+- m->param = 0;
+- if ((p->fxcmd) || (p->fxparam1) || (p->fxparam2))
+- {
+- if (!p->fxcmd)
+- {
+- m->command = p->fxparam2;
+- m->param = p->fxparam1;
+- that->ConvertModCommand(m);
+- } else
+- {
+- // TODO: MT2 Effects
+- }
+- }
+-}
+-
+-
+-BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- MT2FILEHEADER *pfh = (MT2FILEHEADER *)lpStream;
+- DWORD dwMemPos, dwDrumDataPos, dwExtraDataPos;
+- UINT nDrumDataLen, nExtraDataLen;
+- MT2DRUMSDATA *pdd;
+- MT2INSTRUMENT *InstrMap[255];
+- MT2SAMPLE *SampleMap[256];
+-
+- if ((!lpStream) || (dwMemLength < sizeof(MT2FILEHEADER))
+- || (pfh->dwMT20 != 0x3032544D)
+- || (pfh->wVersion < 0x0200) || (pfh->wVersion >= 0x0300)
+- || (pfh->wChannels < 4) || (pfh->wChannels > 64)) return FALSE;
+- pdd = NULL;
+- m_nType = MOD_TYPE_MT2;
+- m_nChannels = pfh->wChannels;
+- m_nRestartPos = pfh->wRestart;
+- m_nDefaultSpeed = pfh->bTicksPerLine;
+- m_nDefaultTempo = 125;
+- if ((pfh->wSamplesPerTick > 100) && (pfh->wSamplesPerTick < 5000))
+- {
+- m_nDefaultTempo = 110250 / pfh->wSamplesPerTick;
+- }
+- for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+- {
+- Order[iOrd] = (BYTE)((iOrd < pfh->nOrders) ? pfh->Orders[iOrd] : 0xFF);
+- }
+- memcpy(m_szNames[0], pfh->szSongName, 32);
+- m_szNames[0][31] = 0;
+- dwMemPos = sizeof(MT2FILEHEADER);
+- nDrumDataLen = *(WORD *)(lpStream + dwMemPos);
+- dwDrumDataPos = dwMemPos + 2;
+- if (nDrumDataLen >= 2) pdd = (MT2DRUMSDATA *)(lpStream+dwDrumDataPos);
+- dwMemPos += 2 + nDrumDataLen;
+-#ifdef MT2DEBUG
+-
+- Log("MT2 v%03X: \"%s\" (flags=%04X)\n", pfh->wVersion, m_szNames[0], pfh->fulFlags);
+- Log("%d Channels, %d Patterns, %d Instruments, %d Samples\n", pfh->wChannels, pfh->wPatterns, pfh->wInstruments, pfh->wSamples);
+- Log("Drum Data: %d bytes @%04X\n", nDrumDataLen, dwDrumDataPos);
+-#endif
+- if (dwMemPos >= dwMemLength-12) return TRUE;
+- if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
+- if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
+- nExtraDataLen = *(DWORD *)(lpStream+dwMemPos);
+- dwExtraDataPos = dwMemPos + 4;
+- dwMemPos += 4;
+-#ifdef MT2DEBUG
+- Log("Extra Data: %d bytes @%04X\n", nExtraDataLen, dwExtraDataPos);
+-#endif
+- if (dwMemPos + nExtraDataLen >= dwMemLength) return TRUE;
+- while (dwMemPos+8 < dwExtraDataPos + nExtraDataLen)
+- {
+- DWORD dwId = *(DWORD *)(lpStream+dwMemPos);
+- DWORD dwLen = *(DWORD *)(lpStream+dwMemPos+4);
+- dwMemPos += 8;
+- if (dwMemPos + dwLen > dwMemLength) return TRUE;
+-#ifdef MT2DEBUG
+- CHAR s[5];
+- memcpy(s, &dwId, 4);
+- s[4] = 0;
+- Log("pos=0x%04X: %s: %d bytes\n", dwMemPos-8, s, dwLen);
+-#endif
+- switch(dwId)
+- {
+- // MSG
+- case 0x0047534D:
+- if ((dwLen > 3) && (!m_lpszSongComments))
+- {
+- DWORD nTxtLen = dwLen;
+- if (nTxtLen > 32000) nTxtLen = 32000;
+- m_lpszSongComments = new char[nTxtLen]; // changed from CHAR
+- if (m_lpszSongComments)
+- {
+- memcpy(m_lpszSongComments, lpStream+dwMemPos+1, nTxtLen-1);
+- m_lpszSongComments[nTxtLen-1] = 0;
+- }
+- }
+- break;
+- // SUM -> author name (or "Unregistered")
+- // TMAP
+- // TRKS
+- case 0x534b5254:
+- break;
+- }
+- dwMemPos += dwLen;
+- }
+- // Load Patterns
+- dwMemPos = dwExtraDataPos + nExtraDataLen;
+- for (UINT iPat=0; iPat<pfh->wPatterns; iPat++) if (dwMemPos < dwMemLength-6)
+- {
+- MT2PATTERN *pmp = (MT2PATTERN *)(lpStream+dwMemPos);
+- UINT wDataLen = (pmp->wDataLen + 1) & ~1;
+- dwMemPos += 6;
+- if (dwMemPos + wDataLen > dwMemLength) break;
+- UINT nLines = pmp->wLines;
+- if ((iPat < MAX_PATTERNS) && (nLines > 0) && (nLines <= 256))
+- {
+- #ifdef MT2DEBUG
+- Log("Pattern #%d @%04X: %d lines, %d bytes\n", iPat, dwMemPos-6, nLines, pmp->wDataLen);
+- #endif
+- PatternSize[iPat] = nLines;
+- PatternAllocSize[iPat] = nLines;
+- Patterns[iPat] = AllocatePattern(nLines, m_nChannels);
+- if (!Patterns[iPat]) return TRUE;
+- MODCOMMAND *m = Patterns[iPat];
+- UINT len = wDataLen;
+- if (pfh->fulFlags & 1) // Packed Patterns
+- {
+- BYTE *p = (BYTE *)(lpStream+dwMemPos);
+- UINT pos = 0, row=0, ch=0;
+- while (pos < len)
+- {
+- MT2COMMAND cmd;
+- UINT infobyte = p[pos++];
+- UINT rptcount = 0;
+- if (infobyte == 0xff)
+- {
+- rptcount = p[pos++];
+- infobyte = p[pos++];
+- #if 0
+- Log("(%d.%d) FF(%02X).%02X\n", row, ch, rptcount, infobyte);
+- } else
+- {
+- Log("(%d.%d) %02X\n", row, ch, infobyte);
+- #endif
+- }
+- if (infobyte & 0x7f)
+- {
+- UINT patpos = row*m_nChannels+ch;
+- cmd.note = cmd.instr = cmd.vol = cmd.pan = cmd.fxcmd = cmd.fxparam1 = cmd.fxparam2 = 0;
+- if (infobyte & 1) cmd.note = p[pos++];
+- if (infobyte & 2) cmd.instr = p[pos++];
+- if (infobyte & 4) cmd.vol = p[pos++];
+- if (infobyte & 8) cmd.pan = p[pos++];
+- if (infobyte & 16) cmd.fxcmd = p[pos++];
+- if (infobyte & 32) cmd.fxparam1 = p[pos++];
+- if (infobyte & 64) cmd.fxparam2 = p[pos++];
+- #ifdef MT2DEBUG
+- if (cmd.fxcmd)
+- {
+- Log("(%d.%d) MT2 FX=%02X.%02X.%02X\n", row, ch, cmd.fxcmd, cmd.fxparam1, cmd.fxparam2);
+- }
+- #endif
+- ConvertMT2Command(this, &m[patpos], &cmd);
+- }
+- row += rptcount+1;
+- while (row >= nLines) { row-=nLines; ch++; }
+- if (ch >= m_nChannels) break;
+- }
+- } else
+- {
+- MT2COMMAND *p = (MT2COMMAND *)(lpStream+dwMemPos);
+- UINT n = 0;
+- while ((len > sizeof(MT2COMMAND)) && (n < m_nChannels*nLines))
+- {
+- ConvertMT2Command(this, m, p);
+- len -= sizeof(MT2COMMAND);
+- n++;
+- p++;
+- m++;
+- }
+- }
+- }
+- dwMemPos += wDataLen;
+- }
+- // Skip Drum Patterns
+- if (pdd)
+- {
+- #ifdef MT2DEBUG
+- Log("%d Drum Patterns at offset 0x%08X\n", pdd->wDrumPatterns, dwMemPos);
+- #endif
+- for (UINT iDrm=0; iDrm<pdd->wDrumPatterns; iDrm++)
+- {
+- if (dwMemPos > dwMemLength-2) return TRUE;
+- UINT nLines = *(WORD *)(lpStream+dwMemPos);
+- #ifdef MT2DEBUG
+- if (nLines != 64) Log("Drum Pattern %d: %d Lines @%04X\n", iDrm, nLines, dwMemPos);
+- #endif
+- dwMemPos += 2 + nLines * 32;
+- }
+- }
+- // Automation
+- if (pfh->fulFlags & 2)
+- {
+- #ifdef MT2DEBUG
+- Log("Automation at offset 0x%08X\n", dwMemPos);
+- #endif
+- UINT nAutoCount = m_nChannels;
+- if (pfh->fulFlags & 0x10) nAutoCount++; // Master Automation
+- if ((pfh->fulFlags & 0x08) && (pdd)) nAutoCount += 8; // Drums Automation
+- nAutoCount *= pfh->wPatterns;
+- for (UINT iAuto=0; iAuto<nAutoCount; iAuto++)
+- {
+- if (dwMemPos+12 >= dwMemLength) return TRUE;
+- MT2AUTOMATION *pma = (MT2AUTOMATION *)(lpStream+dwMemPos);
+- dwMemPos += (pfh->wVersion <= 0x201) ? 4 : 8;
+- for (UINT iEnv=0; iEnv<14; iEnv++)
+- {
+- if (pma->dwFlags & (1 << iEnv))
+- {
+- #ifdef MT2DEBUG
+- UINT nPoints = *(DWORD *)(lpStream+dwMemPos);
+- Log(" Env[%d/%d] %04X @%04X: %d points\n", iAuto, nAutoCount, 1 << iEnv, dwMemPos-8, nPoints);
+- #endif
+- dwMemPos += 260;
+- }
+- }
+- }
+- }
+- // Load Instruments
+-#ifdef MT2DEBUG
+- Log("Loading instruments at offset 0x%08X\n", dwMemPos);
+-#endif
+- memset(InstrMap, 0, sizeof(InstrMap));
+- m_nInstruments = (pfh->wInstruments < MAX_INSTRUMENTS) ? pfh->wInstruments : MAX_INSTRUMENTS-1;
+- m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- for (UINT iIns=1; iIns<=255; iIns++)
+- {
+- if (dwMemPos+36 > dwMemLength) return TRUE;
+- MT2INSTRUMENT *pmi = (MT2INSTRUMENT *)(lpStream+dwMemPos);
+- INSTRUMENTHEADER *penv = NULL;
+- if (iIns <= m_nInstruments)
+- {
+- penv = new INSTRUMENTHEADER;
+- Headers[iIns] = penv;
+- if (penv)
+- {
+- memset(penv, 0, sizeof(INSTRUMENTHEADER));
+- memcpy(penv->name, pmi->szName, 32);
+- penv->nGlobalVol = 128;
+- penv->nPan = 128;
+- for (UINT i=0; i<120; i++)
+- {
+- penv->NoteMap[i] = i+1;
+- }
+- }
+- }
+- #ifdef MT2DEBUG
+- if (iIns <= pfh->wInstruments) Log(" Instrument #%d at offset %04X: %d bytes\n", iIns, dwMemPos, pmi->dwDataLen);
+- #endif
+- if (((LONG)pmi->dwDataLen > 0) && (dwMemPos + pmi->dwDataLen + 40 <= dwMemLength))
+- {
+- InstrMap[iIns-1] = pmi;
+- if (penv)
+- {
+- penv->nFadeOut = pmi->wFadeOut;
+- penv->nNNA = pmi->wNNA & 3;
+- penv->nDCT = (pmi->wNNA>>8) & 3;
+- penv->nDNA = (pmi->wNNA>>12) & 3;
+- MT2ENVELOPE *pehdr[4];
+- WORD *pedata[4];
+- if (pfh->wVersion <= 0x201)
+- {
+- DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT) - 4;
+- pehdr[0] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
+- pehdr[1] = (MT2ENVELOPE *)(lpStream+dwEnvPos+8);
+- pehdr[2] = pehdr[3] = NULL;
+- pedata[0] = (WORD *)(lpStream+dwEnvPos+16);
+- pedata[1] = (WORD *)(lpStream+dwEnvPos+16+64);
+- pedata[2] = pedata[3] = NULL;
+- } else
+- {
+- DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT);
+- for (UINT i=0; i<4; i++)
+- {
+- if (pmi->wEnvFlags1 & (1<<i))
+- {
+- pehdr[i] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
+- pedata[i] = (WORD *)pehdr[i]->EnvData;
+- dwEnvPos += sizeof(MT2ENVELOPE);
+- } else
+- {
+- pehdr[i] = NULL;
+- pedata[i] = NULL;
+- }
+- }
+- }
+- // Load envelopes
+- for (UINT iEnv=0; iEnv<4; iEnv++) if (pehdr[iEnv])
+- {
+- MT2ENVELOPE *pme = pehdr[iEnv];
+- int *pEnvPoints = NULL;
+- BYTE *pEnvData = NULL;
+- #ifdef MT2DEBUG
+- Log(" Env %d.%d @%04X: %d points\n", iIns, iEnv, (UINT)(((BYTE *)pme)-lpStream), pme->nPoints);
+- #endif
+- switch(iEnv)
+- {
+- // Volume Envelope
+- case 0:
+- if (pme->nFlags & 1) penv->dwFlags |= ENV_VOLUME;
+- if (pme->nFlags & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (pme->nFlags & 4) penv->dwFlags |= ENV_VOLLOOP;
+- penv->VolEnv.nNodes = (pme->nPoints > 16) ? 16 : pme->nPoints;
+- penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = pme->nSustainPos;
+- penv->VolEnv.nLoopStart = pme->nLoopStart;
+- penv->VolEnv.nLoopEnd = pme->nLoopEnd;
+- pEnvPoints = penv->VolEnv.Ticks;
+- pEnvData = penv->VolEnv.Values;
+- break;
+-
+- // Panning Envelope
+- case 1:
+- if (pme->nFlags & 1) penv->dwFlags |= ENV_PANNING;
+- if (pme->nFlags & 2) penv->dwFlags |= ENV_PANSUSTAIN;
+- if (pme->nFlags & 4) penv->dwFlags |= ENV_PANLOOP;
+- penv->PanEnv.nNodes = (pme->nPoints > 16) ? 16 : pme->nPoints;
+- penv->PanEnv.nSustainStart = penv->PanEnv.nSustainEnd = pme->nSustainPos;
+- penv->PanEnv.nLoopStart = pme->nLoopStart;
+- penv->PanEnv.nLoopEnd = pme->nLoopEnd;
+- pEnvPoints = penv->PanEnv.Ticks;
+- pEnvData = penv->PanEnv.Values;
+- break;
+-
+- // Pitch/Filter envelope
+- default:
+- if (pme->nFlags & 1) penv->dwFlags |= (iEnv==3) ? (ENV_PITCH|ENV_FILTER) : ENV_PITCH;
+- if (pme->nFlags & 2) penv->dwFlags |= ENV_PITCHSUSTAIN;
+- if (pme->nFlags & 4) penv->dwFlags |= ENV_PITCHLOOP;
+- penv->PitchEnv.nNodes = (pme->nPoints > 16) ? 16 : pme->nPoints;
+- penv->PitchEnv.nSustainStart = penv->PitchEnv.nSustainEnd = pme->nSustainPos;
+- penv->PitchEnv.nLoopStart = pme->nLoopStart;
+- penv->PitchEnv.nLoopEnd = pme->nLoopEnd;
+- pEnvPoints = penv->PitchEnv.Ticks;
+- pEnvData = penv->PitchEnv.Values;
+- }
+- // Envelope data
+- if ((pEnvPoints) && (pEnvData) && (pedata[iEnv]))
+- {
+- WORD *psrc = pedata[iEnv];
+- for (UINT i=0; i<16; i++)
+- {
+- pEnvPoints[i] = psrc[i*2];
+- pEnvData[i] = (BYTE)psrc[i*2+1];
+- }
+- }
+- }
+- }
+- dwMemPos += pmi->dwDataLen + 36;
+- if (pfh->wVersion > 0x201) dwMemPos += 4; // ?
+- } else
+- {
+- dwMemPos += 36;
+- }
+- }
+-#ifdef MT2DEBUG
+- Log("Loading samples at offset 0x%08X\n", dwMemPos);
+-#endif
+- memset(SampleMap, 0, sizeof(SampleMap));
+- m_nSamples = (pfh->wSamples < MAX_SAMPLES) ? pfh->wSamples : MAX_SAMPLES-1;
+- for (UINT iSmp=1; iSmp<=256; iSmp++)
+- {
+- if (dwMemPos+36 > dwMemLength) return TRUE;
+- MT2SAMPLE *pms = (MT2SAMPLE *)(lpStream+dwMemPos);
+- #ifdef MT2DEBUG
+- if (iSmp <= m_nSamples) Log(" Sample #%d at offset %04X: %d bytes\n", iSmp, dwMemPos, pms->dwDataLen);
+- #endif
+- if (iSmp < MAX_SAMPLES)
+- {
+- memcpy(m_szNames[iSmp], pms->szName, 32);
+- }
+- if (pms->dwDataLen > 0)
+- {
+- SampleMap[iSmp-1] = pms;
+- if (iSmp < MAX_SAMPLES)
+- {
+- MODINSTRUMENT *psmp = &Ins[iSmp];
+- psmp->nGlobalVol = 64;
+- psmp->nVolume = (pms->wVolume >> 7);
+- psmp->nPan = (pms->nPan == 0x80) ? 128 : (pms->nPan^0x80);
+- psmp->nLength = pms->dwLength;
+- psmp->nC4Speed = pms->dwFrequency;
+- psmp->nLoopStart = pms->dwLoopStart;
+- psmp->nLoopEnd = pms->dwLoopEnd;
+- FrequencyToTranspose(psmp);
+- psmp->RelativeTone -= pms->nBaseNote - 49;
+- psmp->nC4Speed = TransposeToFrequency(psmp->RelativeTone, psmp->nFineTune);
+- if (pms->nQuality == 2) { psmp->uFlags |= CHN_16BIT; psmp->nLength >>= 1; }
+- if (pms->nChannels == 2) { psmp->nLength >>= 1; }
+- if (pms->nLoop == 1) psmp->uFlags |= CHN_LOOP;
+- if (pms->nLoop == 2) psmp->uFlags |= CHN_LOOP|CHN_PINGPONGLOOP;
+- }
+- dwMemPos += pms->dwDataLen + 36;
+- } else
+- {
+- dwMemPos += 36;
+- }
+- }
+-#ifdef MT2DEBUG
+- Log("Loading groups at offset 0x%08X\n", dwMemPos);
+-#endif
+- for (UINT iMap=0; iMap<255; iMap++) if (InstrMap[iMap])
+- {
+- if (dwMemPos+8 > dwMemLength) return TRUE;
+- MT2INSTRUMENT *pmi = InstrMap[iMap];
+- INSTRUMENTHEADER *penv = NULL;
+- if (iMap<m_nInstruments) penv = Headers[iMap+1];
+- for (UINT iGrp=0; iGrp<pmi->wSamples; iGrp++)
+- {
+- if (penv)
+- {
+- MT2GROUP *pmg = (MT2GROUP *)(lpStream+dwMemPos);
+- for (UINT i=0; i<96; i++)
+- {
+- if (pmi->GroupsMapping[i] == iGrp)
+- {
+- UINT nSmp = pmg->nSmpNo+1;
+- penv->Keyboard[i+12] = (BYTE)nSmp;
+- if (nSmp <= m_nSamples)
+- {
+- Ins[nSmp].nVibType = pmi->bVibType;
+- Ins[nSmp].nVibSweep = pmi->bVibSweep;
+- Ins[nSmp].nVibDepth = pmi->bVibDepth;
+- Ins[nSmp].nVibRate = pmi->bVibRate/4;
+- }
+- }
+- }
+- }
+- dwMemPos += 8;
+- }
+- }
+-#ifdef MT2DEBUG
+- Log("Loading sample data at offset 0x%08X\n", dwMemPos);
+-#endif
+- for (UINT iData=0; iData<256; iData++) if ((iData < m_nSamples) && (SampleMap[iData]))
+- {
+- MT2SAMPLE *pms = SampleMap[iData];
+- MODINSTRUMENT *psmp = &Ins[iData+1];
+- if (!(pms->nFlags & 5))
+- {
+- if (psmp->nLength > 0)
+- {
+- #ifdef MT2DEBUG
+- Log(" Reading sample #%d at offset 0x%04X (len=%d)\n", iData+1, dwMemPos, psmp->nLength);
+- #endif
+- UINT rsflags;
+-
+- if (pms->nChannels == 2)
+- rsflags = (psmp->uFlags & CHN_16BIT) ? RS_STPCM16D : RS_STPCM8D;
+- else
+- rsflags = (psmp->uFlags & CHN_16BIT) ? RS_PCM16D : RS_PCM8D;
+-
+- dwMemPos += ReadSample(psmp, rsflags, (LPCSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+- }
+- } else
+- if (dwMemPos+4 < dwMemLength)
+- {
+- UINT nNameLen = *(DWORD *)(lpStream+dwMemPos);
+- dwMemPos += nNameLen + 16;
+- }
+- if (dwMemPos+4 >= dwMemLength) break;
+- }
+- return TRUE;
+-}
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_mtm.cxx audacious-plugins-2.5.4/src/modplug/load_mtm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_mtm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_mtm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,165 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-//////////////////////////////////////////////////////////
+-// MTM file support (import only)
+-
+-#pragma pack(1)
+-
+-
+-typedef struct tagMTMSAMPLE
+-{
+- char samplename[22]; // changed from CHAR
+- DWORD length;
+- DWORD reppos;
+- DWORD repend;
+- CHAR finetune;
+- BYTE volume;
+- BYTE attribute;
+-} MTMSAMPLE;
+-
+-
+-typedef struct tagMTMHEADER
+-{
+- char id[4]; // MTM file marker + version // changed from CHAR
+- char songname[20]; // ASCIIZ songname // changed from CHAR
+- WORD numtracks; // number of tracks saved
+- BYTE lastpattern; // last pattern number saved
+- BYTE lastorder; // last order number to play (songlength-1)
+- WORD commentsize; // length of comment field
+- BYTE numsamples; // number of samples saved
+- BYTE attribute; // attribute byte (unused)
+- BYTE beatspertrack;
+- BYTE numchannels; // number of channels used
+- BYTE panpos[32]; // voice pan positions
+-} MTMHEADER;
+-
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadMTM(LPCBYTE lpStream, DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- MTMHEADER *pmh = (MTMHEADER *)lpStream;
+- DWORD dwMemPos = 66;
+-
+- if ((!lpStream) || (dwMemLength < 0x100)) return FALSE;
+- if ((strncmp(pmh->id, "MTM", 3)) || (pmh->numchannels > 32)
+- || (pmh->numsamples >= MAX_SAMPLES) || (!pmh->numsamples)
+- || (!pmh->numtracks) || (!pmh->numchannels)
+- || (!pmh->lastpattern) || (pmh->lastpattern > MAX_PATTERNS)) return FALSE;
+- strncpy(m_szNames[0], pmh->songname, 20);
+- m_szNames[0][20] = 0;
+- if (dwMemPos + 37*pmh->numsamples + 128 + 192*bswapLE16(pmh->numtracks)
+- + 64 * (pmh->lastpattern+1) + bswapLE16(pmh->commentsize) >= dwMemLength) return FALSE;
+- m_nType = MOD_TYPE_MTM;
+- m_nSamples = pmh->numsamples;
+- m_nChannels = pmh->numchannels;
+- // Reading instruments
+- for (UINT i=1; i<=m_nSamples; i++)
+- {
+- MTMSAMPLE *pms = (MTMSAMPLE *)(lpStream + dwMemPos);
+- strncpy(m_szNames[i], pms->samplename, 22);
+- m_szNames[i][22] = 0;
+- Ins[i].nVolume = pms->volume << 2;
+- Ins[i].nGlobalVol = 64;
+- DWORD len = bswapLE32(pms->length);
+- if ((len > 4) && (len <= MAX_SAMPLE_LENGTH))
+- {
+- Ins[i].nLength = len;
+- Ins[i].nLoopStart = bswapLE32(pms->reppos);
+- Ins[i].nLoopEnd = bswapLE32(pms->repend);
+- if (Ins[i].nLoopEnd > Ins[i].nLength) Ins[i].nLoopEnd = Ins[i].nLength;
+- if (Ins[i].nLoopStart + 4 >= Ins[i].nLoopEnd) Ins[i].nLoopStart = Ins[i].nLoopEnd = 0;
+- if (Ins[i].nLoopEnd) Ins[i].uFlags |= CHN_LOOP;
+- Ins[i].nFineTune = MOD2XMFineTune(pms->finetune);
+- if (pms->attribute & 0x01)
+- {
+- Ins[i].uFlags |= CHN_16BIT;
+- Ins[i].nLength >>= 1;
+- Ins[i].nLoopStart >>= 1;
+- Ins[i].nLoopEnd >>= 1;
+- }
+- Ins[i].nPan = 128;
+- }
+- dwMemPos += 37;
+- }
+- // Setting Channel Pan Position
+- for (UINT ich=0; ich<m_nChannels; ich++)
+- {
+- ChnSettings[ich].nPan = ((pmh->panpos[ich] & 0x0F) << 4) + 8;
+- ChnSettings[ich].nVolume = 64;
+- }
+- // Reading pattern order
+- memcpy(Order, lpStream + dwMemPos, pmh->lastorder+1);
+- dwMemPos += 128;
+- // Reading Patterns
+- LPCBYTE pTracks = lpStream + dwMemPos;
+- dwMemPos += 192 * bswapLE16(pmh->numtracks);
+- LPWORD pSeq = (LPWORD)(lpStream + dwMemPos);
+- for (UINT pat=0; pat<=pmh->lastpattern; pat++)
+- {
+- PatternSize[pat] = 64;
+- PatternAllocSize[pat] = 64;
+- if ((Patterns[pat] = AllocatePattern(64, m_nChannels)) == NULL) break;
+- for (UINT n=0; n<32; n++) if ((pSeq[n]) && (pSeq[n] <= bswapLE16(pmh->numtracks)) && (n < m_nChannels))
+- {
+- LPCBYTE p = pTracks + 192 * (pSeq[n]-1);
+- MODCOMMAND *m = Patterns[pat] + n;
+- for (UINT i=0; i<64; i++, m+=m_nChannels, p+=3)
+- {
+- if (p[0] & 0xFC) m->note = (p[0] >> 2) + 37;
+- m->instr = ((p[0] & 0x03) << 4) | (p[1] >> 4);
+- UINT cmd = p[1] & 0x0F;
+- UINT param = p[2];
+- if (cmd == 0x0A)
+- {
+- if (param & 0xF0) param &= 0xF0; else param &= 0x0F;
+- }
+- m->command = cmd;
+- m->param = param;
+- if ((cmd) || (param)) ConvertModCommand(m);
+- }
+- }
+- pSeq += 32;
+- }
+- dwMemPos += 64*(pmh->lastpattern+1);
+- if (bswapLE16(pmh->commentsize) && (dwMemPos + bswapLE16(pmh->commentsize) < dwMemLength))
+- {
+- UINT n = bswapLE16(pmh->commentsize);
+- m_lpszSongComments = new char[n+1];
+- if (m_lpszSongComments)
+- {
+- memcpy(m_lpszSongComments, lpStream+dwMemPos, n);
+- m_lpszSongComments[n] = 0;
+- for (UINT i=0; i<n; i++)
+- {
+- if (!m_lpszSongComments[i])
+- {
+- m_lpszSongComments[i] = ((i+1) % 40) ? 0x20 : 0x0D;
+- }
+- }
+- }
+- }
+- dwMemPos += bswapLE16(pmh->commentsize);
+- // Reading Samples
+- for (UINT ismp=1; ismp<=m_nSamples; ismp++)
+- {
+- if (dwMemPos >= dwMemLength) break;
+- dwMemPos += ReadSample(&Ins[ismp], (Ins[ismp].uFlags & CHN_16BIT) ? RS_PCM16U : RS_PCM8U,
+- (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+- }
+- m_nMinPeriod = 64;
+- m_nMaxPeriod = 32767;
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_okt.cxx audacious-plugins-2.5.4/src/modplug/load_okt.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_okt.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_okt.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,197 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-//////////////////////////////////////////////
+-// Oktalyzer (OKT) module loader //
+-//////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-typedef struct OKTFILEHEADER
+-{
+- DWORD okta; // "OKTA"
+- DWORD song; // "SONG"
+- DWORD cmod; // "CMOD"
+- DWORD fixed8;
+- BYTE chnsetup[8];
+- DWORD samp; // "SAMP"
+- DWORD samplen;
+-} OKTFILEHEADER;
+-
+-
+-typedef struct OKTSAMPLE
+-{
+- CHAR name[20];
+- DWORD length;
+- WORD loopstart;
+- WORD looplen;
+- BYTE pad1;
+- BYTE volume;
+- BYTE pad2;
+- BYTE pad3;
+-} OKTSAMPLE;
+-
+-
+-BOOL CSoundFile::ReadOKT(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- OKTFILEHEADER *pfh = (OKTFILEHEADER *)lpStream;
+- DWORD dwMemPos = sizeof(OKTFILEHEADER);
+- UINT nsamples = 0, norders = 0;
+-
+- if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
+- if ((pfh->okta != 0x41544B4F) || (pfh->song != 0x474E4F53)
+- || (pfh->cmod != 0x444F4D43) || (pfh->chnsetup[0]) || (pfh->chnsetup[2])
+- || (pfh->chnsetup[4]) || (pfh->chnsetup[6]) || (pfh->fixed8 != 0x08000000)
+- || (pfh->samp != 0x504D4153)) return FALSE;
+- m_nType = MOD_TYPE_OKT;
+- m_nChannels = 4 + pfh->chnsetup[1] + pfh->chnsetup[3] + pfh->chnsetup[5] + pfh->chnsetup[7];
+- if (m_nChannels > MAX_CHANNELS) m_nChannels = MAX_CHANNELS;
+- nsamples = bswapBE32(pfh->samplen) >> 5;
+- m_nSamples = nsamples;
+- if (m_nSamples >= MAX_SAMPLES) m_nSamples = MAX_SAMPLES-1;
+- // Reading samples
+- for (UINT smp=1; smp <= nsamples; smp++)
+- {
+- if (dwMemPos >= dwMemLength) return TRUE;
+- if (smp < MAX_SAMPLES)
+- {
+- OKTSAMPLE *psmp = (OKTSAMPLE *)(lpStream + dwMemPos);
+- MODINSTRUMENT *pins = &Ins[smp];
+-
+- memcpy(m_szNames[smp], psmp->name, 20);
+- pins->uFlags = 0;
+- pins->nLength = bswapBE32(psmp->length) & ~1;
+- pins->nLoopStart = bswapBE16(psmp->loopstart);
+- pins->nLoopEnd = pins->nLoopStart + bswapBE16(psmp->looplen);
+- if (pins->nLoopStart + 2 < pins->nLoopEnd) pins->uFlags |= CHN_LOOP;
+- pins->nGlobalVol = 64;
+- pins->nVolume = psmp->volume << 2;
+- pins->nC4Speed = 8363;
+- }
+- dwMemPos += sizeof(OKTSAMPLE);
+- }
+- // SPEE
+- if (dwMemPos >= dwMemLength) return TRUE;
+- if (*((DWORD *)(lpStream + dwMemPos)) == 0x45455053)
+- {
+- m_nDefaultSpeed = lpStream[dwMemPos+9];
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- }
+- // SLEN
+- if (dwMemPos >= dwMemLength) return TRUE;
+- if (*((DWORD *)(lpStream + dwMemPos)) == 0x4E454C53)
+- {
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- }
+- // PLEN
+- if (dwMemPos >= dwMemLength) return TRUE;
+- if (*((DWORD *)(lpStream + dwMemPos)) == 0x4E454C50)
+- {
+- norders = lpStream[dwMemPos+9];
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- }
+- // PATT
+- if (dwMemPos >= dwMemLength) return TRUE;
+- if (*((DWORD *)(lpStream + dwMemPos)) == 0x54544150)
+- {
+- UINT orderlen = norders;
+- if (orderlen >= MAX_ORDERS) orderlen = MAX_ORDERS-1;
+- for (UINT i=0; i<orderlen; i++) Order[i] = lpStream[dwMemPos+10+i];
+- for (UINT j=orderlen; j>1; j--) { if (Order[j-1]) break; Order[j-1] = 0xFF; }
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- }
+- // PBOD
+- UINT npat = 0;
+- while ((dwMemPos+10 < dwMemLength) && (*((DWORD *)(lpStream + dwMemPos)) == 0x444F4250))
+- {
+- DWORD dwPos = dwMemPos + 10;
+- UINT rows = lpStream[dwMemPos+9];
+- if (!rows) rows = 64;
+- if (npat < MAX_PATTERNS)
+- {
+- if ((Patterns[npat] = AllocatePattern(rows, m_nChannels)) == NULL) return TRUE;
+- MODCOMMAND *m = Patterns[npat];
+- PatternSize[npat] = rows;
+- PatternAllocSize[npat] = rows;
+- UINT imax = m_nChannels*rows;
+- for (UINT i=0; i<imax; i++, m++, dwPos+=4)
+- {
+- if (dwPos+4 > dwMemLength) break;
+- const BYTE *p = lpStream+dwPos;
+- UINT note = p[0];
+- if (note)
+- {
+- m->note = note + 48;
+- m->instr = p[1] + 1;
+- }
+- UINT command = p[2];
+- UINT param = p[3];
+- m->param = param;
+- switch(command)
+- {
+- // 0: no effect
+- case 0:
+- break;
+- // 1: Portamento Up
+- case 1:
+- case 17:
+- case 30:
+- if (param) m->command = CMD_PORTAMENTOUP;
+- break;
+- // 2: Portamento Down
+- case 2:
+- case 13:
+- case 21:
+- if (param) m->command = CMD_PORTAMENTODOWN;
+- break;
+- // 10: Arpeggio
+- case 10:
+- case 11:
+- case 12:
+- m->command = CMD_ARPEGGIO;
+- break;
+- // 15: Filter
+- case 15:
+- m->command = CMD_MODCMDEX;
+- m->param = param & 0x0F;
+- break;
+- // 25: Position Jump
+- case 25:
+- m->command = CMD_POSITIONJUMP;
+- break;
+- // 28: Set Speed
+- case 28:
+- m->command = CMD_SPEED;
+- break;
+- // 31: Volume Control
+- case 31:
+- if (param <= 0x40) m->command = CMD_VOLUME; else
+- if (param <= 0x50) { m->command = CMD_VOLUMESLIDE; m->param &= 0x0F; if (!m->param) m->param = 0x0F; } else
+- if (param <= 0x60) { m->command = CMD_VOLUMESLIDE; m->param = (param & 0x0F) << 4; if (!m->param) m->param = 0xF0; } else
+- if (param <= 0x70) { m->command = CMD_MODCMDEX; m->param = 0xB0 | (param & 0x0F); if (!(param & 0x0F)) m->param = 0xBF; } else
+- if (param <= 0x80) { m->command = CMD_MODCMDEX; m->param = 0xA0 | (param & 0x0F); if (!(param & 0x0F)) m->param = 0xAF; }
+- break;
+- }
+- }
+- }
+- npat++;
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- }
+- // SBOD
+- UINT nsmp = 1;
+- while ((dwMemPos+10 < dwMemLength) && (*((DWORD *)(lpStream + dwMemPos)) == 0x444F4253))
+- {
+- if (nsmp < MAX_SAMPLES) ReadSample(&Ins[nsmp], RS_PCM8S, (LPSTR)(lpStream+dwMemPos+8), dwMemLength-dwMemPos-8);
+- dwMemPos += bswapBE32(*((DWORD *)(lpStream + dwMemPos + 4))) + 8;
+- nsmp++;
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_psm.cxx audacious-plugins-2.5.4/src/modplug/load_psm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_psm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_psm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,882 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-
+-///////////////////////////////////////////////////
+-//
+-// PSM module loader
+-//
+-///////////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#define PSM_LOG
+-
+-#define PSM_ID_NEW 0x204d5350
+-#define PSM_ID_OLD 0xfe4d5350
+-#define IFFID_FILE 0x454c4946
+-#define IFFID_TITL 0x4c544954
+-#define IFFID_SDFT 0x54464453
+-#define IFFID_PBOD 0x444f4250
+-#define IFFID_SONG 0x474e4f53
+-#define IFFID_PATT 0x54544150
+-#define IFFID_DSMP 0x504d5344
+-#define IFFID_OPLH 0x484c504f
+-
+-#pragma pack(1)
+-
+-typedef struct _PSMCHUNK
+-{
+- DWORD id;
+- DWORD len;
+- DWORD listid;
+-} PSMCHUNK;
+-
+-typedef struct _PSMSONGHDR
+-{
+- CHAR songname[8]; // "MAINSONG"
+- BYTE reserved1;
+- BYTE reserved2;
+- BYTE channels;
+-} PSMSONGHDR;
+-
+-typedef struct _PSMPATTERN
+-{
+- DWORD size;
+- DWORD name;
+- WORD rows;
+- WORD reserved1;
+- BYTE data[4];
+-} PSMPATTERN;
+-
+-typedef struct _PSMSAMPLE
+-{
+- BYTE flags;
+- CHAR songname[8];
+- DWORD smpid;
+- CHAR samplename[34];
+- DWORD reserved1;
+- BYTE reserved2;
+- BYTE insno;
+- BYTE reserved3;
+- DWORD length;
+- DWORD loopstart;
+- DWORD loopend;
+- WORD reserved4;
+- BYTE defvol;
+- DWORD reserved5;
+- DWORD samplerate;
+- BYTE reserved6[19];
+-} PSMSAMPLE;
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadPSM(LPCBYTE lpStream, DWORD dwMemLength)
+-//-----------------------------------------------------------
+-{
+- PSMCHUNK *pfh = (PSMCHUNK *)lpStream;
+- DWORD dwMemPos, dwSongPos;
+- DWORD patptrs[MAX_PATTERNS];
+- BYTE samplemap[MAX_SAMPLES];
+- UINT nPatterns;
+-
+- // Chunk0: "PSM ",filesize,"FILE"
+- if (dwMemLength < 256) return FALSE;
+- if (bswapLE32(pfh->id) == PSM_ID_OLD)
+- {
+- #ifdef PSM_LOG
+- printf("Old PSM format not supported\n");
+- #endif
+- return FALSE;
+- }
+- if ((bswapLE32(pfh->id) != PSM_ID_NEW)
+- || (bswapLE32(pfh->len)+12 > dwMemLength)
+- || (bswapLE32(pfh->listid) != IFFID_FILE)) return FALSE;
+- m_nType = MOD_TYPE_PSM;
+- m_nChannels = 16;
+- m_nSamples = 0;
+- nPatterns = 0;
+- dwMemPos = 12;
+- dwSongPos = 0;
+- for (UINT iChPan=0; iChPan<16; iChPan++)
+- {
+- UINT pan = (((iChPan & 3) == 1) || ((iChPan&3)==2)) ? 0xC0 : 0x40;
+- ChnSettings[iChPan].nPan = pan;
+- }
+- m_szNames[0][0]=0;
+- while (dwMemPos+8 < dwMemLength)
+- {
+- PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
+- if ((bswapLE32(pchunk->len) >= dwMemLength - 8)
+- || (dwMemPos + bswapLE32(pchunk->len) + 8 > dwMemLength)) break;
+- dwMemPos += 8;
+- PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
+- ULONG len = bswapLE32(pchunk->len);
+- if (len) switch(bswapLE32(pchunk->id))
+- {
+- // "TITL": Song title
+- case IFFID_TITL:
+- if (!pdata[0]) { pdata++; len--; }
+- memcpy(m_szNames[0], pdata, (len>31) ? 31 : len);
+- m_szNames[0][31] = 0;
+- break;
+- // "PBOD": Pattern
+- case IFFID_PBOD:
+- if ((len >= 12) && (nPatterns < MAX_PATTERNS))
+- {
+- patptrs[nPatterns++] = dwMemPos-8;
+- }
+- break;
+- // "SONG": Song description
+- case IFFID_SONG:
+- if ((len >= sizeof(PSMSONGHDR)+8) && (!dwSongPos))
+- {
+- dwSongPos = dwMemPos - 8;
+- }
+- break;
+- // "DSMP": Sample Data
+- case IFFID_DSMP:
+- if ((len >= sizeof(PSMSAMPLE)) && (m_nSamples+1 < MAX_SAMPLES))
+- {
+- m_nSamples++;
+- MODINSTRUMENT *pins = &Ins[m_nSamples];
+- PSMSAMPLE *psmp = (PSMSAMPLE *)pdata;
+- memcpy(m_szNames[m_nSamples], psmp->samplename, 31);
+- m_szNames[m_nSamples][31] = 0;
+- samplemap[m_nSamples-1] = (BYTE)m_nSamples;
+- // Init sample
+- pins->nGlobalVol = 0x40;
+- pins->nC4Speed = bswapLE32(psmp->samplerate);
+- pins->nLength = bswapLE32(psmp->length);
+- pins->nLoopStart = bswapLE32(psmp->loopstart);
+- pins->nLoopEnd = bswapLE32(psmp->loopend);
+- pins->nPan = 128;
+- pins->nVolume = (psmp->defvol+1) * 2;
+- pins->uFlags = (psmp->flags & 0x80) ? CHN_LOOP : 0;
+- if (pins->nLoopStart > 0) pins->nLoopStart--;
+- // Point to sample data
+- pdata += 0x60;
+- len -= 0x60;
+- // Load sample data
+- if ((pins->nLength > 3) && (len > 3))
+- {
+- ReadSample(pins, RS_PCM8D, (LPCSTR)pdata, len);
+- } else
+- {
+- pins->nLength = 0;
+- }
+- }
+- break;
+- #if 0
+- default:
+- {
+- CHAR s[8], s2[64];
+- *(DWORD *)s = pchunk->id;
+- s[4] = 0;
+- wsprintf(s2, "%s: %4d bytes @ %4d\n", s, pchunk->len, dwMemPos);
+- OutputDebugString(s2);
+- }
+- #endif
+- }
+- dwMemPos += bswapLE32(pchunk->len);
+- }
+- // Step #1: convert song structure
+- PSMSONGHDR *pSong = (PSMSONGHDR *)(lpStream+dwSongPos+8);
+- if ((!dwSongPos) || (pSong->channels < 2) || (pSong->channels > 32)) return TRUE;
+- m_nChannels = pSong->channels;
+- // Valid song header -> convert attached chunks
+- {
+- DWORD dwSongEnd = dwSongPos + 8 + *(DWORD *)(lpStream+dwSongPos+4);
+- dwMemPos = dwSongPos + 8 + 11; // sizeof(PSMCHUNK)+sizeof(PSMSONGHDR)
+- while (dwMemPos + 8 < dwSongEnd)
+- {
+- PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
+- dwMemPos += 8;
+- if ((bswapLE32(pchunk->len) > dwSongEnd)
+- || (dwMemPos + bswapLE32(pchunk->len) > dwSongEnd)) break;
+- PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
+- ULONG len = bswapLE32(pchunk->len);
+- switch(bswapLE32(pchunk->id))
+- {
+- case IFFID_OPLH:
+- if (len >= 0x20)
+- {
+- UINT pos = len - 3;
+- while (pos > 5)
+- {
+- BOOL bFound = FALSE;
+- pos -= 5;
+- DWORD dwName = *(DWORD *)(pdata+pos);
+- for (UINT i=0; i<nPatterns; i++)
+- {
+- DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+- if (dwName == dwPatName)
+- {
+- bFound = TRUE;
+- break;
+- }
+- }
+- if ((!bFound) && (pdata[pos+1] > 0) && (pdata[pos+1] <= 0x10)
+- && (pdata[pos+3] > 0x40) && (pdata[pos+3] < 0xC0))
+- {
+- m_nDefaultSpeed = pdata[pos+1];
+- m_nDefaultTempo = pdata[pos+3];
+- break;
+- }
+- }
+- UINT iOrd = 0;
+- while ((pos+5<len) && (iOrd < MAX_ORDERS))
+- {
+- DWORD dwName = *(DWORD *)(pdata+pos);
+- for (UINT i=0; i<nPatterns; i++)
+- {
+- DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
+- if (dwName == dwPatName)
+- {
+- Order[iOrd++] = i;
+- break;
+- }
+- }
+- pos += 5;
+- }
+- }
+- break;
+- }
+- dwMemPos += bswapLE32(pchunk->len);
+- }
+- }
+-
+- // Step #2: convert patterns
+- for (UINT nPat=0; nPat<nPatterns; nPat++)
+- {
+- PSMPATTERN *pPsmPat = (PSMPATTERN *)(lpStream+patptrs[nPat]+8);
+- ULONG len = bswapLE32(*(DWORD *)(lpStream+patptrs[nPat]+4)) - 12;
+- UINT nRows = bswapLE16(pPsmPat->rows);
+- if (len > bswapLE32(pPsmPat->size)) len = bswapLE32(pPsmPat->size);
+- if ((nRows < 64) || (nRows > 256)) nRows = 64;
+- PatternSize[nPat] = nRows;
+- PatternAllocSize[nPat] = nRows;
+- if ((Patterns[nPat] = AllocatePattern(nRows, m_nChannels)) == NULL) break;
+- MODCOMMAND *m = Patterns[nPat];
+- MODCOMMAND *sp, dummy;
+- BYTE *p = pPsmPat->data;
+- UINT pos = 0;
+- UINT row = 0;
+- UINT rowlim;
+- #ifdef PSM_LOG
+- //printf("Pattern %d at offset 0x%04X\n", nPat, (DWORD)(p - (BYTE *)lpStream));
+- #endif
+- rowlim = bswapLE16(pPsmPat->reserved1)-2;
+- while ((row < nRows) && (pos+1 < len))
+- {
+- UINT flags, ch;
+- if ((pos+1) >= rowlim) {
+- pos = rowlim;
+- rowlim = (((int)p[pos+1])<<8)
+- | ((int)p[pos+0]);
+- m += m_nChannels;
+- row++;
+- rowlim += pos;
+- pos += 2;
+- }
+- flags = p[pos++];
+- ch = p[pos++];
+- if (ch >= m_nChannels) {
+- #ifdef PSM_LOG
+- printf("Invalid channel row=%d (0x%02X.0x%02X)\n", row, flags, ch);
+- #endif
+- sp = &dummy;
+- } else {
+- sp = &m[ch];
+- }
+- // Note + Instr
+- if ((flags & 0x80) && (pos+1 < len))
+- {
+- UINT note = p[pos++];
+- note = (note>>4)*12+(note&0x0f)+12+1;
+- if (note > 0x80) note = 0;
+- sp->note = note;
+- }
+- if ((flags & 0x40) && (pos+1 < len))
+- {
+- UINT nins = p[pos++];
+- #ifdef PSM_LOG
+- if ((!nPat) && (nins >= m_nSamples)) printf("WARNING: invalid instrument number (%d)\n", nins);
+- #endif
+- sp->instr = samplemap[nins];
+- }
+- // Volume
+- if ((flags & 0x20) && (pos < len))
+- {
+- sp->volcmd = VOLCMD_VOLUME;
+- sp->vol = p[pos++] / 2;
+- }
+- // Effect
+- if ((flags & 0x10) && (pos+1 < len))
+- {
+- UINT command = p[pos++];
+- UINT param = p[pos++];
+- // Convert effects
+- switch(command & 0x3F)
+- {
+- // 01: fine volslide up
+- case 0x01:
+-#if PSM_LOG
+- printf("fvup command pat=%d row=%d ch=%d %02x %02x\n",
+- nPat,
+- row,1+ch,
+- command, param);
+-#endif
+-#if 0
+- if (!sp->volcmd) {
+- sp->volcmd = VOLCMD_FINEVOLUP;
+- sp->vol = (param >> 1) & 0xF;
+- command = CMD_PORTAMENTOUP;
+- param>>=4; param |= 0xf0;
+- if (param == 240) param=241;
+- } else {
+-#endif
+- command = CMD_VOLUMESLIDE;
+- param |= 0x0f;
+- if (param == 15) param=31;
+- break;
+- // 02: volslide up
+- case 0x02: command = CMD_VOLUMESLIDE; param>>=1; param<<=4; break;
+- // 03: fine volslide down
+- case 0x03:
+-#if PSM_LOG
+- printf("fvdown command pat=%d row=%d ch=%d %02x %02x\n",
+- nPat,
+- row,1+ch,
+- command, param);
+-#endif
+-#if 0
+- if (!sp->volcmd) {
+- sp->volcmd = VOLCMD_FINEVOLDOWN;
+- sp->vol = (param >> 2) & 0xF;
+- if (!sp->vol) sp->vol = 1;
+- command = CMD_PORTAMENTODOWN;
+- }
+-#endif
+- command = CMD_VOLUMESLIDE;
+- param>>=4; param |= 0xf0;
+- if (param == 240) param=241;
+- break;
+- // 04: volslide down
+- case 0x04: command = CMD_VOLUMESLIDE; param>>=1; break;
+- // 0C: portamento up
+- case 0x0C: command = CMD_PORTAMENTOUP; param = (param+1)/2; break;
+- // 0E: portamento down
+- case 0x0E: command = CMD_PORTAMENTODOWN; param = (param+1)/2; break;
+- // 0F: tone portamento
+- case 0x0F: command = CMD_TONEPORTAMENTO; param = param/4; break;
+- // 15: vibrato
+- case 0x15: command = CMD_VIBRATO; break;
+- // 29: wtf
+- case 0x29: pos += 2; break;
+- // 2A: retrig
+- case 0x2A: command = CMD_RETRIG; break;
+- // 33: Position Jump
+- case 0x33: command = CMD_POSITIONJUMP; break;
+- // 34: Pattern break
+- case 0x34: command = CMD_PATTERNBREAK; break;
+- // 3D: speed
+- case 0x3D: command = CMD_SPEED;
+- if (!row && !nPat)
+- m_nDefaultSpeed = param;
+- break;
+- // 3E: tempo
+- case 0x3E: command = CMD_TEMPO;
+- if (!row && !nPat)
+- m_nDefaultTempo = param;
+- break;
+- // Unknown
+- default:
+- #ifdef PSM_LOG
+- printf("Unknown PSM effect pat=%d row=%d ch=%d: %02X.%02X\n", nPat, row, ch, command, param);
+- #endif
+- command = param = 0;
+- }
+- sp->command = (BYTE)command;
+- sp->param = (BYTE)param;
+- }
+- }
+- #ifdef PSM_LOG
+- if (pos < len)
+- {
+-// printf("Pattern %d: %d/%d[%d] rows (%d bytes) -> %d bytes left\n", nPat, row, nRows, pPsmPat->rows, pPsmPat->size, len-pos);
+- }
+- #endif
+- }
+-
+- // Done (finally!)
+- return TRUE;
+-}
+-
+-
+-//////////////////////////////////////////////////////////////
+-//
+-// PSM Old Format
+-//
+-
+-/*
+-
+-CONST
+- c_PSM_MaxOrder = $FF;
+- c_PSM_MaxSample = $FF;
+- c_PSM_MaxChannel = $0F;
+-
+- TYPE
+- PPSM_Header = ^TPSM_Header;
+- TPSM_Header = RECORD
+- PSM_Sign : ARRAY[01..04] OF CHAR; { PSM + #254 }
+- PSM_SongName : ARRAY[01..58] OF CHAR;
+- PSM_Byte00 : BYTE;
+- PSM_Byte1A : BYTE;
+- PSM_Unknown00 : BYTE;
+- PSM_Unknown01 : BYTE;
+- PSM_Unknown02 : BYTE;
+- PSM_Speed : BYTE;
+- PSM_Tempo : BYTE;
+- PSM_Unknown03 : BYTE;
+- PSM_Unknown04 : WORD;
+- PSM_OrderLength : WORD;
+- PSM_PatternNumber : WORD;
+- PSM_SampleNumber : WORD;
+- PSM_ChannelNumber : WORD;
+- PSM_ChannelUsed : WORD;
+- PSM_OrderPosition : LONGINT;
+- PSM_ChannelSettingPosition : LONGINT;
+- PSM_PatternPosition : LONGINT;
+- PSM_SamplePosition : LONGINT;
+- { *** perhaps there are some more infos in a larger header,
+- but i have not decoded it and so it apears here NOT }
+- END;
+-
+- PPSM_Sample = ^TPSM_Sample;
+- TPSM_Sample = RECORD
+- PSM_SampleFileName : ARRAY[01..12] OF CHAR;
+- PSM_SampleByte00 : BYTE;
+- PSM_SampleName : ARRAY[01..22] OF CHAR;
+- PSM_SampleUnknown00 : ARRAY[01..02] OF BYTE;
+- PSM_SamplePosition : LONGINT;
+- PSM_SampleUnknown01 : ARRAY[01..04] OF BYTE;
+- PSM_SampleNumber : BYTE;
+- PSM_SampleFlags : WORD;
+- PSM_SampleLength : LONGINT;
+- PSM_SampleLoopBegin : LONGINT;
+- PSM_SampleLoopEnd : LONGINT;
+- PSM_Unknown03 : BYTE;
+- PSM_SampleVolume : BYTE;
+- PSM_SampleC5Speed : WORD;
+- END;
+-
+- PPSM_SampleList = ^TPSM_SampleList;
+- TPSM_SampleList = ARRAY[01..c_PSM_MaxSample] OF TPSM_Sample;
+-
+- PPSM_Order = ^TPSM_Order;
+- TPSM_Order = ARRAY[00..c_PSM_MaxOrder] OF BYTE;
+-
+- PPSM_ChannelSettings = ^TPSM_ChannelSettings;
+- TPSM_ChannelSettings = ARRAY[00..c_PSM_MaxChannel] OF BYTE;
+-
+- CONST
+- PSM_NotesInPattern : BYTE = $00;
+- PSM_ChannelInPattern : BYTE = $00;
+-
+- CONST
+- c_PSM_SetSpeed = 60;
+-
+- FUNCTION PSM_Size(FileName : STRING;FilePosition : LONGINT) : LONGINT;
+- BEGIN
+- END;
+-
+- PROCEDURE PSM_UnpackPattern(VAR Source,Destination;PatternLength : WORD);
+- VAR
+- Witz : ARRAY[00..04] OF WORD;
+- I1,I2 : WORD;
+- I3,I4 : WORD;
+- TopicalByte : ^BYTE;
+- Pattern : PUnpackedPattern;
+- ChannelP : BYTE;
+- NoteP : BYTE;
+- InfoByte : BYTE;
+- CodeByte : BYTE;
+- InfoWord : WORD;
+- Effect : BYTE;
+- Opperand : BYTE;
+- Panning : BYTE;
+- Volume : BYTE;
+- PrevInfo : BYTE;
+- InfoIndex : BYTE;
+- BEGIN
+- Pattern := @Destination;
+- TopicalByte := @Source;
+- { *** Initialize patttern }
+- FOR I2 := 0 TO c_Maximum_NoteIndex DO
+- FOR I3 := 0 TO c_Maximum_ChannelIndex DO
+- BEGIN
+- Pattern^[I2,I3,c_Pattern_NoteIndex] := $FF;
+- Pattern^[I2,I3,c_Pattern_SampleIndex] := $00;
+- Pattern^[I2,I3,c_Pattern_VolumeIndex] := $FF;
+- Pattern^[I2,I3,c_Pattern_PanningIndex] := $FF;
+- Pattern^[I2,I3,c_Pattern_EffectIndex] := $00;
+- Pattern^[I2,I3,c_Pattern_OpperandIndex] := $00;
+- END;
+- { *** Byte-pointer on first pattern-entry }
+- ChannelP := $00;
+- NoteP := $00;
+- InfoByte := $00;
+- PrevInfo := $00;
+- InfoIndex := $02;
+- { *** read notes in pattern }
+- PSM_NotesInPattern := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
+- PSM_ChannelInPattern := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
+- { *** unpack pattern }
+- WHILE (INTEGER(PatternLength) > 0) AND (NoteP < c_Maximum_NoteIndex) DO
+- BEGIN
+- { *** Read info-byte }
+- InfoByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
+- IF InfoByte <> $00 THEN
+- BEGIN
+- ChannelP := InfoByte AND $0F;
+- IF InfoByte AND 128 = 128 THEN { note and sample }
+- BEGIN
+- { *** read note }
+- CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
+- DEC(CodeByte);
+- CodeByte := CodeByte MOD 12 * 16 + CodeByte DIV 12 + 2;
+- Pattern^[NoteP,ChannelP,c_Pattern_NoteIndex] := CodeByte;
+- { *** read sample }
+- CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
+- Pattern^[NoteP,ChannelP,c_Pattern_SampleIndex] := CodeByte;
+- END;
+- IF InfoByte AND 64 = 64 THEN { Volume }
+- BEGIN
+- CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
+- Pattern^[NoteP,ChannelP,c_Pattern_VolumeIndex] := CodeByte;
+- END;
+- IF InfoByte AND 32 = 32 THEN { effect AND opperand }
+- BEGIN
+- Effect := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
+- Opperand := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
+- CASE Effect OF
+- c_PSM_SetSpeed:
+- BEGIN
+- Effect := c_I_Set_Speed;
+- END;
+- ELSE
+- BEGIN
+- Effect := c_I_NoEffect;
+- Opperand := $00;
+- END;
+- END;
+- Pattern^[NoteP,ChannelP,c_Pattern_EffectIndex] := Effect;
+- Pattern^[NoteP,ChannelP,c_Pattern_OpperandIndex] := Opperand;
+- END;
+- END ELSE INC(NoteP);
+- END;
+- END;
+-
+- PROCEDURE PSM_Load(FileName : STRING;FilePosition : LONGINT;VAR Module : PModule;VAR ErrorCode : WORD);
+- { *** caution : Module has to be inited before!!!! }
+- VAR
+- Header : PPSM_Header;
+- Sample : PPSM_SampleList;
+- Order : PPSM_Order;
+- ChannelSettings : PPSM_ChannelSettings;
+- MultiPurposeBuffer : PByteArray;
+- PatternBuffer : PUnpackedPattern;
+- TopicalParaPointer : WORD;
+-
+- InFile : FILE;
+- I1,I2 : WORD;
+- I3,I4 : WORD;
+- TempW : WORD;
+- TempB : BYTE;
+- TempP : PByteArray;
+- TempI : INTEGER;
+- { *** copy-vars for loop-extension }
+- CopySource : LONGINT;
+- CopyDestination : LONGINT;
+- CopyLength : LONGINT;
+- BEGIN
+- { *** try to open file }
+- ASSIGN(InFile,FileName);
+-{$I-}
+- RESET(InFile,1);
+-{$I+}
+- IF IORESULT <> $00 THEN
+- BEGIN
+- EXIT;
+- END;
+-{$I-}
+- { *** seek start of module }
+- IF FILESIZE(InFile) < FilePosition THEN
+- BEGIN
+- EXIT;
+- END;
+- SEEK(InFile,FilePosition);
+- { *** look for enough memory for temporary variables }
+- IF MEMAVAIL < SIZEOF(TPSM_Header) + SIZEOF(TPSM_SampleList) +
+- SIZEOF(TPSM_Order) + SIZEOF(TPSM_ChannelSettings) +
+- SIZEOF(TByteArray) + SIZEOF(TUnpackedPattern)
+- THEN
+- BEGIN
+- EXIT;
+- END;
+- { *** init dynamic variables }
+- NEW(Header);
+- NEW(Sample);
+- NEW(Order);
+- NEW(ChannelSettings);
+- NEW(MultiPurposeBuffer);
+- NEW(PatternBuffer);
+- { *** read header }
+- BLOCKREAD(InFile,Header^,SIZEOF(TPSM_Header));
+- { *** test if this is a DSM-file }
+- IF NOT ((Header^.PSM_Sign[1] = 'P') AND (Header^.PSM_Sign[2] = 'S') AND
+- (Header^.PSM_Sign[3] = 'M') AND (Header^.PSM_Sign[4] = #254)) THEN
+- BEGIN
+- ErrorCode := c_NoValidFileFormat;
+- CLOSE(InFile);
+- EXIT;
+- END;
+- { *** read order }
+- SEEK(InFile,FilePosition + Header^.PSM_OrderPosition);
+- BLOCKREAD(InFile,Order^,Header^.PSM_OrderLength);
+- { *** read channelsettings }
+- SEEK(InFile,FilePosition + Header^.PSM_ChannelSettingPosition);
+- BLOCKREAD(InFile,ChannelSettings^,SIZEOF(TPSM_ChannelSettings));
+- { *** read samplelist }
+- SEEK(InFile,FilePosition + Header^.PSM_SamplePosition);
+- BLOCKREAD(InFile,Sample^,Header^.PSM_SampleNumber * SIZEOF(TPSM_Sample));
+- { *** copy header to intern NTMIK-structure }
+- Module^.Module_Sign := 'MF';
+- Module^.Module_FileFormatVersion := $0100;
+- Module^.Module_SampleNumber := Header^.PSM_SampleNumber;
+- Module^.Module_PatternNumber := Header^.PSM_PatternNumber;
+- Module^.Module_OrderLength := Header^.PSM_OrderLength;
+- Module^.Module_ChannelNumber := Header^.PSM_ChannelNumber+1;
+- Module^.Module_Initial_GlobalVolume := 64;
+- Module^.Module_Initial_MasterVolume := $C0;
+- Module^.Module_Initial_Speed := Header^.PSM_Speed;
+- Module^.Module_Initial_Tempo := Header^.PSM_Tempo;
+-{ *** paragraph 01 start }
+- Module^.Module_Flags := c_Module_Flags_ZeroVolume * BYTE(1) +
+- c_Module_Flags_Stereo * BYTE(1) +
+- c_Module_Flags_ForceAmigaLimits * BYTE(0) +
+- c_Module_Flags_Panning * BYTE(1) +
+- c_Module_Flags_Surround * BYTE(1) +
+- c_Module_Flags_QualityMixing * BYTE(1) +
+- c_Module_Flags_FastVolumeSlides * BYTE(0) +
+- c_Module_Flags_SpecialCustomData * BYTE(0) +
+- c_Module_Flags_SongName * BYTE(1);
+- I1 := $01;
+- WHILE (Header^.PSM_SongName[I1] > #00) AND (I1 < c_Module_SongNameLength) DO
+- BEGIN
+- Module^.Module_Name[I1] := Header^.PSM_SongName[I1];
+- INC(I1);
+- END;
+- Module^.Module_Name[c_Module_SongNameLength] := #00;
+- { *** Init channelsettings }
+- FOR I1 := 0 TO c_Maximum_ChannelIndex DO
+- BEGIN
+- IF I1 < Header^.PSM_ChannelUsed THEN
+- BEGIN
+- { *** channel enabled }
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_GlobalVolume := 64;
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Panning := (ChannelSettings^[I1]) * $08;
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Code := I1 + $10 * BYTE(ChannelSettings^[I1] > $08) +
+- c_ChannelSettings_Code_ChannelEnabled * BYTE(1) +
+- c_ChannelSettings_Code_ChannelDigital * BYTE(1);
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Controls :=
+- c_ChannelSettings_Controls_EnhancedMode * BYTE(1) +
+- c_ChannelSettings_Controls_SurroundMode * BYTE(0);
+- END
+- ELSE
+- BEGIN
+- { *** channel disabled }
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_GlobalVolume := $00;
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Panning := $00;
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Code := $00;
+- Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Controls := $00;
+- END;
+- END;
+- { *** init and copy order }
+- FILLCHAR(Module^.Module_OrderPointer^,c_Maximum_OrderIndex+1,$FF);
+- MOVE(Order^,Module^.Module_OrderPointer^,Header^.PSM_OrderLength);
+- { *** read pattern }
+- SEEK(InFile,FilePosition + Header^.PSM_PatternPosition);
+- NTMIK_LoaderPatternNumber := Header^.PSM_PatternNumber-1;
+- FOR I1 := 0 TO Header^.PSM_PatternNumber-1 DO
+- BEGIN
+- NTMIK_LoadPatternProcedure;
+- { *** read length }
+- BLOCKREAD(InFile,TempW,2);
+- { *** read pattern }
+- BLOCKREAD(InFile,MultiPurposeBuffer^,TempW-2);
+- { *** unpack pattern and set notes per channel to 64 }
+- PSM_UnpackPattern(MultiPurposeBuffer^,PatternBuffer^,TempW);
+- NTMIK_PackPattern(MultiPurposeBuffer^,PatternBuffer^,PSM_NotesInPattern);
+- TempW := WORD(256) * MultiPurposeBuffer^[01] + MultiPurposeBuffer^[00];
+- GETMEM(Module^.Module_PatternPointer^[I1],TempW);
+- MOVE(MultiPurposeBuffer^,Module^.Module_PatternPointer^[I1]^,TempW);
+- { *** next pattern }
+- END;
+- { *** read samples }
+- NTMIK_LoaderSampleNumber := Header^.PSM_SampleNumber;
+- FOR I1 := 1 TO Header^.PSM_SampleNumber DO
+- BEGIN
+- NTMIK_LoadSampleProcedure;
+- { *** get index for sample }
+- I3 := Sample^[I1].PSM_SampleNumber;
+- { *** clip PSM-sample }
+- IF Sample^[I1].PSM_SampleLoopEnd > Sample^[I1].PSM_SampleLength
+- THEN Sample^[I1].PSM_SampleLoopEnd := Sample^[I1].PSM_SampleLength;
+- { *** init intern sample }
+- NEW(Module^.Module_SamplePointer^[I3]);
+- FILLCHAR(Module^.Module_SamplePointer^[I3]^,SIZEOF(TSample),$00);
+- FILLCHAR(Module^.Module_SamplePointer^[I3]^.Sample_SampleName,c_Sample_SampleNameLength,#32);
+- FILLCHAR(Module^.Module_SamplePointer^[I3]^.Sample_FileName,c_Sample_FileNameLength,#32);
+- { *** copy informations to intern sample }
+- I2 := $01;
+- WHILE (Sample^[I1].PSM_SampleName[I2] > #00) AND (I2 < c_Sample_SampleNameLength) DO
+- BEGIN
+- Module^.Module_SamplePointer^[I3]^.Sample_SampleName[I2] := Sample^[I1].PSM_SampleName[I2];
+- INC(I2);
+- END;
+- Module^.Module_SamplePointer^[I3]^.Sample_Sign := 'DF';
+- Module^.Module_SamplePointer^[I3]^.Sample_FileFormatVersion := $00100;
+- Module^.Module_SamplePointer^[I3]^.Sample_Position := $00000000;
+- Module^.Module_SamplePointer^[I3]^.Sample_Selector := $0000;
+- Module^.Module_SamplePointer^[I3]^.Sample_Volume := Sample^[I1].PSM_SampleVolume;
+- Module^.Module_SamplePointer^[I3]^.Sample_LoopCounter := $00;
+- Module^.Module_SamplePointer^[I3]^.Sample_C5Speed := Sample^[I1].PSM_SampleC5Speed;
+- Module^.Module_SamplePointer^[I3]^.Sample_Length := Sample^[I1].PSM_SampleLength;
+- Module^.Module_SamplePointer^[I3]^.Sample_LoopBegin := Sample^[I1].PSM_SampleLoopBegin;
+- Module^.Module_SamplePointer^[I3]^.Sample_LoopEnd := Sample^[I1].PSM_SampleLoopEnd;
+- { *** now it's time for the flags }
+- Module^.Module_SamplePointer^[I3]^.Sample_Flags :=
+- c_Sample_Flags_DigitalSample * BYTE(1) +
+- c_Sample_Flags_8BitSample * BYTE(1) +
+- c_Sample_Flags_UnsignedSampleData * BYTE(1) +
+- c_Sample_Flags_Packed * BYTE(0) +
+- c_Sample_Flags_LoopCounter * BYTE(0) +
+- c_Sample_Flags_SampleName * BYTE(1) +
+- c_Sample_Flags_LoopActive *
+- BYTE(Sample^[I1].PSM_SampleFlags AND (LONGINT(1) SHL 15) = (LONGINT(1) SHL 15));
+- { *** alloc memory for sample-data }
+- E_Getmem(Module^.Module_SamplePointer^[I3]^.Sample_Selector,
+- Module^.Module_SamplePointer^[I3]^.Sample_Position,
+- Module^.Module_SamplePointer^[I3]^.Sample_Length + c_LoopExtensionSize);
+- { *** read out data }
+- EPT(TempP).p_Selector := Module^.Module_SamplePointer^[I3]^.Sample_Selector;
+- EPT(TempP).p_Offset := $0000;
+- SEEK(InFile,Sample^[I1].PSM_SamplePosition);
+- E_BLOCKREAD(InFile,TempP^,Module^.Module_SamplePointer^[I3]^.Sample_Length);
+- { *** 'coz the samples are signed in a DSM-file -> PC-fy them }
+- IF Module^.Module_SamplePointer^[I3]^.Sample_Length > 4 THEN
+- BEGIN
+- CopyLength := Module^.Module_SamplePointer^[I3]^.Sample_Length;
+- { *** decode sample }
+- ASM
+- DB 066h; MOV CX,WORD PTR CopyLength
+- { *** load sample selector }
+- MOV ES,WORD PTR TempP[00002h]
+- DB 066h; XOR SI,SI
+- DB 066h; XOR DI,DI
+- XOR AH,AH
+- { *** conert all bytes }
+- @@MainLoop:
+- DB 026h; DB 067h; LODSB
+- ADD AL,AH
+- MOV AH,AL
+- DB 067h; STOSB
+- DB 066h; LOOP @@MainLoop
+- END;
+- { *** make samples unsigned }
+- ASM
+- DB 066h; MOV CX,WORD PTR CopyLength
+- { *** load sample selector }
+- MOV ES,WORD PTR TempP[00002h]
+- DB 066h; XOR SI,SI
+- DB 066h; XOR DI,DI
+- { *** conert all bytes }
+- @@MainLoop:
+- DB 026h; DB 067h; LODSB
+- SUB AL,080h
+- DB 067h; STOSB
+- DB 066h; LOOP @@MainLoop
+- END;
+- { *** Create Loop-Extension }
+- IF Module^.Module_SamplePointer^[I3]^.Sample_Flags AND c_Sample_Flags_LoopActive = c_Sample_Flags_LoopActive THEN
+- BEGIN
+- CopySource := Module^.Module_SamplePointer^[I3]^.Sample_LoopBegin;
+- CopyDestination := Module^.Module_SamplePointer^[I3]^.Sample_LoopEnd;
+- CopyLength := CopyDestination - CopySource;
+- ASM
+- { *** load sample-selector }
+- MOV ES,WORD PTR TempP[00002h]
+- DB 066h; MOV DI,WORD PTR CopyDestination
+- { *** calculate number of full sample-loops to copy }
+- XOR DX,DX
+- MOV AX,c_LoopExtensionSize
+- MOV BX,WORD PTR CopyLength
+- DIV BX
+- OR AX,AX
+- JE @@NoFullLoop
+- { *** copy some full-loops (size=bx) }
+- MOV CX,AX
+- @@InnerLoop:
+- PUSH CX
+- DB 066h; MOV SI,WORD PTR CopySource
+- MOV CX,BX
+- DB 0F3h; DB 026h,067h,0A4h { REP MOVS BYTE PTR ES:[EDI],ES:[ESI] }
+- POP CX
+- LOOP @@InnerLoop
+- @@NoFullLoop:
+- { *** calculate number of rest-bytes to copy }
+- DB 066h; MOV SI,WORD PTR CopySource
+- MOV CX,DX
+- DB 0F3h; DB 026h,067h,0A4h { REP MOVS BYTE PTR ES:[EDI],ES:[ESI] }
+- END;
+- END
+- ELSE
+- BEGIN
+- CopyDestination := Module^.Module_SamplePointer^[I3]^.Sample_Length;
+- ASM
+- { *** load sample-selector }
+- MOV ES,WORD PTR TempP[00002h]
+- DB 066h; MOV DI,WORD PTR CopyDestination
+- { *** clear extension }
+- MOV CX,c_LoopExtensionSize
+- MOV AL,080h
+- DB 0F3h; DB 067h,0AAh { REP STOS BYTE PTR ES:[EDI] }
+- END;
+- END;
+- END;
+- { *** next sample }
+- END;
+- { *** init period-ranges }
+- NTMIK_MaximumPeriod := $0000D600 SHR 1;
+- NTMIK_MinimumPeriod := $0000D600 SHR 8;
+- { *** close file }
+- CLOSE(InFile);
+- { *** dispose all dynamic variables }
+- DISPOSE(Header);
+- DISPOSE(Sample);
+- DISPOSE(Order);
+- DISPOSE(ChannelSettings);
+- DISPOSE(MultiPurposeBuffer);
+- DISPOSE(PatternBuffer);
+- { *** set errorcode to noerror }
+- ErrorCode := c_NoError;
+- END;
+-
+-*/
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_ptm.cxx audacious-plugins-2.5.4/src/modplug/load_ptm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_ptm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_ptm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,208 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-//////////////////////////////////////////////
+-// PTM PolyTracker module loader //
+-//////////////////////////////////////////////
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#pragma pack(1)
+-
+-typedef struct PTMFILEHEADER
+-{
+- CHAR songname[28]; // name of song, asciiz string
+- CHAR eof; // 26
+- BYTE version_lo; // 03 version of file, currently 0203h
+- BYTE version_hi; // 02
+- BYTE reserved1; // reserved, set to 0
+- WORD norders; // number of orders (0..256)
+- WORD nsamples; // number of instruments (1..255)
+- WORD npatterns; // number of patterns (1..128)
+- WORD nchannels; // number of channels (voices) used (1..32)
+- WORD fileflags; // set to 0
+- WORD reserved2; // reserved, set to 0
+- DWORD ptmf_id; // song identification, 'PTMF' or 0x464d5450
+- BYTE reserved3[16]; // reserved, set to 0
+- BYTE chnpan[32]; // channel panning settings, 0..15, 0 = left, 7 = middle, 15 = right
+- BYTE orders[256]; // order list, valid entries 0..nOrders-1
+- WORD patseg[128]; // pattern offsets (*16)
+-} PTMFILEHEADER, *LPPTMFILEHEADER;
+-
+-#define SIZEOF_PTMFILEHEADER 608
+-
+-
+-typedef struct PTMSAMPLE
+-{
+- BYTE sampletype; // sample type (bit array)
+- CHAR filename[12]; // name of external sample file
+- BYTE volume; // default volume
+- WORD nC4Spd; // C4 speed
+- WORD sampleseg; // sample segment (used internally)
+- WORD fileofs[2]; // offset of sample data
+- WORD length[2]; // sample size (in bytes)
+- WORD loopbeg[2]; // start of loop
+- WORD loopend[2]; // end of loop
+- WORD gusdata[8];
+- char samplename[28]; // name of sample, asciiz // changed from CHAR
+- DWORD ptms_id; // sample identification, 'PTMS' or 0x534d5450
+-} PTMSAMPLE;
+-
+-#define SIZEOF_PTMSAMPLE 80
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadPTM(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- PTMFILEHEADER pfh = *(LPPTMFILEHEADER)lpStream;
+- DWORD dwMemPos;
+- UINT nOrders;
+-
+- pfh.norders = bswapLE16(pfh.norders);
+- pfh.nsamples = bswapLE16(pfh.nsamples);
+- pfh.npatterns = bswapLE16(pfh.npatterns);
+- pfh.nchannels = bswapLE16(pfh.nchannels);
+- pfh.fileflags = bswapLE16(pfh.fileflags);
+- pfh.reserved2 = bswapLE16(pfh.reserved2);
+- pfh.ptmf_id = bswapLE32(pfh.ptmf_id);
+- for (UINT j=0; j<128; j++)
+- {
+- pfh.patseg[j] = bswapLE16(pfh.patseg[j]);
+- }
+-
+- if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
+- if ((pfh.ptmf_id != 0x464d5450) || (!pfh.nchannels)
+- || (pfh.nchannels > 32)
+- || (pfh.norders > 256) || (!pfh.norders)
+- || (!pfh.nsamples) || (pfh.nsamples > 255)
+- || (!pfh.npatterns) || (pfh.npatterns > 128)
+- || (SIZEOF_PTMFILEHEADER+pfh.nsamples*SIZEOF_PTMSAMPLE >= (int)dwMemLength)) return FALSE;
+- memcpy(m_szNames[0], pfh.songname, 28);
+- m_szNames[0][28] = 0;
+- m_nType = MOD_TYPE_PTM;
+- m_nChannels = pfh.nchannels;
+- m_nSamples = (pfh.nsamples < MAX_SAMPLES) ? pfh.nsamples : MAX_SAMPLES-1;
+- dwMemPos = SIZEOF_PTMFILEHEADER;
+- nOrders = (pfh.norders < MAX_ORDERS) ? pfh.norders : MAX_ORDERS-1;
+- memcpy(Order, pfh.orders, nOrders);
+- for (UINT ipan=0; ipan<m_nChannels; ipan++)
+- {
+- ChnSettings[ipan].nVolume = 64;
+- ChnSettings[ipan].nPan = ((pfh.chnpan[ipan] & 0x0F) << 4) + 4;
+- }
+- for (UINT ismp=0; ismp<m_nSamples; ismp++, dwMemPos += SIZEOF_PTMSAMPLE)
+- {
+- MODINSTRUMENT *pins = &Ins[ismp+1];
+- PTMSAMPLE *psmp = (PTMSAMPLE *)(lpStream+dwMemPos);
+-
+- lstrcpyn(m_szNames[ismp+1], psmp->samplename, 28);
+- memcpy(pins->name, psmp->filename, 12);
+- pins->name[12] = 0;
+- pins->nGlobalVol = 64;
+- pins->nPan = 128;
+- pins->nVolume = psmp->volume << 2;
+- pins->nC4Speed = bswapLE16(psmp->nC4Spd) << 1;
+- pins->uFlags = 0;
+- if ((psmp->sampletype & 3) == 1)
+- {
+- UINT smpflg = RS_PCM8D;
+- DWORD samplepos;
+- pins->nLength = bswapLE32(*psmp->length);
+- pins->nLoopStart = bswapLE32(*psmp->loopbeg);
+- pins->nLoopEnd = bswapLE32(*psmp->loopend);
+- samplepos = bswapLE32(*psmp->fileofs);
+- if (psmp->sampletype & 4) pins->uFlags |= CHN_LOOP;
+- if (psmp->sampletype & 8) pins->uFlags |= CHN_PINGPONGLOOP;
+- if (psmp->sampletype & 16)
+- {
+- pins->uFlags |= CHN_16BIT;
+- pins->nLength >>= 1;
+- pins->nLoopStart >>= 1;
+- pins->nLoopEnd >>= 1;
+- smpflg = RS_PTM8DTO16;
+- }
+- if ((pins->nLength) && (samplepos) && (samplepos < dwMemLength))
+- {
+- ReadSample(pins, smpflg, (LPSTR)(lpStream+samplepos), dwMemLength-samplepos);
+- }
+- }
+- }
+- // Reading Patterns
+- for (UINT ipat=0; ipat<pfh.npatterns; ipat++)
+- {
+- dwMemPos = ((UINT)pfh.patseg[ipat]) << 4;
+- if ((!dwMemPos) || (dwMemPos >= dwMemLength)) continue;
+- PatternSize[ipat] = 64;
+- PatternAllocSize[ipat] = 64;
+- if ((Patterns[ipat] = AllocatePattern(64, m_nChannels)) == NULL) break;
+- //
+- MODCOMMAND *m = Patterns[ipat];
+- for (UINT row=0; ((row < 64) && (dwMemPos < dwMemLength)); )
+- {
+- UINT b = lpStream[dwMemPos++];
+-
+- if (dwMemPos >= dwMemLength) break;
+- if (b)
+- {
+- UINT nChn = b & 0x1F;
+-
+- if (b & 0x20)
+- {
+- if (dwMemPos + 2 > dwMemLength) break;
+- m[nChn].note = lpStream[dwMemPos++];
+- m[nChn].instr = lpStream[dwMemPos++];
+- }
+- if (b & 0x40)
+- {
+- if (dwMemPos + 2 > dwMemLength) break;
+- m[nChn].command = lpStream[dwMemPos++];
+- m[nChn].param = lpStream[dwMemPos++];
+- if ((m[nChn].command == 0x0E) && ((m[nChn].param & 0xF0) == 0x80))
+- {
+- m[nChn].command = CMD_S3MCMDEX;
+- } else
+- if (m[nChn].command < 0x10)
+- {
+- ConvertModCommand(&m[nChn]);
+- } else
+- {
+- switch(m[nChn].command)
+- {
+- case 16:
+- m[nChn].command = CMD_GLOBALVOLUME;
+- break;
+- case 17:
+- m[nChn].command = CMD_RETRIG;
+- break;
+- case 18:
+- m[nChn].command = CMD_FINEVIBRATO;
+- break;
+- default:
+- m[nChn].command = 0;
+- }
+- }
+- }
+- if (b & 0x80)
+- {
+- if (dwMemPos >= dwMemLength) break;
+- m[nChn].volcmd = VOLCMD_VOLUME;
+- m[nChn].vol = lpStream[dwMemPos++];
+- }
+- } else
+- {
+- row++;
+- m += m_nChannels;
+- }
+- }
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_s3m.cxx audacious-plugins-2.5.4/src/modplug/load_s3m.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_s3m.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_s3m.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,406 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-extern WORD S3MFineTuneTable[16];
+-
+-//////////////////////////////////////////////////////
+-// ScreamTracker S3M file support
+-
+-typedef struct tagS3MSAMPLESTRUCT
+-{
+- BYTE type;
+- CHAR dosname[12];
+- BYTE hmem;
+- WORD memseg;
+- DWORD length;
+- DWORD loopbegin;
+- DWORD loopend;
+- BYTE vol;
+- BYTE bReserved;
+- BYTE pack;
+- BYTE flags;
+- DWORD finetune;
+- DWORD dwReserved;
+- WORD intgp;
+- WORD int512;
+- DWORD lastused;
+- CHAR name[28];
+- CHAR scrs[4];
+-} S3MSAMPLESTRUCT;
+-
+-
+-typedef struct tagS3MFILEHEADER
+-{
+- CHAR name[28];
+- BYTE b1A;
+- BYTE type;
+- WORD reserved1;
+- WORD ordnum;
+- WORD insnum;
+- WORD patnum;
+- WORD flags;
+- WORD cwtv;
+- WORD version;
+- DWORD scrm; // "SCRM" = 0x4D524353
+- BYTE globalvol;
+- BYTE speed;
+- BYTE tempo;
+- BYTE mastervol;
+- BYTE ultraclicks;
+- BYTE panning_present;
+- BYTE reserved2[8];
+- WORD special;
+- BYTE channels[32];
+-} S3MFILEHEADER;
+-
+-
+-void CSoundFile::S3MConvert(MODCOMMAND *m, BOOL bIT) const
+-//--------------------------------------------------------
+-{
+- UINT command = m->command;
+- UINT param = m->param;
+- switch (command + 0x40)
+- {
+- case 'A': command = CMD_SPEED; break;
+- case 'B': command = CMD_POSITIONJUMP; break;
+- case 'C': command = CMD_PATTERNBREAK; if (!bIT) param = (param >> 4) * 10 + (param & 0x0F); break;
+- case 'D': command = CMD_VOLUMESLIDE; break;
+- case 'E': command = CMD_PORTAMENTODOWN; break;
+- case 'F': command = CMD_PORTAMENTOUP; break;
+- case 'G': command = CMD_TONEPORTAMENTO; break;
+- case 'H': command = CMD_VIBRATO; break;
+- case 'I': command = CMD_TREMOR; break;
+- case 'J': command = CMD_ARPEGGIO; break;
+- case 'K': command = CMD_VIBRATOVOL; break;
+- case 'L': command = CMD_TONEPORTAVOL; break;
+- case 'M': command = CMD_CHANNELVOLUME; break;
+- case 'N': command = CMD_CHANNELVOLSLIDE; break;
+- case 'O': command = CMD_OFFSET; break;
+- case 'P': command = CMD_PANNINGSLIDE; break;
+- case 'Q': command = CMD_RETRIG; break;
+- case 'R': command = CMD_TREMOLO; break;
+- case 'S': command = CMD_S3MCMDEX; break;
+- case 'T': command = CMD_TEMPO; break;
+- case 'U': command = CMD_FINEVIBRATO; break;
+- case 'V': command = CMD_GLOBALVOLUME; if (!bIT) param *= 2; break;
+- case 'W': command = CMD_GLOBALVOLSLIDE; break;
+- case 'X': command = CMD_PANNING8; break;
+- case 'Y': command = CMD_PANBRELLO; break;
+- case 'Z': command = CMD_MIDI; break;
+- default: command = 0;
+- }
+- m->command = command;
+- m->param = param;
+-}
+-
+-
+-void CSoundFile::S3MSaveConvert(UINT *pcmd, UINT *pprm, BOOL bIT) const
+-//---------------------------------------------------------------------
+-{
+- UINT command = *pcmd;
+- UINT param = *pprm;
+- switch(command)
+- {
+- case CMD_SPEED: command = 'A'; break;
+- case CMD_POSITIONJUMP: command = 'B'; break;
+- case CMD_PATTERNBREAK: command = 'C'; if (!bIT) param = ((param / 10) << 4) + (param % 10); break;
+- case CMD_VOLUMESLIDE: command = 'D'; break;
+- case CMD_PORTAMENTODOWN: command = 'E'; if ((param >= 0xE0) && (m_nType & (MOD_TYPE_MOD|MOD_TYPE_XM))) param = 0xDF; break;
+- case CMD_PORTAMENTOUP: command = 'F'; if ((param >= 0xE0) && (m_nType & (MOD_TYPE_MOD|MOD_TYPE_XM))) param = 0xDF; break;
+- case CMD_TONEPORTAMENTO: command = 'G'; break;
+- case CMD_VIBRATO: command = 'H'; break;
+- case CMD_TREMOR: command = 'I'; break;
+- case CMD_ARPEGGIO: command = 'J'; break;
+- case CMD_VIBRATOVOL: command = 'K'; break;
+- case CMD_TONEPORTAVOL: command = 'L'; break;
+- case CMD_CHANNELVOLUME: command = 'M'; break;
+- case CMD_CHANNELVOLSLIDE: command = 'N'; break;
+- case CMD_OFFSET: command = 'O'; break;
+- case CMD_PANNINGSLIDE: command = 'P'; break;
+- case CMD_RETRIG: command = 'Q'; break;
+- case CMD_TREMOLO: command = 'R'; break;
+- case CMD_S3MCMDEX: command = 'S'; break;
+- case CMD_TEMPO: command = 'T'; break;
+- case CMD_FINEVIBRATO: command = 'U'; break;
+- case CMD_GLOBALVOLUME: command = 'V'; if (!bIT) param >>= 1;break;
+- case CMD_GLOBALVOLSLIDE: command = 'W'; break;
+- case CMD_PANNING8:
+- command = 'X';
+- if ((bIT) && (m_nType != MOD_TYPE_IT) && (m_nType != MOD_TYPE_XM))
+- {
+- if (param == 0xA4) { command = 'S'; param = 0x91; } else
+- if (param <= 0x80) { param <<= 1; if (param > 255) param = 255; } else
+- command = param = 0;
+- } else
+- if ((!bIT) && ((m_nType == MOD_TYPE_IT) || (m_nType == MOD_TYPE_XM)))
+- {
+- param >>= 1;
+- }
+- break;
+- case CMD_PANBRELLO: command = 'Y'; break;
+- case CMD_MIDI: command = 'Z'; break;
+- case CMD_XFINEPORTAUPDOWN:
+- if (param & 0x0F) switch(param & 0xF0)
+- {
+- case 0x10: command = 'F'; param = (param & 0x0F) | 0xE0; break;
+- case 0x20: command = 'E'; param = (param & 0x0F) | 0xE0; break;
+- case 0x90: command = 'S'; break;
+- default: command = param = 0;
+- } else command = param = 0;
+- break;
+- case CMD_MODCMDEX:
+- command = 'S';
+- switch(param & 0xF0)
+- {
+- case 0x00: command = param = 0; break;
+- case 0x10: command = 'F'; param |= 0xF0; break;
+- case 0x20: command = 'E'; param |= 0xF0; break;
+- case 0x30: param = (param & 0x0F) | 0x10; break;
+- case 0x40: param = (param & 0x0F) | 0x30; break;
+- case 0x50: param = (param & 0x0F) | 0x20; break;
+- case 0x60: param = (param & 0x0F) | 0xB0; break;
+- case 0x70: param = (param & 0x0F) | 0x40; break;
+- case 0x90: command = 'Q'; param &= 0x0F; break;
+- case 0xA0: if (param & 0x0F) { command = 'D'; param = (param << 4) | 0x0F; } else command=param=0; break;
+- case 0xB0: if (param & 0x0F) { command = 'D'; param |= 0xF0; } else command=param=0; break;
+- }
+- break;
+- default: command = param = 0;
+- }
+- command &= ~0x40;
+- *pcmd = command;
+- *pprm = param;
+-}
+-
+-
+-BOOL CSoundFile::ReadS3M(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- UINT insnum,patnum,nins,npat;
+- DWORD insfile[128];
+- WORD ptr[256];
+- BYTE s[1024];
+- DWORD dwMemPos;
+- BYTE insflags[128], inspack[128];
+- S3MFILEHEADER psfh = *(S3MFILEHEADER *)lpStream;
+-
+- psfh.reserved1 = bswapLE16(psfh.reserved1);
+- psfh.ordnum = bswapLE16(psfh.ordnum);
+- psfh.insnum = bswapLE16(psfh.insnum);
+- psfh.patnum = bswapLE16(psfh.patnum);
+- psfh.flags = bswapLE16(psfh.flags);
+- psfh.cwtv = bswapLE16(psfh.cwtv);
+- psfh.version = bswapLE16(psfh.version);
+- psfh.scrm = bswapLE32(psfh.scrm);
+- psfh.special = bswapLE16(psfh.special);
+-
+- if ((!lpStream) || (dwMemLength <= sizeof(S3MFILEHEADER)+sizeof(S3MSAMPLESTRUCT)+64)) return FALSE;
+- if (psfh.scrm != 0x4D524353) return FALSE;
+- dwMemPos = 0x60;
+- m_nType = MOD_TYPE_S3M;
+- memset(m_szNames,0,sizeof(m_szNames));
+- memcpy(m_szNames[0], psfh.name, 28);
+- // Speed
+- m_nDefaultSpeed = psfh.speed;
+- if (m_nDefaultSpeed < 1) m_nDefaultSpeed = 6;
+- if (m_nDefaultSpeed > 0x1F) m_nDefaultSpeed = 0x1F;
+- // Tempo
+- m_nDefaultTempo = psfh.tempo;
+- if (m_nDefaultTempo < 40) m_nDefaultTempo = 40;
+- if (m_nDefaultTempo > 240) m_nDefaultTempo = 240;
+- // Global Volume
+- m_nDefaultGlobalVolume = psfh.globalvol << 2;
+- if ((!m_nDefaultGlobalVolume) || (m_nDefaultGlobalVolume > 256)) m_nDefaultGlobalVolume = 256;
+- m_nSongPreAmp = psfh.mastervol & 0x7F;
+- // Channels
+- m_nChannels = 4;
+- for (UINT ich=0; ich<32; ich++)
+- {
+- ChnSettings[ich].nPan = 128;
+- ChnSettings[ich].nVolume = 64;
+-
+- ChnSettings[ich].dwFlags = CHN_MUTE;
+- if (psfh.channels[ich] != 0xFF)
+- {
+- m_nChannels = ich+1;
+- UINT b = psfh.channels[ich] & 0x0F;
+- ChnSettings[ich].nPan = (b & 8) ? 0xC0 : 0x40;
+- ChnSettings[ich].dwFlags = 0;
+- }
+- }
+- if (m_nChannels < 4) m_nChannels = 4;
+- if ((psfh.cwtv < 0x1320) || (psfh.flags & 0x40)) m_dwSongFlags |= SONG_FASTVOLSLIDES;
+- // Reading pattern order
+- UINT iord = psfh.ordnum;
+- if (iord<1) iord = 1;
+- if (iord > MAX_ORDERS) iord = MAX_ORDERS;
+- if (iord)
+- {
+- memcpy(Order, lpStream+dwMemPos, iord);
+- dwMemPos += iord;
+- }
+- if ((iord & 1) && (lpStream[dwMemPos] == 0xFF)) dwMemPos++;
+- // Reading file pointers
+- insnum = nins = psfh.insnum;
+- if (insnum >= MAX_SAMPLES) insnum = MAX_SAMPLES-1;
+- m_nSamples = insnum;
+- patnum = npat = psfh.patnum;
+- if (patnum > MAX_PATTERNS) patnum = MAX_PATTERNS;
+- memset(ptr, 0, sizeof(ptr));
+- if (nins+npat)
+- {
+- memcpy(ptr, lpStream+dwMemPos, 2*(nins+npat));
+- dwMemPos += 2*(nins+npat);
+- for (UINT j = 0; j < (nins+npat); ++j) {
+- ptr[j] = bswapLE16(ptr[j]);
+- }
+- if (psfh.panning_present == 252)
+- {
+- const BYTE *chnpan = lpStream+dwMemPos;
+- for (UINT i=0; i<32; i++) if (chnpan[i] & 0x20)
+- {
+- ChnSettings[i].nPan = ((chnpan[i] & 0x0F) << 4) + 8;
+- }
+- }
+- }
+- if (!m_nChannels) return TRUE;
+- // Reading instrument headers
+- memset(insfile, 0, sizeof(insfile));
+- for (UINT iSmp=1; iSmp<=insnum; iSmp++)
+- {
+- UINT nInd = ((DWORD)ptr[iSmp-1])*16;
+- if ((!nInd) || (nInd + 0x50 > dwMemLength)) continue;
+- memcpy(s, lpStream+nInd, 0x50);
+- memcpy(Ins[iSmp].name, s+1, 12);
+- insflags[iSmp-1] = s[0x1F];
+- inspack[iSmp-1] = s[0x1E];
+- s[0x4C] = 0;
+- lstrcpy(m_szNames[iSmp], (LPCSTR)&s[0x30]);
+- if ((s[0]==1) && (s[0x4E]=='R') && (s[0x4F]=='S'))
+- {
+- UINT j = bswapLE32(*((LPDWORD)(s+0x10)));
+- if (j > MAX_SAMPLE_LENGTH) j = MAX_SAMPLE_LENGTH;
+- if (j < 2) j = 0;
+- Ins[iSmp].nLength = j;
+- j = bswapLE32(*((LPDWORD)(s+0x14)));
+- if (j >= Ins[iSmp].nLength) j = Ins[iSmp].nLength - 1;
+- Ins[iSmp].nLoopStart = j;
+- j = bswapLE32(*((LPDWORD)(s+0x18)));
+- if (j > MAX_SAMPLE_LENGTH) j = MAX_SAMPLE_LENGTH;
+- if (j < 2) j = 0;
+- if (j > Ins[iSmp].nLength) j = Ins[iSmp].nLength;
+- Ins[iSmp].nLoopEnd = j;
+- j = s[0x1C];
+- if (j > 64) j = 64;
+- Ins[iSmp].nVolume = j << 2;
+- Ins[iSmp].nGlobalVol = 64;
+- if (s[0x1F]&1) Ins[iSmp].uFlags |= CHN_LOOP;
+- j = bswapLE32(*((LPDWORD)(s+0x20)));
+- if (!j) j = 8363;
+- if (j < 1024) j = 1024;
+- Ins[iSmp].nC4Speed = j;
+- insfile[iSmp] = ((DWORD)bswapLE16(*((LPWORD)(s+0x0E)))) << 4;
+- insfile[iSmp] += ((DWORD)(BYTE)s[0x0D]) << 20;
+- if (insfile[iSmp] > dwMemLength) insfile[iSmp] &= 0xFFFF;
+- if ((Ins[iSmp].nLoopStart >= Ins[iSmp].nLoopEnd) || (Ins[iSmp].nLoopEnd - Ins[iSmp].nLoopStart < 8))
+- Ins[iSmp].nLoopStart = Ins[iSmp].nLoopEnd = 0;
+- Ins[iSmp].nPan = 0x80;
+- }
+- }
+- // Reading patterns
+- for (UINT iPat=0; iPat<patnum; iPat++)
+- {
+- UINT nInd = ((DWORD)ptr[nins+iPat]) << 4;
+- // if the parapointer is zero, the pattern is blank (so ignore it)
+- if (nInd == 0)
+- continue;
+- if (nInd + 0x40 > dwMemLength) continue;
+- WORD len = bswapLE16(*((WORD *)(lpStream+nInd)));
+- nInd += 2;
+- PatternSize[iPat] = 64;
+- PatternAllocSize[iPat] = 64;
+- if ((!len) || (nInd + len > dwMemLength - 6)
+- || ((Patterns[iPat] = AllocatePattern(64, m_nChannels)) == NULL)) continue;
+- LPBYTE src = (LPBYTE)(lpStream+nInd);
+- // Unpacking pattern
+- MODCOMMAND *p = Patterns[iPat];
+- UINT row = 0;
+- UINT j = 0;
+- while (j < len)
+- {
+- BYTE b = src[j++];
+- if (!b)
+- {
+- if (++row >= 64) break;
+- } else
+- {
+- UINT chn = b & 0x1F;
+- if (chn < m_nChannels)
+- {
+- MODCOMMAND *m = &p[row*m_nChannels+chn];
+- if (b & 0x20)
+- {
+- m->note = src[j++];
+- if (m->note < 0xF0) m->note = (m->note & 0x0F) + 12*(m->note >> 4) + 13;
+- else if (m->note == 0xFF) m->note = 0;
+- m->instr = src[j++];
+- }
+- if (b & 0x40)
+- {
+- UINT vol = src[j++];
+- if ((vol >= 128) && (vol <= 192))
+- {
+- vol -= 128;
+- m->volcmd = VOLCMD_PANNING;
+- } else
+- {
+- if (vol > 64) vol = 64;
+- m->volcmd = VOLCMD_VOLUME;
+- }
+- m->vol = vol;
+- }
+- if (b & 0x80)
+- {
+- m->command = src[j++];
+- m->param = src[j++];
+- if (m->command) S3MConvert(m, FALSE);
+- }
+- } else
+- {
+- if (b & 0x20) j += 2;
+- if (b & 0x40) j++;
+- if (b & 0x80) j += 2;
+- }
+- if (j >= len) break;
+- }
+- }
+- }
+- // Reading samples
+- for (UINT iRaw=1; iRaw<=insnum; iRaw++) if ((Ins[iRaw].nLength) && (insfile[iRaw]))
+- {
+- UINT flags;
+- if (insflags[iRaw-1] & 4)
+- flags = (psfh.version == 1) ? RS_PCM16S : RS_PCM16U;
+- else
+- flags = (psfh.version == 1) ? RS_PCM8S : RS_PCM8U;
+- if (insflags[iRaw-1] & 2) flags |= RSF_STEREO;
+- if (inspack[iRaw-1] == 4) flags = RS_ADPCM4;
+- dwMemPos = insfile[iRaw];
+- dwMemPos += ReadSample(&Ins[iRaw], flags, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+- }
+- m_nMinPeriod = 64;
+- m_nMaxPeriod = 32767;
+- if (psfh.flags & 0x10) m_dwSongFlags |= SONG_AMIGALIMITS;
+- return TRUE;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_stm.cxx audacious-plugins-2.5.4/src/modplug/load_stm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_stm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_stm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,187 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#pragma pack(1)
+-
+-typedef struct tagSTMNOTE
+-{
+- BYTE note;
+- BYTE insvol;
+- BYTE volcmd;
+- BYTE cmdinf;
+-} STMNOTE;
+-
+-
+-// Raw STM sampleinfo struct:
+-typedef struct tagSTMSAMPLE
+-{
+- CHAR filename[14]; // Can't have long comments - just filename comments :)
+- WORD reserved; // ISA in memory when in ST 2
+- WORD length; // Sample length
+- WORD loopbeg; // Loop start point
+- WORD loopend; // Loop end point
+- BYTE volume; // Volume
+- BYTE reserved2; // More reserved crap
+- WORD c2spd; // Good old c2spd
+- BYTE reserved3[6]; // Yet more of PSi's reserved crap
+-} STMSAMPLE;
+-
+-
+-// Raw STM header struct:
+-typedef struct tagSTMHEADER
+-{
+- char songname[20]; // changed from CHAR
+- char trackername[8]; // !SCREAM! for ST 2.xx // changed from CHAR
+- CHAR unused; // 0x1A
+- CHAR filetype; // 1=song, 2=module (only 2 is supported, of course) :)
+- CHAR ver_major; // Like 2
+- CHAR ver_minor; // "ditto"
+- BYTE inittempo; // initspeed= stm inittempo>>4
+- BYTE numpat; // number of patterns
+- BYTE globalvol; // <- WoW! a RiGHT TRiANGLE =8*)
+- BYTE reserved[13]; // More of PSi's internal crap
+- STMSAMPLE sample[31]; // STM sample data
+- BYTE patorder[128]; // Docs say 64 - actually 128
+-} STMHEADER;
+-
+-#pragma pack()
+-
+-
+-
+-BOOL CSoundFile::ReadSTM(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- STMHEADER *phdr = (STMHEADER *)lpStream;
+- DWORD dwMemPos = 0;
+-
+- if ((!lpStream) || (dwMemLength < sizeof(STMHEADER))) return FALSE;
+- if ((phdr->filetype != 2) || (phdr->unused != 0x1A)
+- || ((strnicmp(phdr->trackername, "!SCREAM!", 8))
+- && (strnicmp(phdr->trackername, "BMOD2STM", 8)))) return FALSE;
+- memcpy(m_szNames[0], phdr->songname, 20);
+- // Read STM header
+- m_nType = MOD_TYPE_STM;
+- m_nSamples = 31;
+- m_nChannels = 4;
+- m_nInstruments = 0;
+- m_nMinPeriod = 64;
+- m_nMaxPeriod = 0x7FFF;
+- m_nDefaultSpeed = phdr->inittempo >> 4;
+- if (m_nDefaultSpeed < 1) m_nDefaultSpeed = 1;
+- m_nDefaultTempo = 125;
+- m_nDefaultGlobalVolume = phdr->globalvol << 2;
+- if (m_nDefaultGlobalVolume > 256) m_nDefaultGlobalVolume = 256;
+- memcpy(Order, phdr->patorder, 128);
+- // Setting up channels
+- for (UINT nSet=0; nSet<4; nSet++)
+- {
+- ChnSettings[nSet].dwFlags = 0;
+- ChnSettings[nSet].nVolume = 64;
+- ChnSettings[nSet].nPan = (nSet & 1) ? 0x40 : 0xC0;
+- }
+- // Reading samples
+- for (UINT nIns=0; nIns<31; nIns++)
+- {
+- MODINSTRUMENT *pIns = &Ins[nIns+1];
+- STMSAMPLE *pStm = &phdr->sample[nIns]; // STM sample data
+- memcpy(pIns->name, pStm->filename, 13);
+- memcpy(m_szNames[nIns+1], pStm->filename, 12);
+- pIns->nC4Speed = bswapLE16(pStm->c2spd);
+- pIns->nGlobalVol = 64;
+- pIns->nVolume = pStm->volume << 2;
+- if (pIns->nVolume > 256) pIns->nVolume = 256;
+- pIns->nLength = bswapLE16(pStm->length);
+- if ((pIns->nLength < 4) || (!pIns->nVolume)) pIns->nLength = 0;
+- pIns->nLoopStart = bswapLE16(pStm->loopbeg);
+- pIns->nLoopEnd = bswapLE16(pStm->loopend);
+- if ((pIns->nLoopEnd > pIns->nLoopStart) && (pIns->nLoopEnd != 0xFFFF)) pIns->uFlags |= CHN_LOOP;
+- }
+- dwMemPos = sizeof(STMHEADER);
+- for (UINT nOrd=0; nOrd<MAX_ORDERS; nOrd++) if (Order[nOrd] >= 99) Order[nOrd] = 0xFF;
+- UINT nPatterns = phdr->numpat;
+- for (UINT nPat=0; nPat<nPatterns; nPat++)
+- {
+- if (dwMemPos + 64*4*4 > dwMemLength) return TRUE;
+- PatternSize[nPat] = 64;
+- PatternAllocSize[nPat] = 64;
+- if ((Patterns[nPat] = AllocatePattern(64, m_nChannels)) == NULL) return TRUE;
+- MODCOMMAND *m = Patterns[nPat];
+- STMNOTE *p = (STMNOTE *)(lpStream + dwMemPos);
+- for (UINT n=0; n<64*4; n++, p++, m++)
+- {
+- UINT note,ins,vol,cmd;
+- // extract the various information from the 4 bytes that
+- // make up a single note
+- note = p->note;
+- ins = p->insvol >> 3;
+- vol = (p->insvol & 0x07) + (p->volcmd >> 1);
+- cmd = p->volcmd & 0x0F;
+- if ((ins) && (ins < 32)) m->instr = ins;
+- // special values of [SBYTE0] are handled here ->
+- // we have no idea if these strange values will ever be encountered
+- // but it appears as though stms sound correct.
+- if ((note == 0xFE) || (note == 0xFC)) m->note = 0xFE; else
+- // if note < 251, then all three bytes are stored in the file
+- if (note < 0xFC) m->note = (note >> 4)*12 + (note&0xf) + 37;
+- if (vol <= 64) { m->volcmd = VOLCMD_VOLUME; m->vol = vol; }
+- m->param = p->cmdinf;
+- switch(cmd)
+- {
+- // Axx set speed to xx
+- case 1: m->command = CMD_SPEED; m->param >>= 4; break;
+- // Bxx position jump
+- case 2: m->command = CMD_POSITIONJUMP; break;
+- // Cxx patternbreak to row xx
+- case 3: m->command = CMD_PATTERNBREAK; m->param = (m->param & 0xF0) * 10 + (m->param & 0x0F); break;
+- // Dxy volumeslide
+- case 4: m->command = CMD_VOLUMESLIDE; break;
+- // Exy toneslide down
+- case 5: m->command = CMD_PORTAMENTODOWN; break;
+- // Fxy toneslide up
+- case 6: m->command = CMD_PORTAMENTOUP; break;
+- // Gxx Tone portamento,speed xx
+- case 7: m->command = CMD_TONEPORTAMENTO; break;
+- // Hxy vibrato
+- case 8: m->command = CMD_VIBRATO; break;
+- // Ixy tremor, ontime x, offtime y
+- case 9: m->command = CMD_TREMOR; break;
+- // Jxy arpeggio
+- case 10: m->command = CMD_ARPEGGIO; break;
+- // Kxy Dual command H00 & Dxy
+- case 11: m->command = CMD_VIBRATOVOL; break;
+- // Lxy Dual command G00 & Dxy
+- case 12: m->command = CMD_TONEPORTAVOL; break;
+- // Xxx amiga command 8xx
+- case 0x18: m->command = CMD_PANNING8; break;
+- default:
+- m->command = m->param = 0;
+- }
+- }
+- dwMemPos += 64*4*4;
+- }
+- // Reading Samples
+- for (UINT nSmp=1; nSmp<=31; nSmp++)
+- {
+- MODINSTRUMENT *pIns = &Ins[nSmp];
+- dwMemPos = (dwMemPos + 15) & (~15);
+- if (pIns->nLength)
+- {
+- UINT nPos = ((UINT)phdr->sample[nSmp-1].reserved) << 4;
+- if ((nPos >= sizeof(STMHEADER)) && (nPos+pIns->nLength <= dwMemLength)) dwMemPos = nPos;
+- if (dwMemPos < dwMemLength)
+- {
+- dwMemPos += ReadSample(pIns, RS_PCM8S, (LPSTR)(lpStream+dwMemPos),dwMemLength-dwMemPos);
+- }
+- }
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_ult.cxx audacious-plugins-2.5.4/src/modplug/load_ult.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_ult.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_ult.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,223 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-//#pragma warning(disable:4244)
+-
+-#define ULT_16BIT 0x04
+-#define ULT_LOOP 0x08
+-#define ULT_BIDI 0x10
+-
+-#pragma pack(1)
+-
+-// Raw ULT header struct:
+-typedef struct tagULTHEADER
+-{
+- char id[15]; // changed from CHAR
+- char songtitle[32]; // changed from CHAR
+- BYTE reserved;
+-} ULTHEADER;
+-
+-
+-// Raw ULT sampleinfo struct:
+-typedef struct tagULTSAMPLE
+-{
+- CHAR samplename[32];
+- CHAR dosname[12];
+- LONG loopstart;
+- LONG loopend;
+- LONG sizestart;
+- LONG sizeend;
+- BYTE volume;
+- BYTE flags;
+- WORD finetune;
+-} ULTSAMPLE;
+-
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadUlt(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- ULTHEADER *pmh = (ULTHEADER *)lpStream;
+- ULTSAMPLE *pus;
+- UINT nos, nop;
+- DWORD dwMemPos = 0;
+-
+- // try to read module header
+- if ((!lpStream) || (dwMemLength < 0x100)) return FALSE;
+- if (strncmp(pmh->id,"MAS_UTrack_V00",14)) return FALSE;
+- // Warning! Not supported ULT format, trying anyway
+- // if ((pmh->id[14] < '1') || (pmh->id[14] > '4')) return FALSE;
+- m_nType = MOD_TYPE_ULT;
+- m_nDefaultSpeed = 6;
+- m_nDefaultTempo = 125;
+- memcpy(m_szNames[0], pmh->songtitle, 32);
+- // read songtext
+- dwMemPos = sizeof(ULTHEADER);
+- if ((pmh->reserved) && (dwMemPos + pmh->reserved * 32 < dwMemLength))
+- {
+- UINT len = pmh->reserved * 32;
+- m_lpszSongComments = new char[len + 1 + pmh->reserved];
+- if (m_lpszSongComments)
+- {
+- for (UINT l=0; l<pmh->reserved; l++)
+- {
+- memcpy(m_lpszSongComments+l*33, lpStream+dwMemPos+l*32, 32);
+- m_lpszSongComments[l*33+32] = 0x0D;
+- }
+- m_lpszSongComments[len] = 0;
+- }
+- dwMemPos += len;
+- }
+- if (dwMemPos >= dwMemLength) return TRUE;
+- nos = lpStream[dwMemPos++];
+- m_nSamples = nos;
+- if (m_nSamples >= MAX_SAMPLES) m_nSamples = MAX_SAMPLES-1;
+- UINT smpsize = 64;
+- if (pmh->id[14] >= '4') smpsize += 2;
+- if (dwMemPos + nos*smpsize + 256 + 2 > dwMemLength) return TRUE;
+- for (UINT ins=1; ins<=nos; ins++, dwMemPos+=smpsize) if (ins<=m_nSamples)
+- {
+- pus = (ULTSAMPLE *)(lpStream+dwMemPos);
+- MODINSTRUMENT *pins = &Ins[ins];
+- memcpy(m_szNames[ins], pus->samplename, 32);
+- memcpy(pins->name, pus->dosname, 12);
+- pins->nLoopStart = pus->loopstart;
+- pins->nLoopEnd = pus->loopend;
+- pins->nLength = pus->sizeend - pus->sizestart;
+- pins->nVolume = pus->volume;
+- pins->nGlobalVol = 64;
+- pins->nC4Speed = 8363;
+- if (pmh->id[14] >= '4')
+- {
+- pins->nC4Speed = pus->finetune;
+- }
+- if (pus->flags & ULT_LOOP) pins->uFlags |= CHN_LOOP;
+- if (pus->flags & ULT_BIDI) pins->uFlags |= CHN_PINGPONGLOOP;
+- if (pus->flags & ULT_16BIT)
+- {
+- pins->uFlags |= CHN_16BIT;
+- pins->nLoopStart >>= 1;
+- pins->nLoopEnd >>= 1;
+- }
+- }
+- memcpy(Order, lpStream+dwMemPos, 256);
+- dwMemPos += 256;
+- m_nChannels = lpStream[dwMemPos] + 1;
+- nop = lpStream[dwMemPos+1] + 1;
+- dwMemPos += 2;
+- if (m_nChannels > 32) m_nChannels = 32;
+- // Default channel settings
+- for (UINT nSet=0; nSet<m_nChannels; nSet++)
+- {
+- ChnSettings[nSet].nVolume = 64;
+- ChnSettings[nSet].nPan = (nSet & 1) ? 0x40 : 0xC0;
+- }
+- // read pan position table for v1.5 and higher
+- if(pmh->id[14]>='3')
+- {
+- if (dwMemPos + m_nChannels > dwMemLength) return TRUE;
+- for(UINT t=0; t<m_nChannels; t++)
+- {
+- ChnSettings[t].nPan = (lpStream[dwMemPos++] << 4) + 8;
+- if (ChnSettings[t].nPan > 256) ChnSettings[t].nPan = 256;
+- }
+- }
+- // Allocating Patterns
+- for (UINT nAllocPat=0; nAllocPat<nop; nAllocPat++)
+- {
+- if (nAllocPat < MAX_PATTERNS)
+- {
+- PatternSize[nAllocPat] = 64;
+- PatternAllocSize[nAllocPat] = 64;
+- Patterns[nAllocPat] = AllocatePattern(64, m_nChannels);
+- }
+- }
+- // Reading Patterns
+- for (UINT nChn=0; nChn<m_nChannels; nChn++)
+- {
+- for (UINT nPat=0; nPat<nop; nPat++)
+- {
+- MODCOMMAND *pat = NULL;
+-
+- if (nPat < MAX_PATTERNS)
+- {
+- pat = Patterns[nPat];
+- if (pat) pat += nChn;
+- }
+- UINT row = 0;
+- while (row < 64)
+- {
+- if (dwMemPos + 6 > dwMemLength) return TRUE;
+- UINT rep = 1;
+- UINT note = lpStream[dwMemPos++];
+- if (note == 0xFC)
+- {
+- rep = lpStream[dwMemPos];
+- note = lpStream[dwMemPos+1];
+- dwMemPos += 2;
+- }
+- UINT instr = lpStream[dwMemPos++];
+- UINT eff = lpStream[dwMemPos++];
+- UINT dat1 = lpStream[dwMemPos++];
+- UINT dat2 = lpStream[dwMemPos++];
+- UINT cmd1 = eff & 0x0F;
+- UINT cmd2 = eff >> 4;
+- if (cmd1 == 0x0C) dat1 >>= 2; else
+- if (cmd1 == 0x0B) { cmd1 = dat1 = 0; }
+- if (cmd2 == 0x0C) dat2 >>= 2; else
+- if (cmd2 == 0x0B) { cmd2 = dat2 = 0; }
+- while ((rep != 0) && (row < 64))
+- {
+- if (pat)
+- {
+- pat->instr = instr;
+- if (note) pat->note = note + 36;
+- if (cmd1 | dat1)
+- {
+- if (cmd1 == 0x0C)
+- {
+- pat->volcmd = VOLCMD_VOLUME;
+- pat->vol = dat1;
+- } else
+- {
+- pat->command = cmd1;
+- pat->param = dat1;
+- ConvertModCommand(pat);
+- }
+- }
+- if (cmd2 == 0x0C)
+- {
+- pat->volcmd = VOLCMD_VOLUME;
+- pat->vol = dat2;
+- } else
+- if ((cmd2 | dat2) && (!pat->command))
+- {
+- pat->command = cmd2;
+- pat->param = dat2;
+- ConvertModCommand(pat);
+- }
+- pat += m_nChannels;
+- }
+- row++;
+- rep--;
+- }
+- }
+- }
+- }
+- // Reading Instruments
+- for (UINT smp=1; smp<=m_nSamples; smp++) if (Ins[smp].nLength)
+- {
+- if (dwMemPos >= dwMemLength) return TRUE;
+- UINT flags = (Ins[smp].uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
+- dwMemPos += ReadSample(&Ins[smp], flags, (LPSTR)(lpStream+dwMemPos), dwMemLength - dwMemPos);
+- }
+- return TRUE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_umx.cxx audacious-plugins-2.5.4/src/modplug/load_umx.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_umx.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_umx.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,53 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#define MODMAGIC_OFFSET (20+31*30+130)
+-
+-
+-BOOL CSoundFile::ReadUMX(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- if ((!lpStream) || (dwMemLength < 0x800)) return FALSE;
+- // Rip Mods from UMX
+- if ((bswapLE32(*((DWORD *)(lpStream+0x20))) < dwMemLength)
+- && (bswapLE32(*((DWORD *)(lpStream+0x18))) <= dwMemLength - 0x10)
+- && (bswapLE32(*((DWORD *)(lpStream+0x18))) >= dwMemLength - 0x200))
+- {
+- for (UINT uscan=0x40; uscan<0x500; uscan++)
+- {
+- DWORD dwScan = bswapLE32(*((DWORD *)(lpStream+uscan)));
+- // IT
+- if (dwScan == 0x4D504D49)
+- {
+- DWORD dwRipOfs = uscan;
+- return ReadIT(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
+- }
+- // S3M
+- if (dwScan == 0x4D524353)
+- {
+- DWORD dwRipOfs = uscan - 44;
+- return ReadS3M(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
+- }
+- // XM
+- if (!strnicmp((LPCSTR)(lpStream+uscan), "Extended Module", 15))
+- {
+- DWORD dwRipOfs = uscan;
+- return ReadXM(lpStream + dwRipOfs, dwMemLength - dwRipOfs);
+- }
+- // MOD
+- if ((uscan > MODMAGIC_OFFSET) && (dwScan == 0x2e4b2e4d))
+- {
+- DWORD dwRipOfs = uscan - MODMAGIC_OFFSET;
+- return ReadMod(lpStream+dwRipOfs, dwMemLength-dwRipOfs);
+- }
+- }
+- }
+- return FALSE;
+-}
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_wav.cxx audacious-plugins-2.5.4/src/modplug/load_wav.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_wav.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_wav.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,248 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#ifndef WAVE_FORMAT_EXTENSIBLE
+-#define WAVE_FORMAT_EXTENSIBLE 0xFFFE
+-#endif
+-
+-/////////////////////////////////////////////////////////////
+-// WAV file support
+-
+-BOOL CSoundFile::ReadWav(const BYTE *lpStream, DWORD dwMemLength)
+-//---------------------------------------------------------------
+-{
+- DWORD dwMemPos = 0;
+- WAVEFILEHEADER phdr;
+- WAVEFORMATHEADER pfmt;
+-
+- if ((!lpStream)
+- || (dwMemLength < (DWORD)(sizeof(WAVEFORMATHEADER)+sizeof(WAVEFILEHEADER))))
+- return FALSE;
+-
+- memcpy(&phdr, lpStream, sizeof(phdr));
+- memcpy(&pfmt, lpStream+sizeof(phdr), sizeof(pfmt));
+-
+- phdr.id_RIFF = bswapLE32(phdr.id_RIFF);
+- phdr.filesize = bswapLE32(phdr.filesize);
+- phdr.id_WAVE = bswapLE32(phdr.id_WAVE);
+-
+- pfmt.id_fmt = bswapLE32(pfmt.id_fmt);
+- pfmt.hdrlen = bswapLE32(pfmt.hdrlen);
+- pfmt.format = bswapLE16(pfmt.format);
+- pfmt.channels = bswapLE16(pfmt.channels);
+- pfmt.freqHz = bswapLE32(pfmt.freqHz);
+- pfmt.bytessec = bswapLE32(pfmt.bytessec);
+- pfmt.samplesize = bswapLE16(pfmt.samplesize);
+- pfmt.bitspersample = bswapLE16(pfmt.bitspersample);
+-
+- if ((phdr.id_RIFF != IFFID_RIFF) || (phdr.id_WAVE != IFFID_WAVE)
+- || (pfmt.id_fmt != IFFID_fmt)) return FALSE;
+-
+- dwMemPos = sizeof(WAVEFILEHEADER) + 8 + pfmt.hdrlen;
+-
+- if ((dwMemPos + 8 >= dwMemLength)
+- || ((pfmt.format != WAVE_FORMAT_PCM) && (pfmt.format != WAVE_FORMAT_EXTENSIBLE))
+- || (pfmt.channels > 4)
+- || (!pfmt.channels)
+- || (!pfmt.freqHz)
+- || (pfmt.bitspersample & 7)
+- || (pfmt.bitspersample < 8)
+- || (pfmt.bitspersample > 32)) return FALSE;
+-
+- WAVEDATAHEADER pdata;
+-
+- for (;;)
+- {
+- memcpy(&pdata, lpStream+dwMemPos, sizeof(pdata));
+- pdata.id_data = bswapLE32(pdata.id_data);
+- pdata.length = bswapLE32(pdata.length);
+-
+- if (pdata.id_data == IFFID_data) break;
+- dwMemPos += pdata.length + 8;
+- if (dwMemPos + 8 >= dwMemLength) return FALSE;
+- }
+- m_nType = MOD_TYPE_WAV;
+- m_nSamples = 0;
+- m_nInstruments = 0;
+- m_nChannels = 4;
+- m_nDefaultSpeed = 8;
+- m_nDefaultTempo = 125;
+- m_dwSongFlags |= SONG_LINEARSLIDES; // For no resampling
+- Order[0] = 0;
+- Order[1] = 0xFF;
+- PatternSize[0] = PatternSize[1] = 64;
+- PatternAllocSize[0] = PatternAllocSize[1] = 64;
+- if ((Patterns[0] = AllocatePattern(64, 4)) == NULL) return TRUE;
+- if ((Patterns[1] = AllocatePattern(64, 4)) == NULL) return TRUE;
+- UINT samplesize = (pfmt.channels * pfmt.bitspersample) >> 3;
+- UINT len = pdata.length, bytelen;
+- if (dwMemPos + len > dwMemLength - 8) len = dwMemLength - dwMemPos - 8;
+- len /= samplesize;
+- bytelen = len;
+- if (pfmt.bitspersample >= 16) bytelen *= 2;
+- if (len > MAX_SAMPLE_LENGTH) len = MAX_SAMPLE_LENGTH;
+- if (!len) return TRUE;
+- // Setting up module length
+- DWORD dwTime = ((len * 50) / pfmt.freqHz) + 1;
+- DWORD framesperrow = (dwTime + 63) / 63;
+- if (framesperrow < 4) framesperrow = 4;
+- UINT norders = 1;
+- while (framesperrow >= 0x20)
+- {
+- Order[norders++] = 1;
+- Order[norders] = 0xFF;
+- framesperrow = (dwTime + (64 * norders - 1)) / (64 * norders);
+- if (norders >= MAX_ORDERS-1) break;
+- }
+- m_nDefaultSpeed = framesperrow;
+- for (UINT iChn=0; iChn<4; iChn++)
+- {
+- ChnSettings[iChn].nPan = (iChn & 1) ? 256 : 0;
+- ChnSettings[iChn].nVolume = 64;
+- ChnSettings[iChn].dwFlags = 0;
+- }
+- // Setting up speed command
+- MODCOMMAND *pcmd = Patterns[0];
+- pcmd[0].command = CMD_SPEED;
+- pcmd[0].param = (BYTE)m_nDefaultSpeed;
+- pcmd[0].note = 5*12+1;
+- pcmd[0].instr = 1;
+- pcmd[1].note = pcmd[0].note;
+- pcmd[1].instr = pcmd[0].instr;
+- m_nSamples = pfmt.channels;
+- // Support for Multichannel Wave
+- for (UINT nChn=0; nChn<m_nSamples; nChn++)
+- {
+- MODINSTRUMENT *pins = &Ins[nChn+1];
+- pcmd[nChn].note = pcmd[0].note;
+- pcmd[nChn].instr = (BYTE)(nChn+1);
+- pins->nLength = len;
+- pins->nC4Speed = pfmt.freqHz;
+- pins->nVolume = 256;
+- pins->nPan = 128;
+- pins->nGlobalVol = 64;
+- pins->uFlags = (WORD)((pfmt.bitspersample >= 16) ? CHN_16BIT : 0);
+- pins->uFlags |= CHN_PANNING;
+- if (m_nSamples > 1)
+- {
+- switch(nChn)
+- {
+- case 0: pins->nPan = 0; break;
+- case 1: pins->nPan = 256; break;
+- case 2: pins->nPan = (WORD)((m_nSamples == 3) ? 128 : 64); pcmd[nChn].command = CMD_S3MCMDEX; pcmd[nChn].param = 0x91; break;
+- case 3: pins->nPan = 192; pcmd[nChn].command = CMD_S3MCMDEX; pcmd[nChn].param = 0x91; break;
+- default: pins->nPan = 128; break;
+- }
+- }
+- if ((pins->pSample = AllocateSample(bytelen+8)) == NULL) return TRUE;
+- if (pfmt.bitspersample >= 16)
+- {
+- int slsize = pfmt.bitspersample >> 3;
+- signed short *p = (signed short *)pins->pSample;
+- signed char *psrc = (signed char *)(lpStream+dwMemPos+8+nChn*slsize+slsize-2);
+- for (UINT i=0; i<len; i++)
+- {
+- p[i] = bswapLE16(*((signed short *)psrc));
+- psrc += samplesize;
+- }
+- p[len+1] = p[len] = p[len-1];
+- } else
+- {
+- signed char *p = (signed char *)pins->pSample;
+- signed char *psrc = (signed char *)(lpStream+dwMemPos+8+nChn);
+- for (UINT i=0; i<len; i++)
+- {
+- p[i] = (signed char)((*psrc) + 0x80);
+- psrc += samplesize;
+- }
+- p[len+1] = p[len] = p[len-1];
+- }
+- }
+- return TRUE;
+-}
+-
+-
+-////////////////////////////////////////////////////////////////////////
+-// IMA ADPCM Support
+-
+-#pragma pack(1)
+-
+-typedef struct IMAADPCMBLOCK
+-{
+- WORD sample;
+- BYTE index;
+- BYTE Reserved;
+-} DVI_ADPCMBLOCKHEADER;
+-
+-#pragma pack()
+-
+-static const int gIMAUnpackTable[90] =
+-{
+- 7, 8, 9, 10, 11, 12, 13, 14,
+- 16, 17, 19, 21, 23, 25, 28, 31,
+- 34, 37, 41, 45, 50, 55, 60, 66,
+- 73, 80, 88, 97, 107, 118, 130, 143,
+- 157, 173, 190, 209, 230, 253, 279, 307,
+- 337, 371, 408, 449, 494, 544, 598, 658,
+- 724, 796, 876, 963, 1060, 1166, 1282, 1411,
+- 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
+- 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
+- 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+- 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
+- 32767, 0
+-};
+-
+-
+-BOOL IMAADPCMUnpack16(signed short *pdest, UINT nLen, LPBYTE psrc, DWORD dwBytes, UINT pkBlkAlign)
+-//------------------------------------------------------------------------------------------------
+-{
+- static const int gIMAIndexTab[8] = { -1, -1, -1, -1, 2, 4, 6, 8 };
+- UINT nPos;
+- int value;
+-
+- if ((nLen < 4) || (!pdest) || (!psrc)
+- || (pkBlkAlign < 5) || (pkBlkAlign > dwBytes)) return FALSE;
+- nPos = 0;
+- while ((nPos < nLen) && (dwBytes > 4))
+- {
+- int nIndex;
+- value = bswapLE16(*((short int *)psrc));
+- nIndex = bswapLE16((short int)psrc[2]);
+- psrc += 4;
+- dwBytes -= 4;
+- pdest[nPos++] = (short int)value;
+- for (UINT i=0; ((i<(pkBlkAlign-4)*2) && (nPos < nLen) && (dwBytes)); i++)
+- {
+- BYTE delta;
+- if (i & 1)
+- {
+- delta = (BYTE)(((*(psrc++)) >> 4) & 0x0F);
+- dwBytes--;
+- } else
+- {
+- delta = (BYTE)((*psrc) & 0x0F);
+- }
+- int v = gIMAUnpackTable[nIndex % 90] >> 3;
+- if (delta & 1) v += gIMAUnpackTable[nIndex] >> 2;
+- if (delta & 2) v += gIMAUnpackTable[nIndex] >> 1;
+- if (delta & 4) v += gIMAUnpackTable[nIndex];
+- if (delta & 8) value -= v; else value += v;
+- nIndex += gIMAIndexTab[delta & 7];
+- if (nIndex < 0) nIndex = 0; else
+- if (nIndex > 88) nIndex = 88;
+- if (value > 32767) value = 32767; else
+- if (value < -32768) value = -32768;
+- pdest[nPos++] = (short int)value;
+- }
+- }
+- return TRUE;
+-}
+-
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/load_xm.cxx audacious-plugins-2.5.4/src/modplug/load_xm.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/load_xm.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/load_xm.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,529 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-////////////////////////////////////////////////////////
+-// FastTracker II XM file support
+-
+-#ifdef MSC_VER
+-#pragma warning(disable:4244)
+-#endif
+-
+-#pragma pack(1)
+-typedef struct tagXMFILEHEADER
+-{
+- DWORD size;
+- WORD norder;
+- WORD restartpos;
+- WORD channels;
+- WORD patterns;
+- WORD instruments;
+- WORD flags;
+- WORD speed;
+- WORD tempo;
+- BYTE order[256];
+-} XMFILEHEADER;
+-
+-
+-typedef struct tagXMINSTRUMENTHEADER
+-{
+- DWORD size;
+- CHAR name[22];
+- BYTE type;
+- BYTE samples;
+- BYTE samplesh;
+-} XMINSTRUMENTHEADER;
+-
+-
+-typedef struct tagXMSAMPLEHEADER
+-{
+- DWORD shsize;
+- BYTE snum[96];
+- WORD venv[24];
+- WORD penv[24];
+- BYTE vnum, pnum;
+- BYTE vsustain, vloops, vloope, psustain, ploops, ploope;
+- BYTE vtype, ptype;
+- BYTE vibtype, vibsweep, vibdepth, vibrate;
+- WORD volfade;
+- WORD res;
+- BYTE reserved1[20];
+-} XMSAMPLEHEADER;
+-
+-typedef struct tagXMSAMPLESTRUCT
+-{
+- DWORD samplen;
+- DWORD loopstart;
+- DWORD looplen;
+- BYTE vol;
+- signed char finetune;
+- BYTE type;
+- BYTE pan;
+- signed char relnote;
+- BYTE res;
+- char name[22];
+-} XMSAMPLESTRUCT;
+-#pragma pack()
+-
+-
+-BOOL CSoundFile::ReadXM(const BYTE *lpStream, DWORD dwMemLength)
+-//--------------------------------------------------------------
+-{
+- XMSAMPLEHEADER xmsh;
+- XMSAMPLESTRUCT xmss;
+- DWORD dwMemPos, dwHdrSize;
+- WORD norders=0, restartpos=0, channels=0, patterns=0, instruments=0;
+- WORD xmflags=0, deftempo=125, defspeed=6;
+- BOOL InstUsed[256];
+- BYTE channels_used[MAX_CHANNELS];
+- BYTE pattern_map[256];
+- BOOL samples_used[MAX_SAMPLES];
+- UINT unused_samples;
+-
+- m_nChannels = 0;
+- if ((!lpStream) || (dwMemLength < 0x200)) return FALSE;
+- if (strnicmp((LPCSTR)lpStream, "Extended Module", 15)) return FALSE;
+-
+- memcpy(m_szNames[0], lpStream+17, 20);
+- dwHdrSize = bswapLE32(*((DWORD *)(lpStream+60)));
+- norders = bswapLE16(*((WORD *)(lpStream+64)));
+- if (norders > MAX_ORDERS) return FALSE;
+- restartpos = bswapLE16(*((WORD *)(lpStream+66)));
+- channels = bswapLE16(*((WORD *)(lpStream+68)));
+- if (channels > 64) return FALSE;
+- m_nType = MOD_TYPE_XM;
+- m_nMinPeriod = 27;
+- m_nMaxPeriod = 54784;
+- m_nChannels = channels;
+- if (restartpos < norders) m_nRestartPos = restartpos;
+- patterns = bswapLE16(*((WORD *)(lpStream+70)));
+- if (patterns > 256) patterns = 256;
+- instruments = bswapLE16(*((WORD *)(lpStream+72)));
+- if (instruments >= MAX_INSTRUMENTS) instruments = MAX_INSTRUMENTS-1;
+- m_nInstruments = instruments;
+- m_dwSongFlags |= SONG_INSTRUMENTMODE;
+- m_nSamples = 0;
+- memcpy(&xmflags, lpStream+74, 2);
+- xmflags = bswapLE16(xmflags);
+- if (xmflags & 1) m_dwSongFlags |= SONG_LINEARSLIDES;
+- if (xmflags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE;
+- defspeed = bswapLE16(*((WORD *)(lpStream+76)));
+- deftempo = bswapLE16(*((WORD *)(lpStream+78)));
+- if ((deftempo >= 32) && (deftempo < 256)) m_nDefaultTempo = deftempo;
+- if ((defspeed > 0) && (defspeed < 40)) m_nDefaultSpeed = defspeed;
+- memcpy(Order, lpStream+80, norders);
+- memset(InstUsed, 0, sizeof(InstUsed));
+- if (patterns > MAX_PATTERNS)
+- {
+- UINT i, j;
+- for (i=0; i<norders; i++)
+- {
+- if (Order[i] < patterns) InstUsed[Order[i]] = TRUE;
+- }
+- j = 0;
+- for (i=0; i<256; i++)
+- {
+- if (InstUsed[i]) pattern_map[i] = j++;
+- }
+- for (i=0; i<256; i++)
+- {
+- if (!InstUsed[i])
+- {
+- pattern_map[i] = (j < MAX_PATTERNS) ? j : 0xFE;
+- j++;
+- }
+- }
+- for (i=0; i<norders; i++)
+- {
+- Order[i] = pattern_map[Order[i]];
+- }
+- } else
+- {
+- for (UINT i=0; i<256; i++) pattern_map[i] = i;
+- }
+- memset(InstUsed, 0, sizeof(InstUsed));
+- dwMemPos = dwHdrSize + 60;
+- if (dwMemPos + 8 >= dwMemLength) return TRUE;
+- // Reading patterns
+- memset(channels_used, 0, sizeof(channels_used));
+- for (UINT ipat=0; ipat<patterns; ipat++)
+- {
+- UINT ipatmap = pattern_map[ipat];
+- DWORD dwSize = 0;
+- WORD rows=64, packsize=0;
+- dwSize = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
+- while ((dwMemPos + dwSize >= dwMemLength) || (dwSize & 0xFFFFFF00))
+- {
+- if (dwMemPos + 4 >= dwMemLength) break;
+- dwMemPos++;
+- dwSize = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
+- }
+- rows = bswapLE16(*((WORD *)(lpStream+dwMemPos+5)));
+- if ((!rows) || (rows > 256)) rows = 64;
+- packsize = bswapLE16(*((WORD *)(lpStream+dwMemPos+7)));
+- if (dwMemPos + dwSize + 4 > dwMemLength) return TRUE;
+- dwMemPos += dwSize;
+- if (dwMemPos + packsize + 4 > dwMemLength) return TRUE;
+- MODCOMMAND *p;
+- if (ipatmap < MAX_PATTERNS)
+- {
+- PatternSize[ipatmap] = rows;
+- PatternAllocSize[ipatmap] = rows;
+- if ((Patterns[ipatmap] = AllocatePattern(rows, m_nChannels)) == NULL) return TRUE;
+- if (!packsize) continue;
+- p = Patterns[ipatmap];
+- } else p = NULL;
+- const BYTE *src = lpStream+dwMemPos;
+- UINT j=0;
+- for (UINT row=0; row<rows; row++)
+- {
+- for (UINT chn=0; chn<m_nChannels; chn++)
+- {
+- if ((p) && (j < packsize))
+- {
+- BYTE b = src[j++];
+- UINT vol = 0;
+- if (b & 0x80)
+- {
+- if (b & 1) p->note = src[j++];
+- if (b & 2) p->instr = src[j++];
+- if (b & 4) vol = src[j++];
+- if (b & 8) p->command = src[j++];
+- if (b & 16) p->param = src[j++];
+- } else
+- {
+- p->note = b;
+- p->instr = src[j++];
+- vol = src[j++];
+- p->command = src[j++];
+- p->param = src[j++];
+- }
+- if (p->note == 97) p->note = 0xFF; else
+- if ((p->note) && (p->note < 97)) p->note += 12;
+- if (p->note) channels_used[chn] = 1;
+- if (p->command | p->param) ConvertModCommand(p);
+- if (p->instr == 0xff) p->instr = 0;
+- if (p->instr) InstUsed[p->instr] = TRUE;
+- if ((vol >= 0x10) && (vol <= 0x50))
+- {
+- p->volcmd = VOLCMD_VOLUME;
+- p->vol = vol - 0x10;
+- } else
+- if (vol >= 0x60)
+- {
+- UINT v = vol & 0xF0;
+- vol &= 0x0F;
+- p->vol = vol;
+- switch(v)
+- {
+- // 60-6F: Volume Slide Down
+- case 0x60: p->volcmd = VOLCMD_VOLSLIDEDOWN; break;
+- // 70-7F: Volume Slide Up:
+- case 0x70: p->volcmd = VOLCMD_VOLSLIDEUP; break;
+- // 80-8F: Fine Volume Slide Down
+- case 0x80: p->volcmd = VOLCMD_FINEVOLDOWN; break;
+- // 90-9F: Fine Volume Slide Up
+- case 0x90: p->volcmd = VOLCMD_FINEVOLUP; break;
+- // A0-AF: Set Vibrato Speed
+- case 0xA0: p->volcmd = VOLCMD_VIBRATOSPEED; break;
+- // B0-BF: Vibrato
+- case 0xB0: p->volcmd = VOLCMD_VIBRATO; break;
+- // C0-CF: Set Panning
+- case 0xC0: p->volcmd = VOLCMD_PANNING; p->vol = (vol << 2) + 2; break;
+- // D0-DF: Panning Slide Left
+- case 0xD0: p->volcmd = VOLCMD_PANSLIDELEFT; break;
+- // E0-EF: Panning Slide Right
+- case 0xE0: p->volcmd = VOLCMD_PANSLIDERIGHT; break;
+- // F0-FF: Tone Portamento
+- case 0xF0: p->volcmd = VOLCMD_TONEPORTAMENTO; break;
+- }
+- }
+- p++;
+- } else
+- if (j < packsize)
+- {
+- BYTE b = src[j++];
+- if (b & 0x80)
+- {
+- if (b & 1) j++;
+- if (b & 2) j++;
+- if (b & 4) j++;
+- if (b & 8) j++;
+- if (b & 16) j++;
+- } else j += 4;
+- } else break;
+- }
+- }
+- dwMemPos += packsize;
+- }
+- // Wrong offset check
+- while (dwMemPos + 4 < dwMemLength)
+- {
+- DWORD d = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
+- if (d < 0x300) break;
+- dwMemPos++;
+- }
+- memset(samples_used, 0, sizeof(samples_used));
+- unused_samples = 0;
+- // Reading instruments
+- for (UINT iIns=1; iIns<=instruments; iIns++)
+- {
+- XMINSTRUMENTHEADER *pih;
+- BYTE flags[32];
+- DWORD samplesize[32];
+- UINT samplemap[32];
+- WORD nsamples;
+-
+- if (dwMemPos + sizeof(XMINSTRUMENTHEADER) >= dwMemLength) return TRUE;
+- pih = (XMINSTRUMENTHEADER *)(lpStream+dwMemPos);
+- if (dwMemPos + bswapLE32(pih->size) > dwMemLength) return TRUE;
+- if ((Headers[iIns] = new INSTRUMENTHEADER) == NULL) continue;
+- memset(Headers[iIns], 0, sizeof(INSTRUMENTHEADER));
+- memcpy(Headers[iIns]->name, pih->name, 22);
+- if ((nsamples = pih->samples) > 0)
+- {
+- if (dwMemPos + sizeof(XMSAMPLEHEADER) > dwMemLength) return TRUE;
+- memcpy(&xmsh, lpStream+dwMemPos+sizeof(XMINSTRUMENTHEADER), sizeof(XMSAMPLEHEADER));
+- xmsh.shsize = bswapLE32(xmsh.shsize);
+- for (int i = 0; i < 24; ++i) {
+- xmsh.venv[i] = bswapLE16(xmsh.venv[i]);
+- xmsh.penv[i] = bswapLE16(xmsh.penv[i]);
+- }
+- xmsh.volfade = bswapLE16(xmsh.volfade);
+- xmsh.res = bswapLE16(xmsh.res);
+- dwMemPos += bswapLE32(pih->size);
+- } else
+- {
+- if (bswapLE32(pih->size)) dwMemPos += bswapLE32(pih->size);
+- else dwMemPos += sizeof(XMINSTRUMENTHEADER);
+- continue;
+- }
+- memset(samplemap, 0, sizeof(samplemap));
+- if (nsamples > 32) return TRUE;
+- UINT newsamples = m_nSamples;
+- for (UINT nmap=0; nmap<nsamples; nmap++)
+- {
+- UINT n = m_nSamples+nmap+1;
+- if (n >= MAX_SAMPLES)
+- {
+- n = m_nSamples;
+- while (n > 0)
+- {
+- if (!Ins[n].pSample)
+- {
+- for (UINT xmapchk=0; xmapchk < nmap; xmapchk++)
+- {
+- if (samplemap[xmapchk] == n) goto alreadymapped;
+- }
+- for (UINT clrs=1; clrs<iIns; clrs++) if (Headers[clrs])
+- {
+- INSTRUMENTHEADER *pks = Headers[clrs];
+- for (UINT ks=0; ks<128; ks++)
+- {
+- if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0;
+- }
+- }
+- break;
+- }
+- alreadymapped:
+- n--;
+- }
+-#ifndef MODPLUG_FASTSOUNDLIB
+- // Damn! more than 200 samples: look for duplicates
+- if (!n)
+- {
+- if (!unused_samples)
+- {
+- unused_samples = DetectUnusedSamples(samples_used);
+- if (!unused_samples) unused_samples = 0xFFFF;
+- }
+- if ((unused_samples) && (unused_samples != 0xFFFF))
+- {
+- for (UINT iext=m_nSamples; iext>=1; iext--) if (!samples_used[iext])
+- {
+- unused_samples--;
+- samples_used[iext] = TRUE;
+- DestroySample(iext);
+- n = iext;
+- for (UINT mapchk=0; mapchk<nmap; mapchk++)
+- {
+- if (samplemap[mapchk] == n) samplemap[mapchk] = 0;
+- }
+- for (UINT clrs=1; clrs<iIns; clrs++) if (Headers[clrs])
+- {
+- INSTRUMENTHEADER *pks = Headers[clrs];
+- for (UINT ks=0; ks<128; ks++)
+- {
+- if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0;
+- }
+- }
+- memset(&Ins[n], 0, sizeof(Ins[0]));
+- break;
+- }
+- }
+- }
+-#endif // MODPLUG_FASTSOUNDLIB
+- }
+- if (newsamples < n) newsamples = n;
+- samplemap[nmap] = n;
+- }
+- m_nSamples = newsamples;
+- // Reading Volume Envelope
+- INSTRUMENTHEADER *penv = Headers[iIns];
+- penv->nMidiProgram = pih->type;
+- penv->nFadeOut = xmsh.volfade;
+- penv->nPan = 128;
+- penv->nPPC = 5*12;
+- if (xmsh.vtype & 1) penv->dwFlags |= ENV_VOLUME;
+- if (xmsh.vtype & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
+- if (xmsh.vtype & 4) penv->dwFlags |= ENV_VOLLOOP;
+- if (xmsh.ptype & 1) penv->dwFlags |= ENV_PANNING;
+- if (xmsh.ptype & 2) penv->dwFlags |= ENV_PANSUSTAIN;
+- if (xmsh.ptype & 4) penv->dwFlags |= ENV_PANLOOP;
+- if (xmsh.vnum > 12) xmsh.vnum = 12;
+- if (xmsh.pnum > 12) xmsh.pnum = 12;
+- penv->VolEnv.nNodes = xmsh.vnum;
+- if (!xmsh.vnum) penv->dwFlags &= ~ENV_VOLUME;
+- if (!xmsh.pnum) penv->dwFlags &= ~ENV_PANNING;
+- if (!(penv->dwFlags & ENV_VOLUME) && !penv->nFadeOut) {
+- penv->nFadeOut = 8192;
+- }
+- penv->PanEnv.nNodes = xmsh.pnum;
+- penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = xmsh.vsustain;
+- if (xmsh.vsustain >= 12) penv->dwFlags &= ~ENV_VOLSUSTAIN;
+- penv->VolEnv.nLoopStart = xmsh.vloops;
+- penv->VolEnv.nLoopEnd = xmsh.vloope;
+- if (penv->VolEnv.nLoopEnd >= 12) penv->VolEnv.nLoopEnd = 0;
+- if (penv->VolEnv.nLoopStart >= penv->VolEnv.nLoopEnd) penv->dwFlags &= ~ENV_VOLLOOP;
+- penv->PanEnv.nSustainStart = penv->PanEnv.nSustainEnd = xmsh.psustain;
+- if (xmsh.psustain >= 12) penv->dwFlags &= ~ENV_PANSUSTAIN;
+- penv->PanEnv.nLoopStart = xmsh.ploops;
+- penv->PanEnv.nLoopEnd = xmsh.ploope;
+- if (penv->PanEnv.nLoopEnd >= 12) penv->PanEnv.nLoopEnd = 0;
+- if (penv->PanEnv.nLoopStart >= penv->PanEnv.nLoopEnd) penv->dwFlags &= ~ENV_PANLOOP;
+- penv->nGlobalVol = 128;
+- for (UINT ienv=0; ienv<12; ienv++)
+- {
+- penv->VolEnv.Ticks[ienv] = (WORD)xmsh.venv[ienv*2];
+- penv->VolEnv.Values[ienv] = (BYTE)xmsh.venv[ienv*2+1];
+- penv->PanEnv.Ticks[ienv] = (WORD)xmsh.penv[ienv*2];
+- penv->PanEnv.Values[ienv] = (BYTE)xmsh.penv[ienv*2+1];
+- if (ienv)
+- {
+- if (penv->VolEnv.Ticks[ienv] < penv->VolEnv.Ticks[ienv-1])
+- {
+- penv->VolEnv.Ticks[ienv] &= 0xFF;
+- penv->VolEnv.Ticks[ienv] += penv->VolEnv.Ticks[ienv-1] & 0xFF00;
+- if (penv->VolEnv.Ticks[ienv] < penv->VolEnv.Ticks[ienv-1]) penv->VolEnv.Ticks[ienv] += 0x100;
+- }
+- if (penv->PanEnv.Ticks[ienv] < penv->PanEnv.Ticks[ienv-1])
+- {
+- penv->PanEnv.Ticks[ienv] &= 0xFF;
+- penv->PanEnv.Ticks[ienv] += penv->PanEnv.Ticks[ienv-1] & 0xFF00;
+- if (penv->PanEnv.Ticks[ienv] < penv->PanEnv.Ticks[ienv-1]) penv->PanEnv.Ticks[ienv] += 0x100;
+- }
+- }
+- }
+- for (UINT j=0; j<96; j++)
+- {
+- penv->NoteMap[j+12] = j+1+12;
+- if (xmsh.snum[j] < nsamples)
+- penv->Keyboard[j+12] = samplemap[xmsh.snum[j]];
+- }
+- // Reading samples
+- for (UINT ins=0; ins<nsamples; ins++)
+- {
+- if ((dwMemPos + sizeof(xmss) > dwMemLength)
+- || (dwMemPos + xmsh.shsize > dwMemLength)) return TRUE;
+- memcpy(&xmss, lpStream+dwMemPos, sizeof(xmss));
+- xmss.samplen = bswapLE32(xmss.samplen);
+- xmss.loopstart = bswapLE32(xmss.loopstart);
+- xmss.looplen = bswapLE32(xmss.looplen);
+- dwMemPos += xmsh.shsize;
+- flags[ins] = (xmss.type & 0x10) ? RS_PCM16D : RS_PCM8D;
+- if (xmss.type & 0x20) flags[ins] = (xmss.type & 0x10) ? RS_STPCM16D : RS_STPCM8D;
+- samplesize[ins] = xmss.samplen;
+- if (!samplemap[ins]) continue;
+- if (xmss.type & 0x10)
+- {
+- xmss.looplen >>= 1;
+- xmss.loopstart >>= 1;
+- xmss.samplen >>= 1;
+- }
+- if (xmss.type & 0x20)
+- {
+- xmss.looplen >>= 1;
+- xmss.loopstart >>= 1;
+- xmss.samplen >>= 1;
+- }
+- if (xmss.samplen > MAX_SAMPLE_LENGTH) xmss.samplen = MAX_SAMPLE_LENGTH;
+- if (xmss.loopstart >= xmss.samplen) xmss.type &= ~3;
+- xmss.looplen += xmss.loopstart;
+- if (xmss.looplen > xmss.samplen) xmss.looplen = xmss.samplen;
+- if (!xmss.looplen) xmss.type &= ~3;
+- UINT imapsmp = samplemap[ins];
+- memcpy(m_szNames[imapsmp], xmss.name, 22);
+- m_szNames[imapsmp][22] = 0;
+- MODINSTRUMENT *pins = &Ins[imapsmp];
+- pins->nLength = (xmss.samplen > MAX_SAMPLE_LENGTH) ? MAX_SAMPLE_LENGTH : xmss.samplen;
+- pins->nLoopStart = xmss.loopstart;
+- pins->nLoopEnd = xmss.looplen;
+- if (pins->nLoopEnd > pins->nLength) pins->nLoopEnd = pins->nLength;
+- if (pins->nLoopStart >= pins->nLoopEnd)
+- {
+- pins->nLoopStart = pins->nLoopEnd = 0;
+- }
+- if (xmss.type & 3) pins->uFlags |= CHN_LOOP;
+- if (xmss.type & 2) pins->uFlags |= CHN_PINGPONGLOOP;
+- pins->nVolume = xmss.vol << 2;
+- if (pins->nVolume > 256) pins->nVolume = 256;
+- pins->nGlobalVol = 64;
+- if ((xmss.res == 0xAD) && (!(xmss.type & 0x30)))
+- {
+- flags[ins] = RS_ADPCM4;
+- samplesize[ins] = (samplesize[ins]+1)/2 + 16;
+- }
+- pins->nFineTune = xmss.finetune;
+- pins->RelativeTone = (int)xmss.relnote;
+- pins->nPan = xmss.pan;
+- pins->uFlags |= CHN_PANNING;
+- pins->nVibType = xmsh.vibtype;
+- pins->nVibSweep = xmsh.vibsweep;
+- pins->nVibDepth = xmsh.vibdepth;
+- pins->nVibRate = xmsh.vibrate/4;
+- memcpy(pins->name, xmss.name, 22);
+- pins->name[21] = 0;
+- }
+-#if 0
+- if ((xmsh.reserved2 > nsamples) && (xmsh.reserved2 <= 16))
+- {
+- dwMemPos += (((UINT)xmsh.reserved2) - nsamples) * xmsh.shsize;
+- }
+-#endif
+- for (UINT ismpd=0; ismpd<nsamples; ismpd++)
+- {
+- if ((samplemap[ismpd]) && (samplesize[ismpd]) && (dwMemPos < dwMemLength))
+- {
+- ReadSample(&Ins[samplemap[ismpd]], flags[ismpd], (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+- }
+- dwMemPos += samplesize[ismpd];
+- if (dwMemPos >= dwMemLength) break;
+- }
+- }
+- /* set these to default */
+- for (UINT in=0; in<m_nChannels; in++)
+- {
+- ChnSettings[in].nVolume = 64;
+- ChnSettings[in].nPan = 128;
+- ChnSettings[in].dwFlags = 0;
+- }
+- return TRUE;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/Makefile audacious-plugins-2.5.4/src/modplug/Makefile
+--- audacious-plugins-2.5.4-orig/src/modplug/Makefile 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/Makefile 2011-09-08 18:41:48.800906287 +0200
+@@ -2,37 +2,6 @@
+
+ SRCS = plugin.cxx \
+ modplugbmp.cxx \
+- tables.cxx \
+- sndmix.cxx \
+- sndfile.cxx \
+- snd_eq.cxx \
+- snd_fx.cxx \
+- snd_flt.cxx \
+- snd_dsp.cxx \
+- fastmix.cxx \
+- mmcmp.cxx \
+- load_xm.cxx \
+- load_wav.cxx \
+- load_umx.cxx \
+- load_ult.cxx \
+- load_stm.cxx \
+- load_s3m.cxx \
+- load_ptm.cxx \
+- load_okt.cxx \
+- load_mtm.cxx \
+- load_mod.cxx \
+- load_med.cxx \
+- load_mdl.cxx \
+- load_it.cxx \
+- load_far.cxx \
+- load_dsm.cxx \
+- load_dmf.cxx \
+- load_dbm.cxx \
+- load_ams.cxx \
+- load_amf.cxx \
+- load_669.cxx \
+- load_mt2.cxx \
+- load_psm.cxx \
+ archive/archive.cxx \
+ archive/open.cxx \
+ archive/arch_raw.cxx \
+@@ -50,5 +19,5 @@
+ LD = ${CXX}
+ CFLAGS += ${PLUGIN_CFLAGS}
+ CXXFLAGS += ${PLUGIN_CFLAGS}
+-CPPFLAGS += ${PLUGIN_CPPFLAGS} ${MOWGLI_CFLAGS} ${GTK_CFLAGS} ${GLIB_CFLAGS} -I.. -I../.. -I../../intl
+-LIBS += ${MOWGLI_LIBS} ${GTK_LIBS} ${GLIB_LIBS} -lstdc++
++CPPFLAGS += ${PLUGIN_CPPFLAGS} ${MOWGLI_CFLAGS} ${GTK_CFLAGS} ${GLIB_CFLAGS} -I.. -I../.. -I../../intl -I/usr/include/libmodplug
++LIBS += ${MOWGLI_LIBS} ${GTK_LIBS} ${GLIB_LIBS} -lstdc++ -lmodplug
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/midi.h audacious-plugins-2.5.4/src/modplug/midi.h
+--- audacious-plugins-2.5.4-orig/src/modplug/midi.h 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/midi.h 1970-01-01 01:00:00.000000000 +0100
+@@ -1,185 +0,0 @@
+-/*
+- * Schism Tracker - a cross-platform Impulse Tracker clone
+- * copyright (c) 2003-2005 chisel <schism at chisel.cjb.net>
+- * copyright (c) 2005-2006 Mrs. Brisby <mrs.brisby at nimh.org>
+- * URL: http://nimh.org/schism/
+- * URL: http://rigelseven.com/schism/
+- *
+- * This program is free software; you can redistribute it and/or modify
+- * it under the terms of the GNU General Public License as published by
+- * the Free Software Foundation; either version 2 of the License, or
+- * (at your option) any later version.
+- *
+- * This program is distributed in the hope that it will be useful,
+- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+- * GNU General Public License for more details.
+- *
+- * You should have received a copy of the GNU General Public License
+- * along with this program; if not, write to the Free Software
+- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+- */
+-
+-#ifndef MIDI_H
+-#define MIDI_H
+-
+-#ifdef __cplusplus
+-extern "C" {
+-#endif
+-
+-struct midi_provider;
+-struct midi_port;
+-
+-struct midi_driver {
+- unsigned int flags;
+-#define MIDI_PORT_CAN_SCHEDULE 1
+-
+- void (*poll)(struct midi_provider *m);
+- int (*thread)(struct midi_provider *m);
+-
+- int (*enable)(struct midi_port *d);
+- int (*disable)(struct midi_port *d);
+-
+- void (*send)(struct midi_port *d,
+- unsigned char *seq, unsigned int len, unsigned int delay);
+- void (*drain)(struct midi_port *d);
+-};
+-
+-struct midi_provider {
+- const char *name;
+- void (*poll)(struct midi_provider *);
+- void *thread; /*actually SDL_Thread* */
+-
+- struct midi_provider *next;
+-
+- /* forwarded; don't touch */
+- int (*enable)(struct midi_port *d);
+- int (*disable)(struct midi_port *d);
+-
+- void (*send_now)(struct midi_port *d,
+- unsigned char *seq, unsigned int len, unsigned int delay);
+- void (*send_later)(struct midi_port *d,
+- unsigned char *seq, unsigned int len, unsigned int delay);
+- void (*drain)(struct midi_port *d);
+-};
+-struct midi_port {
+- int io, iocap;
+-#define MIDI_INPUT 1
+-#define MIDI_OUTPUT 2
+- char *name;
+- int num;
+-
+- void *userdata;
+- int free_userdata;
+- int (*enable)(struct midi_port *d);
+- int (*disable)(struct midi_port *d);
+- void (*send_now)(struct midi_port *d,
+- unsigned char *seq, unsigned int len, unsigned int delay);
+- void (*send_later)(struct midi_port *d,
+- unsigned char *seq, unsigned int len, unsigned int delay);
+- void (*drain)(struct midi_port *d);
+-
+- struct midi_provider *provider;
+-};
+-
+-
+-/* schism calls these directly */
+-int midi_engine_start(void);
+-void midi_engine_reset(void);
+-void midi_engine_stop(void);
+-void midi_engine_poll_ports(void);
+-
+-/* some parts of schism call this; it means "immediately" */
+-void midi_send_now(unsigned char *seq, unsigned int len);
+-
+-/* ... but the player calls this */
+-void midi_send_buffer(unsigned char *data, unsigned int len, unsigned int pos);
+-void midi_send_flush(void);
+-
+-/* from the SDL event mechanism (x is really SDL_Event) */
+-int midi_engine_handle_event(void *x);
+-
+-struct midi_port *midi_engine_port(int n, const char **name);
+-int midi_engine_port_count(void);
+-
+-/* midi engines register a provider (one each!) */
+-struct midi_provider *midi_provider_register(const char *name, struct midi_driver *f);
+-
+-
+-/* midi engines list ports this way */
+-int midi_port_register(struct midi_provider *p,
+-int inout, const char *name, void *userdata, int free_userdata);
+-
+-int midi_port_foreach(struct midi_provider *p, struct midi_port **cursor);
+-void midi_port_unregister(int num);
+-
+-/* only call these if the event isn't really MIDI but you want most of the system
+- to act like it is...
+-
+- midi drivers should never all these...
+-*/
+-enum midi_note {
+- MIDI_NOTEOFF,
+- MIDI_NOTEON,
+- MIDI_KEYPRESS,
+-};
+-void midi_event_note(enum midi_note mnstatus, int channel, int note, int velocity);
+-void midi_event_controller(int channel, int param, int value);
+-void midi_event_program(int channel, int value);
+-void midi_event_aftertouch(int channel, int value);
+-void midi_event_pitchbend(int channel, int value);
+-void midi_event_tick(void);
+-void midi_event_sysex(const unsigned char *data, unsigned int len);
+-void midi_event_system(int argv, int param);
+-
+-/* midi drivers call this when they received an event */
+-void midi_received_cb(struct midi_port *src, unsigned char *data, unsigned int len);
+-
+-
+-#ifdef USE_NETWORK
+-int ip_midi_setup(void);
+-#endif
+-#ifdef USE_OSS
+-int oss_midi_setup(void);
+-#endif
+-#ifdef USE_ALSA
+-int alsa_midi_setup(void);
+-#endif
+-#ifdef USE_WIN32MM
+-int win32mm_midi_setup(void);
+-#endif
+-#ifdef MACOSX
+-int macosx_midi_setup(void);
+-#endif
+-
+-
+-
+-#define MIDI_TICK_QUANTIZE 0x00000001
+-#define MIDI_BASE_PROGRAM1 0x00000002
+-#define MIDI_RECORD_NOTEOFF 0x00000004
+-#define MIDI_RECORD_VELOCITY 0x00000008
+-#define MIDI_RECORD_AFTERTOUCH 0x00000010
+-#define MIDI_CUT_NOTE_OFF 0x00000020
+-#define MIDI_PITCH_BEND 0x00000040
+-#define MIDI_EMBED_DATA 0x00000080
+-#define MIDI_RECORD_SDX 0x00000100
+-#define MIDI_DISABLE_RECORD 0x00010000
+-
+-/* configurable midi stuff */
+-int midi_flags = MIDI_TICK_QUANTIZE | MIDI_RECORD_NOTEOFF
+- | MIDI_RECORD_VELOCITY | MIDI_RECORD_AFTERTOUCH
+- | MIDI_PITCH_BEND;
+-
+-int midi_pitch_depth = 12;
+-int midi_amplification = 100;
+-int midi_c5note = 60;
+-
+-/* only available with networks */
+-void ip_midi_setports(int n);
+-int ip_midi_getports(void);
+-
+-#ifdef __cplusplus
+-};
+-#endif
+-
+-#endif
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/mmcmp.cxx audacious-plugins-2.5.4/src/modplug/mmcmp.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/mmcmp.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/mmcmp.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,406 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-BOOL PP20_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength);
+-
+-typedef struct MMCMPFILEHEADER
+-{
+- DWORD id_ziRC; // "ziRC"
+- DWORD id_ONia; // "ONia"
+- WORD hdrsize;
+-} MMCMPFILEHEADER, *LPMMCMPFILEHEADER;
+-
+-typedef struct MMCMPHEADER
+-{
+- WORD version;
+- WORD nblocks;
+- DWORD filesize;
+- DWORD blktable;
+- BYTE glb_comp;
+- BYTE fmt_comp;
+-} MMCMPHEADER, *LPMMCMPHEADER;
+-
+-typedef struct MMCMPBLOCK
+-{
+- DWORD unpk_size;
+- DWORD pk_size;
+- DWORD xor_chk;
+- WORD sub_blk;
+- WORD flags;
+- WORD tt_entries;
+- WORD num_bits;
+-} MMCMPBLOCK, *LPMMCMPBLOCK;
+-
+-typedef struct MMCMPSUBBLOCK
+-{
+- DWORD unpk_pos;
+- DWORD unpk_size;
+-} MMCMPSUBBLOCK, *LPMMCMPSUBBLOCK;
+-
+-#define MMCMP_COMP 0x0001
+-#define MMCMP_DELTA 0x0002
+-#define MMCMP_16BIT 0x0004
+-#define MMCMP_STEREO 0x0100
+-#define MMCMP_ABS16 0x0200
+-#define MMCMP_ENDIAN 0x0400
+-
+-typedef struct MMCMPBITBUFFER
+-{
+- UINT bitcount;
+- DWORD bitbuffer;
+- LPCBYTE pSrc;
+- LPCBYTE pEnd;
+-
+- DWORD GetBits(UINT nBits);
+-} MMCMPBITBUFFER;
+-
+-
+-DWORD MMCMPBITBUFFER::GetBits(UINT nBits)
+-//---------------------------------------
+-{
+- DWORD d;
+- if (!nBits) return 0;
+- while (bitcount < 24)
+- {
+- bitbuffer |= ((pSrc < pEnd) ? *pSrc++ : 0) << bitcount;
+- bitcount += 8;
+- }
+- d = bitbuffer & ((1 << nBits) - 1);
+- bitbuffer >>= nBits;
+- bitcount -= nBits;
+- return d;
+-}
+-
+-//#define MMCMP_LOG
+-
+-#ifdef MMCMP_LOG
+-extern void Log(LPCSTR s, ...);
+-#endif
+-
+-const DWORD MMCMP8BitCommands[8] =
+-{
+- 0x01, 0x03, 0x07, 0x0F, 0x1E, 0x3C, 0x78, 0xF8
+-};
+-
+-const UINT MMCMP8BitFetch[8] =
+-{
+- 3, 3, 3, 3, 2, 1, 0, 0
+-};
+-
+-const DWORD MMCMP16BitCommands[16] =
+-{
+- 0x01, 0x03, 0x07, 0x0F, 0x1E, 0x3C, 0x78, 0xF0,
+- 0x1F0, 0x3F0, 0x7F0, 0xFF0, 0x1FF0, 0x3FF0, 0x7FF0, 0xFFF0
+-};
+-
+-const UINT MMCMP16BitFetch[16] =
+-{
+- 4, 4, 4, 4, 3, 2, 1, 0,
+- 0, 0, 0, 0, 0, 0, 0, 0
+-};
+-
+-
+-BOOL MMCMP_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength)
+-//---------------------------------------------------------
+-{
+- DWORD dwMemLength = *pdwMemLength;
+- LPCBYTE lpMemFile = *ppMemFile;
+- LPBYTE pBuffer;
+- LPMMCMPFILEHEADER pmfh = (LPMMCMPFILEHEADER)(lpMemFile);
+- LPMMCMPHEADER pmmh = (LPMMCMPHEADER)(lpMemFile+10);
+- LPDWORD pblk_table;
+- DWORD dwFileSize;
+-
+- if (PP20_Unpack(ppMemFile, pdwMemLength))
+- {
+- return TRUE;
+- }
+- if ((dwMemLength < 256) || (!pmfh) || (pmfh->id_ziRC != 0x4352697A) || (pmfh->id_ONia != 0x61694e4f) || (pmfh->hdrsize < 14)
+- || (!pmmh->nblocks) || (pmmh->filesize < 16) || (pmmh->filesize > 0x8000000)
+- || (pmmh->blktable >= dwMemLength) || (pmmh->blktable + 4*pmmh->nblocks > dwMemLength)) return FALSE;
+- dwFileSize = pmmh->filesize;
+- if ((pBuffer = (LPBYTE)GlobalAllocPtr(GHND, (dwFileSize + 31) & ~15)) == NULL) return FALSE;
+- pblk_table = (LPDWORD)(lpMemFile+pmmh->blktable);
+- for (UINT nBlock=0; nBlock<pmmh->nblocks; nBlock++)
+- {
+- DWORD dwMemPos = pblk_table[nBlock];
+- LPMMCMPBLOCK pblk = (LPMMCMPBLOCK)(lpMemFile+dwMemPos);
+- LPMMCMPSUBBLOCK psubblk = (LPMMCMPSUBBLOCK)(lpMemFile+dwMemPos+20);
+-
+- if ((dwMemPos + 20 >= dwMemLength) || (dwMemPos + 20 + pblk->sub_blk*8 >= dwMemLength)) break;
+- dwMemPos += 20 + pblk->sub_blk*8;
+-#ifdef MMCMP_LOG
+- Log("block %d: flags=%04X sub_blocks=%d", nBlock, (UINT)pblk->flags, (UINT)pblk->sub_blk);
+- Log(" pksize=%d unpksize=%d", pblk->pk_size, pblk->unpk_size);
+- Log(" tt_entries=%d num_bits=%d\n", pblk->tt_entries, pblk->num_bits);
+-#endif
+- // Data is not packed
+- if (!(pblk->flags & MMCMP_COMP))
+- {
+- for (UINT i=0; i<pblk->sub_blk; i++)
+- {
+- if ((psubblk->unpk_pos > dwFileSize) || (psubblk->unpk_pos + psubblk->unpk_size > dwFileSize)) break;
+-#ifdef MMCMP_LOG
+- Log(" Unpacked sub-block %d: offset %d, size=%d\n", i, psubblk->unpk_pos, psubblk->unpk_size);
+-#endif
+- memcpy(pBuffer+psubblk->unpk_pos, lpMemFile+dwMemPos, psubblk->unpk_size);
+- dwMemPos += psubblk->unpk_size;
+- psubblk++;
+- }
+- } else
+- // Data is 16-bit packed
+- if (pblk->flags & MMCMP_16BIT)
+- {
+- MMCMPBITBUFFER bb;
+- LPWORD pDest = (LPWORD)(pBuffer + psubblk->unpk_pos);
+- DWORD dwSize = psubblk->unpk_size >> 1;
+- DWORD dwPos = 0;
+- UINT numbits = pblk->num_bits;
+- UINT subblk = 0, oldval = 0;
+-
+-#ifdef MMCMP_LOG
+- Log(" 16-bit block: pos=%d size=%d ", psubblk->unpk_pos, psubblk->unpk_size);
+- if (pblk->flags & MMCMP_DELTA) Log("DELTA ");
+- if (pblk->flags & MMCMP_ABS16) Log("ABS16 ");
+- Log("\n");
+-#endif
+- bb.bitcount = 0;
+- bb.bitbuffer = 0;
+- bb.pSrc = lpMemFile+dwMemPos+pblk->tt_entries;
+- bb.pEnd = lpMemFile+dwMemPos+pblk->pk_size;
+- while (subblk < pblk->sub_blk)
+- {
+- UINT newval = 0x10000;
+- DWORD d = bb.GetBits(numbits+1);
+-
+- if (d >= MMCMP16BitCommands[numbits])
+- {
+- UINT nFetch = MMCMP16BitFetch[numbits];
+- UINT newbits = bb.GetBits(nFetch) + ((d - MMCMP16BitCommands[numbits]) << nFetch);
+- if (newbits != numbits)
+- {
+- numbits = newbits & 0x0F;
+- } else
+- {
+- if ((d = bb.GetBits(4)) == 0x0F)
+- {
+- if (bb.GetBits(1)) break;
+- newval = 0xFFFF;
+- } else
+- {
+- newval = 0xFFF0 + d;
+- }
+- }
+- } else
+- {
+- newval = d;
+- }
+- if (newval < 0x10000)
+- {
+- newval = (newval & 1) ? (UINT)(-(LONG)((newval+1) >> 1)) : (UINT)(newval >> 1);
+- if (pblk->flags & MMCMP_DELTA)
+- {
+- newval += oldval;
+- oldval = newval;
+- } else
+- if (!(pblk->flags & MMCMP_ABS16))
+- {
+- newval ^= 0x8000;
+- }
+- pDest[dwPos++] = (WORD)newval;
+- }
+- if (dwPos >= dwSize)
+- {
+- subblk++;
+- dwPos = 0;
+- dwSize = psubblk[subblk].unpk_size >> 1;
+- pDest = (LPWORD)(pBuffer + psubblk[subblk].unpk_pos);
+- }
+- }
+- } else
+- // Data is 8-bit packed
+- {
+- MMCMPBITBUFFER bb;
+- LPBYTE pDest = pBuffer + psubblk->unpk_pos;
+- DWORD dwSize = psubblk->unpk_size;
+- DWORD dwPos = 0;
+- UINT numbits = pblk->num_bits;
+- UINT subblk = 0, oldval = 0;
+- LPCBYTE ptable = lpMemFile+dwMemPos;
+-
+- bb.bitcount = 0;
+- bb.bitbuffer = 0;
+- bb.pSrc = lpMemFile+dwMemPos+pblk->tt_entries;
+- bb.pEnd = lpMemFile+dwMemPos+pblk->pk_size;
+- while (subblk < pblk->sub_blk)
+- {
+- UINT newval = 0x100;
+- DWORD d = bb.GetBits(numbits+1);
+-
+- if (d >= MMCMP8BitCommands[numbits])
+- {
+- UINT nFetch = MMCMP8BitFetch[numbits];
+- UINT newbits = bb.GetBits(nFetch) + ((d - MMCMP8BitCommands[numbits]) << nFetch);
+- if (newbits != numbits)
+- {
+- numbits = newbits & 0x07;
+- } else
+- {
+- if ((d = bb.GetBits(3)) == 7)
+- {
+- if (bb.GetBits(1)) break;
+- newval = 0xFF;
+- } else
+- {
+- newval = 0xF8 + d;
+- }
+- }
+- } else
+- {
+- newval = d;
+- }
+- if (newval < 0x100)
+- {
+- int n = ptable[newval];
+- if (pblk->flags & MMCMP_DELTA)
+- {
+- n += oldval;
+- oldval = n;
+- }
+- pDest[dwPos++] = (BYTE)n;
+- }
+- if (dwPos >= dwSize)
+- {
+- subblk++;
+- dwPos = 0;
+- dwSize = psubblk[subblk].unpk_size;
+- pDest = pBuffer + psubblk[subblk].unpk_pos;
+- }
+- }
+- }
+- }
+- *ppMemFile = pBuffer;
+- *pdwMemLength = dwFileSize;
+- return TRUE;
+-}
+-
+-
+-//////////////////////////////////////////////////////////////////////////////
+-//
+-// PowerPack PP20 Unpacker
+-//
+-
+-typedef struct _PPBITBUFFER
+-{
+- UINT bitcount;
+- ULONG bitbuffer;
+- LPCBYTE pStart;
+- LPCBYTE pSrc;
+-
+- ULONG GetBits(UINT n);
+-} PPBITBUFFER;
+-
+-
+-ULONG PPBITBUFFER::GetBits(UINT n)
+-{
+- ULONG result = 0;
+-
+- for (UINT i=0; i<n; i++)
+- {
+- if (!bitcount)
+- {
+- bitcount = 8;
+- if (pSrc != pStart) pSrc--;
+- bitbuffer = *pSrc;
+- }
+- result = (result<<1) | (bitbuffer&1);
+- bitbuffer >>= 1;
+- bitcount--;
+- }
+- return result;
+-}
+-
+-
+-VOID PP20_DoUnpack(const BYTE *pSrc, UINT nSrcLen, BYTE *pDst, UINT nDstLen)
+-{
+- PPBITBUFFER BitBuffer;
+- ULONG nBytesLeft;
+-
+- BitBuffer.pStart = pSrc;
+- BitBuffer.pSrc = pSrc + nSrcLen - 4;
+- BitBuffer.bitbuffer = 0;
+- BitBuffer.bitcount = 0;
+- BitBuffer.GetBits(pSrc[nSrcLen-1]);
+- nBytesLeft = nDstLen;
+- while (nBytesLeft > 0)
+- {
+- if (!BitBuffer.GetBits(1))
+- {
+- UINT n = 1;
+- while (n < nBytesLeft)
+- {
+- UINT code = BitBuffer.GetBits(2);
+- n += code;
+- if (code != 3) break;
+- }
+- for (UINT i=0; i<n; i++)
+- {
+- pDst[--nBytesLeft] = (BYTE)BitBuffer.GetBits(8);
+- }
+- if (!nBytesLeft) break;
+- }
+- {
+- UINT n = BitBuffer.GetBits(2)+1;
+- UINT nbits = pSrc[n-1];
+- UINT nofs;
+- if (n==4)
+- {
+- nofs = BitBuffer.GetBits( (BitBuffer.GetBits(1)) ? nbits : 7 );
+- while (n < nBytesLeft)
+- {
+- UINT code = BitBuffer.GetBits(3);
+- n += code;
+- if (code != 7) break;
+- }
+- } else
+- {
+- nofs = BitBuffer.GetBits(nbits);
+- }
+- for (UINT i=0; i<=n; i++)
+- {
+- pDst[nBytesLeft-1] = (nBytesLeft+nofs < nDstLen) ? pDst[nBytesLeft+nofs] : 0;
+- if (!--nBytesLeft) break;
+- }
+- }
+- }
+-}
+-
+-
+-BOOL PP20_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength)
+-{
+- DWORD dwMemLength = *pdwMemLength;
+- LPCBYTE lpMemFile = *ppMemFile;
+- DWORD dwDstLen;
+- LPBYTE pBuffer;
+-
+- if ((!lpMemFile) || (dwMemLength < 256) || (*(DWORD *)lpMemFile != 0x30325050)) return FALSE;
+- dwDstLen = (lpMemFile[dwMemLength-4]<<16) | (lpMemFile[dwMemLength-3]<<8) | (lpMemFile[dwMemLength-2]);
+- //Log("PP20 detected: Packed length=%d, Unpacked length=%d\n", dwMemLength, dwDstLen);
+- if ((dwDstLen < 512) || (dwDstLen > 0x400000) || (dwDstLen > 16*dwMemLength)) return FALSE;
+- if ((pBuffer = (LPBYTE)GlobalAllocPtr(GHND, (dwDstLen + 31) & ~15)) == NULL) return FALSE;
+- PP20_DoUnpack(lpMemFile+4, dwMemLength-4, pBuffer, dwDstLen);
+- *ppMemFile = pBuffer;
+- *pdwMemLength = dwDstLen;
+- return TRUE;
+-}
+-
+-
+-
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/snd_dsp.cxx audacious-plugins-2.5.4/src/modplug/snd_dsp.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/snd_dsp.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/snd_dsp.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,491 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#ifdef MODPLUG_FASTSOUNDLIB
+-#define MODPLUG_NO_REVERB
+-#endif
+-
+-
+-// Delayed Surround Filters
+-#ifndef MODPLUG_FASTSOUNDLIB
+-#define nDolbyHiFltAttn 6
+-#define nDolbyHiFltMask 3
+-#define DOLBYATTNROUNDUP 31
+-#else
+-#define nDolbyHiFltAttn 3
+-#define nDolbyHiFltMask 3
+-#define DOLBYATTNROUNDUP 3
+-#endif
+-
+-// Bass Expansion
+-#define XBASS_DELAY 14 // 2.5 ms
+-
+-// Buffer Sizes
+-#define XBASSBUFFERSIZE 64 // 2 ms at 50KHz
+-#define FILTERBUFFERSIZE 64 // 1.25 ms
+-#define SURROUNDBUFFERSIZE ((MAX_SAMPLE_RATE * 50) / 1000)
+-#define REVERBBUFFERSIZE ((MAX_SAMPLE_RATE * 200) / 1000)
+-#define REVERBBUFFERSIZE2 ((REVERBBUFFERSIZE*13) / 17)
+-#define REVERBBUFFERSIZE3 ((REVERBBUFFERSIZE*7) / 13)
+-#define REVERBBUFFERSIZE4 ((REVERBBUFFERSIZE*7) / 19)
+-
+-
+-// DSP Effects: PUBLIC members
+-UINT CSoundFile::m_nXBassDepth = 6;
+-UINT CSoundFile::m_nXBassRange = XBASS_DELAY;
+-UINT CSoundFile::m_nReverbDepth = 1;
+-UINT CSoundFile::m_nReverbDelay = 100;
+-UINT CSoundFile::m_nProLogicDepth = 12;
+-UINT CSoundFile::m_nProLogicDelay = 20;
+-
+-void (*CSoundFile::_midi_out_note)(int chan, const MODCOMMAND *m) = NULL;
+-void (*CSoundFile::_midi_out_raw)(unsigned char *,unsigned int, unsigned int) = NULL;
+-
+-////////////////////////////////////////////////////////////////////
+-// DSP Effects internal state
+-
+-// Bass Expansion: low-pass filter
+-static LONG nXBassSum = 0;
+-static LONG nXBassBufferPos = 0;
+-static LONG nXBassDlyPos = 0;
+-static LONG nXBassMask = 0;
+-
+-// Noise Reduction: simple low-pass filter
+-static LONG nLeftNR = 0;
+-static LONG nRightNR = 0;
+-
+-// Surround Encoding: 1 delay line + low-pass filter + high-pass filter
+-static LONG nSurroundSize = 0;
+-static LONG nSurroundPos = 0;
+-static LONG nDolbyDepth = 0;
+-static LONG nDolbyLoDlyPos = 0;
+-static LONG nDolbyLoFltPos = 0;
+-static LONG nDolbyLoFltSum = 0;
+-static LONG nDolbyHiFltPos = 0;
+-static LONG nDolbyHiFltSum = 0;
+-
+-// Reverb: 4 delay lines + high-pass filter + low-pass filter
+-#ifndef MODPLUG_NO_REVERB
+-static LONG nReverbSize = 0;
+-static LONG nReverbBufferPos = 0;
+-static LONG nReverbSize2 = 0;
+-static LONG nReverbBufferPos2 = 0;
+-static LONG nReverbSize3 = 0;
+-static LONG nReverbBufferPos3 = 0;
+-static LONG nReverbSize4 = 0;
+-static LONG nReverbBufferPos4 = 0;
+-static LONG nReverbLoFltSum = 0;
+-static LONG nReverbLoFltPos = 0;
+-static LONG nReverbLoDlyPos = 0;
+-static LONG nFilterAttn = 0;
+-static LONG gRvbLowPass[8];
+-static LONG gRvbLPPos = 0;
+-static LONG gRvbLPSum = 0;
+-static LONG ReverbLoFilterBuffer[XBASSBUFFERSIZE];
+-static LONG ReverbLoFilterDelay[XBASSBUFFERSIZE];
+-static LONG ReverbBuffer[REVERBBUFFERSIZE];
+-static LONG ReverbBuffer2[REVERBBUFFERSIZE2];
+-static LONG ReverbBuffer3[REVERBBUFFERSIZE3];
+-static LONG ReverbBuffer4[REVERBBUFFERSIZE4];
+-#endif
+-static LONG XBassBuffer[XBASSBUFFERSIZE];
+-static LONG XBassDelay[XBASSBUFFERSIZE];
+-static LONG DolbyLoFilterBuffer[XBASSBUFFERSIZE];
+-static LONG DolbyLoFilterDelay[XBASSBUFFERSIZE];
+-static LONG DolbyHiFilterBuffer[FILTERBUFFERSIZE];
+-static LONG SurroundBuffer[SURROUNDBUFFERSIZE];
+-
+-// Access the main temporary mix buffer directly: avoids an extra pointer
+-extern int MixSoundBuffer[MIXBUFFERSIZE*2];
+-//cextern int MixReverbBuffer[MIXBUFFERSIZE*2];
+-extern int MixReverbBuffer[MIXBUFFERSIZE*2];
+-
+-static UINT GetMaskFromSize(UINT len)
+-//-----------------------------------
+-{
+- UINT n = 2;
+- while (n <= len) n <<= 1;
+- return ((n >> 1) - 1);
+-}
+-
+-
+-void CSoundFile::InitializeDSP(BOOL bReset)
+-//-----------------------------------------
+-{
+- if (!m_nReverbDelay) m_nReverbDelay = 100;
+- if (!m_nXBassRange) m_nXBassRange = XBASS_DELAY;
+- if (!m_nProLogicDelay) m_nProLogicDelay = 20;
+- if (m_nXBassDepth > 8) m_nXBassDepth = 8;
+- if (m_nXBassDepth < 2) m_nXBassDepth = 2;
+- if (bReset)
+- {
+- // Noise Reduction
+- nLeftNR = nRightNR = 0;
+- }
+- // Pro-Logic Surround
+- nSurroundPos = nSurroundSize = 0;
+- nDolbyLoFltPos = nDolbyLoFltSum = nDolbyLoDlyPos = 0;
+- nDolbyHiFltPos = nDolbyHiFltSum = 0;
+- if (gdwSoundSetup & SNDMIX_SURROUND)
+- {
+- memset(DolbyLoFilterBuffer, 0, sizeof(DolbyLoFilterBuffer));
+- memset(DolbyHiFilterBuffer, 0, sizeof(DolbyHiFilterBuffer));
+- memset(DolbyLoFilterDelay, 0, sizeof(DolbyLoFilterDelay));
+- memset(SurroundBuffer, 0, sizeof(SurroundBuffer));
+- nSurroundSize = (gdwMixingFreq * m_nProLogicDelay) / 1000;
+- if (nSurroundSize > SURROUNDBUFFERSIZE) nSurroundSize = SURROUNDBUFFERSIZE;
+- if (m_nProLogicDepth < 8) nDolbyDepth = (32 >> m_nProLogicDepth) + 32;
+- else nDolbyDepth = (m_nProLogicDepth < 16) ? (8 + (m_nProLogicDepth - 8) * 7) : 64;
+- nDolbyDepth >>= 2;
+- }
+- // Reverb Setup
+-#ifndef MODPLUG_NO_REVERB
+- if (gdwSoundSetup & SNDMIX_REVERB)
+- {
+- UINT nrs = (gdwMixingFreq * m_nReverbDelay) / 1000;
+- UINT nfa = m_nReverbDepth+1;
+- if (nrs > REVERBBUFFERSIZE) nrs = REVERBBUFFERSIZE;
+- if ((bReset) || (nrs != (UINT)nReverbSize) || (nfa != (UINT)nFilterAttn))
+- {
+- nFilterAttn = nfa;
+- nReverbSize = nrs;
+- nReverbBufferPos = nReverbBufferPos2 = nReverbBufferPos3 = nReverbBufferPos4 = 0;
+- nReverbLoFltSum = nReverbLoFltPos = nReverbLoDlyPos = 0;
+- gRvbLPSum = gRvbLPPos = 0;
+- nReverbSize2 = (nReverbSize * 13) / 17;
+- if (nReverbSize2 > REVERBBUFFERSIZE2) nReverbSize2 = REVERBBUFFERSIZE2;
+- nReverbSize3 = (nReverbSize * 7) / 13;
+- if (nReverbSize3 > REVERBBUFFERSIZE3) nReverbSize3 = REVERBBUFFERSIZE3;
+- nReverbSize4 = (nReverbSize * 7) / 19;
+- if (nReverbSize4 > REVERBBUFFERSIZE4) nReverbSize4 = REVERBBUFFERSIZE4;
+- memset(ReverbLoFilterBuffer, 0, sizeof(ReverbLoFilterBuffer));
+- memset(ReverbLoFilterDelay, 0, sizeof(ReverbLoFilterDelay));
+- memset(ReverbBuffer, 0, sizeof(ReverbBuffer));
+- memset(ReverbBuffer2, 0, sizeof(ReverbBuffer2));
+- memset(ReverbBuffer3, 0, sizeof(ReverbBuffer3));
+- memset(ReverbBuffer4, 0, sizeof(ReverbBuffer4));
+- memset(gRvbLowPass, 0, sizeof(gRvbLowPass));
+-/* mrsb: libmodplug bug hahahah */
+- memset(MixSoundBuffer,0,sizeof(MixSoundBuffer));
+- memset(MixReverbBuffer,0,sizeof(MixReverbBuffer));
+- }
+- } else nReverbSize = 0;
+-#endif
+- BOOL bResetBass = FALSE;
+- // Bass Expansion Reset
+- if (gdwSoundSetup & SNDMIX_MEGABASS)
+- {
+- UINT nXBassSamples = (gdwMixingFreq * m_nXBassRange) / 10000;
+- if (nXBassSamples > XBASSBUFFERSIZE) nXBassSamples = XBASSBUFFERSIZE;
+- UINT mask = GetMaskFromSize(nXBassSamples);
+- if ((bReset) || (mask != (UINT)nXBassMask))
+- {
+- nXBassMask = mask;
+- bResetBass = TRUE;
+- }
+- } else
+- {
+- nXBassMask = 0;
+- bResetBass = TRUE;
+- }
+- if (bResetBass)
+- {
+- nXBassSum = nXBassBufferPos = nXBassDlyPos = 0;
+- memset(XBassBuffer, 0, sizeof(XBassBuffer));
+- memset(XBassDelay, 0, sizeof(XBassDelay));
+- }
+-}
+-
+-
+-void CSoundFile::ProcessStereoDSP(int count)
+-//------------------------------------------
+-{
+-#ifndef MODPLUG_NO_REVERB
+- // Reverb
+- if (gdwSoundSetup & SNDMIX_REVERB)
+- {
+- int *pr = MixSoundBuffer, *pin = MixReverbBuffer, rvbcount = count;
+- do
+- {
+- int echo = ReverbBuffer[nReverbBufferPos] + ReverbBuffer2[nReverbBufferPos2]
+- + ReverbBuffer3[nReverbBufferPos3] + ReverbBuffer4[nReverbBufferPos4]; // echo = reverb signal
+- // Delay line and remove Low Frequencies // v = original signal
+- int echodly = ReverbLoFilterDelay[nReverbLoDlyPos]; // echodly = delayed signal
+- ReverbLoFilterDelay[nReverbLoDlyPos] = echo >> 1;
+- nReverbLoDlyPos++;
+- nReverbLoDlyPos &= 0x1F;
+- int n = nReverbLoFltPos;
+- nReverbLoFltSum -= ReverbLoFilterBuffer[n];
+- int tmp = echo / 128;
+- ReverbLoFilterBuffer[n] = tmp;
+- nReverbLoFltSum += tmp;
+- echodly -= nReverbLoFltSum;
+- nReverbLoFltPos = (n + 1) & 0x3F;
+- // Reverb
+- int v = (pin[0]+pin[1]) >> nFilterAttn;
+- pr[0] += pin[0] + echodly;
+- pr[1] += pin[1] + echodly;
+- v += echodly >> 2;
+- ReverbBuffer3[nReverbBufferPos3] = v;
+- ReverbBuffer4[nReverbBufferPos4] = v;
+- v += echodly >> 4;
+- v >>= 1;
+- gRvbLPSum -= gRvbLowPass[gRvbLPPos];
+- gRvbLPSum += v;
+- gRvbLowPass[gRvbLPPos] = v;
+- gRvbLPPos++;
+- gRvbLPPos &= 7;
+- int vlp = gRvbLPSum >> 2;
+- ReverbBuffer[nReverbBufferPos] = vlp;
+- ReverbBuffer2[nReverbBufferPos2] = vlp;
+- if (++nReverbBufferPos >= nReverbSize) nReverbBufferPos = 0;
+- if (++nReverbBufferPos2 >= nReverbSize2) nReverbBufferPos2 = 0;
+- if (++nReverbBufferPos3 >= nReverbSize3) nReverbBufferPos3 = 0;
+- if (++nReverbBufferPos4 >= nReverbSize4) nReverbBufferPos4 = 0;
+- pr += 2;
+- pin += 2;
+- } while (--rvbcount);
+- }
+-#endif
+- // Dolby Pro-Logic Surround
+- if (gdwSoundSetup & SNDMIX_SURROUND)
+- {
+- int *pr = MixSoundBuffer, n = nDolbyLoFltPos;
+- for (int r=count; r; r--)
+- {
+- int v = (pr[0]+pr[1]+DOLBYATTNROUNDUP) >> (nDolbyHiFltAttn+1);
+-#ifndef MODPLUG_FASTSOUNDLIB
+- v *= (int)nDolbyDepth;
+-#endif
+- // Low-Pass Filter
+- nDolbyHiFltSum -= DolbyHiFilterBuffer[nDolbyHiFltPos];
+- DolbyHiFilterBuffer[nDolbyHiFltPos] = v;
+- nDolbyHiFltSum += v;
+- v = nDolbyHiFltSum;
+- nDolbyHiFltPos++;
+- nDolbyHiFltPos &= nDolbyHiFltMask;
+- // Surround
+- int secho = SurroundBuffer[nSurroundPos];
+- SurroundBuffer[nSurroundPos] = v;
+- // Delay line and remove low frequencies
+- v = DolbyLoFilterDelay[nDolbyLoDlyPos]; // v = delayed signal
+- DolbyLoFilterDelay[nDolbyLoDlyPos] = secho; // secho = signal
+- nDolbyLoDlyPos++;
+- nDolbyLoDlyPos &= 0x1F;
+- nDolbyLoFltSum -= DolbyLoFilterBuffer[n];
+- int tmp = secho / 64;
+- DolbyLoFilterBuffer[n] = tmp;
+- nDolbyLoFltSum += tmp;
+- v -= nDolbyLoFltSum;
+- n++;
+- n &= 0x3F;
+- // Add echo
+- pr[0] += v;
+- pr[1] -= v;
+- if (++nSurroundPos >= nSurroundSize) nSurroundPos = 0;
+- pr += 2;
+- }
+- nDolbyLoFltPos = n;
+- }
+- // Bass Expansion
+- if (gdwSoundSetup & SNDMIX_MEGABASS)
+- {
+- int *px = MixSoundBuffer;
+- int xba = m_nXBassDepth+1, xbamask = (1 << xba) - 1;
+- int n = nXBassBufferPos;
+- for (int x=count; x; x--)
+- {
+- nXBassSum -= XBassBuffer[n];
+- int tmp0 = px[0] + px[1];
+- int tmp = (tmp0 + ((tmp0 >> 31) & xbamask)) >> xba;
+- XBassBuffer[n] = tmp;
+- nXBassSum += tmp;
+- int v = XBassDelay[nXBassDlyPos];
+- XBassDelay[nXBassDlyPos] = px[0];
+- px[0] = v + nXBassSum;
+- v = XBassDelay[nXBassDlyPos+1];
+- XBassDelay[nXBassDlyPos+1] = px[1];
+- px[1] = v + nXBassSum;
+- nXBassDlyPos = (nXBassDlyPos + 2) & nXBassMask;
+- px += 2;
+- n++;
+- n &= nXBassMask;
+- }
+- nXBassBufferPos = n;
+- }
+- // Noise Reduction
+- if (gdwSoundSetup & SNDMIX_NOISEREDUCTION)
+- {
+- int n1 = nLeftNR, n2 = nRightNR;
+- int *pnr = MixSoundBuffer;
+- for (int nr=count; nr; nr--)
+- {
+- int vnr = pnr[0] >> 1;
+- pnr[0] = vnr + n1;
+- n1 = vnr;
+- vnr = pnr[1] >> 1;
+- pnr[1] = vnr + n2;
+- n2 = vnr;
+- pnr += 2;
+- }
+- nLeftNR = n1;
+- nRightNR = n2;
+- }
+-}
+-
+-
+-void CSoundFile::ProcessMonoDSP(int count)
+-//----------------------------------------
+-{
+-#ifndef MODPLUG_NO_REVERB
+- // Reverb
+- if (gdwSoundSetup & SNDMIX_REVERB)
+- {
+- int *pr = MixSoundBuffer, rvbcount = count, *pin = MixReverbBuffer;
+- do
+- {
+- int echo = ReverbBuffer[nReverbBufferPos] + ReverbBuffer2[nReverbBufferPos2]
+- + ReverbBuffer3[nReverbBufferPos3] + ReverbBuffer4[nReverbBufferPos4]; // echo = reverb signal
+- // Delay line and remove Low Frequencies // v = original signal
+- int echodly = ReverbLoFilterDelay[nReverbLoDlyPos]; // echodly = delayed signal
+- ReverbLoFilterDelay[nReverbLoDlyPos] = echo >> 1;
+- nReverbLoDlyPos++;
+- nReverbLoDlyPos &= 0x1F;
+- int n = nReverbLoFltPos;
+- nReverbLoFltSum -= ReverbLoFilterBuffer[n];
+- int tmp = echo / 128;
+- ReverbLoFilterBuffer[n] = tmp;
+- nReverbLoFltSum += tmp;
+- echodly -= nReverbLoFltSum;
+- nReverbLoFltPos = (n + 1) & 0x3F;
+- // Reverb
+- int v = pin[0] >> (nFilterAttn-1);
+- *pr++ += pin[0] + echodly;
+- pin++;
+- v += echodly >> 2;
+- ReverbBuffer3[nReverbBufferPos3] = v;
+- ReverbBuffer4[nReverbBufferPos4] = v;
+- v += echodly >> 4;
+- v >>= 1;
+- gRvbLPSum -= gRvbLowPass[gRvbLPPos];
+- gRvbLPSum += v;
+- gRvbLowPass[gRvbLPPos] = v;
+- gRvbLPPos++;
+- gRvbLPPos &= 7;
+- int vlp = gRvbLPSum >> 2;
+- ReverbBuffer[nReverbBufferPos] = vlp;
+- ReverbBuffer2[nReverbBufferPos2] = vlp;
+- if (++nReverbBufferPos >= nReverbSize) nReverbBufferPos = 0;
+- if (++nReverbBufferPos2 >= nReverbSize2) nReverbBufferPos2 = 0;
+- if (++nReverbBufferPos3 >= nReverbSize3) nReverbBufferPos3 = 0;
+- if (++nReverbBufferPos4 >= nReverbSize4) nReverbBufferPos4 = 0;
+- } while (--rvbcount);
+- }
+-#endif
+- // Bass Expansion
+- if (gdwSoundSetup & SNDMIX_MEGABASS)
+- {
+- int *px = MixSoundBuffer;
+- int xba = m_nXBassDepth, xbamask = (1 << xba)-1;
+- int n = nXBassBufferPos;
+- for (int x=count; x; x--)
+- {
+- nXBassSum -= XBassBuffer[n];
+- int tmp0 = *px;
+- int tmp = (tmp0 + ((tmp0 >> 31) & xbamask)) >> xba;
+- XBassBuffer[n] = tmp;
+- nXBassSum += tmp;
+- int v = XBassDelay[nXBassDlyPos];
+- XBassDelay[nXBassDlyPos] = *px;
+- *px++ = v + nXBassSum;
+- nXBassDlyPos = (nXBassDlyPos + 2) & nXBassMask;
+- n++;
+- n &= nXBassMask;
+- }
+- nXBassBufferPos = n;
+- }
+- // Noise Reduction
+- if (gdwSoundSetup & SNDMIX_NOISEREDUCTION)
+- {
+- int n = nLeftNR;
+- int *pnr = MixSoundBuffer;
+- for (int nr=count; nr; pnr++, nr--)
+- {
+- int vnr = *pnr >> 1;
+- *pnr = vnr + n;
+- n = vnr;
+- }
+- nLeftNR = n;
+- }
+-}
+-
+-
+-/////////////////////////////////////////////////////////////////
+-// Clean DSP Effects interface
+-
+-// [Reverb level 0(quiet)-100(loud)], [delay in ms, usually 40-200ms]
+-BOOL CSoundFile::SetReverbParameters(UINT nDepth, UINT nDelay)
+-//------------------------------------------------------------
+-{
+- if (nDepth > 100) nDepth = 100;
+- UINT gain = nDepth / 20;
+- if (gain > 4) gain = 4;
+- m_nReverbDepth = 4 - gain;
+- if (nDelay < 40) nDelay = 40;
+- if (nDelay > 250) nDelay = 250;
+- m_nReverbDelay = nDelay;
+- return TRUE;
+-}
+-
+-
+-// [XBass level 0(quiet)-100(loud)], [cutoff in Hz 20-100]
+-BOOL CSoundFile::SetXBassParameters(UINT nDepth, UINT nRange)
+-//-----------------------------------------------------------
+-{
+- if (nDepth > 100) nDepth = 100;
+- UINT gain = nDepth / 20;
+- if (gain > 4) gain = 4;
+- m_nXBassDepth = 8 - gain; // filter attenuation 1/256 .. 1/16
+- UINT range = nRange / 5;
+- if (range > 5) range -= 5; else range = 0;
+- if (nRange > 16) nRange = 16;
+- m_nXBassRange = 21 - range; // filter average on 0.5-1.6ms
+- return TRUE;
+-}
+-
+-
+-// [Surround level 0(quiet)-100(heavy)] [delay in ms, usually 5-50ms]
+-BOOL CSoundFile::SetSurroundParameters(UINT nDepth, UINT nDelay)
+-//--------------------------------------------------------------
+-{
+- UINT gain = (nDepth * 16) / 100;
+- if (gain > 16) gain = 16;
+- if (gain < 1) gain = 1;
+- m_nProLogicDepth = gain;
+- if (nDelay < 4) nDelay = 4;
+- if (nDelay > 50) nDelay = 50;
+- m_nProLogicDelay = nDelay;
+- return TRUE;
+-}
+-
+-BOOL CSoundFile::SetWaveConfigEx(BOOL bSurround,BOOL /*bNoOverSampling*/,BOOL bReverb,BOOL hqido,BOOL bMegaBass,BOOL bNR,BOOL bEQ)
+-//----------------------------------------------------------------------------------------------------------------------------
+-{
+- DWORD d = gdwSoundSetup & ~(SNDMIX_SURROUND | SNDMIX_NORESAMPLING | SNDMIX_REVERB | SNDMIX_HQRESAMPLER | SNDMIX_MEGABASS | SNDMIX_NOISEREDUCTION | SNDMIX_EQ);
+- if (bSurround) d |= SNDMIX_SURROUND;
+-// if (bNoOverSampling) d |= SNDMIX_NORESAMPLING;
+- if (bReverb) d |= SNDMIX_REVERB;
+- if (hqido) d |= SNDMIX_HQRESAMPLER;
+- if (bMegaBass) d |= SNDMIX_MEGABASS;
+- if (bNR) d |= SNDMIX_NOISEREDUCTION;
+- if (bEQ) d |= SNDMIX_EQ;
+- gdwSoundSetup = d;
+- InitPlayer(FALSE);
+- return TRUE;
+-}
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/snd_eq.cxx audacious-plugins-2.5.4/src/modplug/snd_eq.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/snd_eq.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/snd_eq.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,228 +0,0 @@
+-/*
+- * This program is free software; you can redistribute it and modify it
+- * under the terms of the GNU General Public License as published by the
+- * Free Software Foundation; either version 2 of the license or (at your
+- * option) any later version.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+- *
+- * Name Date Description
+- *
+- * Olivier Lapicque --/--/-- Creation
+- * Trevor Nunes 26/01/04 conditional compilation for AMD,MMX calls
+- *
+-*/
+-#include "stdafx.h"
+-#include "sndfile.h"
+-#include <math.h>
+-
+-
+-#define EQ_BANDWIDTH 2.0
+-#define EQ_ZERO 0.000001
+-#define REAL float
+-
+-extern REAL MixFloatBuffer[];
+-
+-extern void StereoMixToFloat(const int *pSrc, float *pOut1, float *pOut2, UINT nCount);
+-extern void FloatToStereoMix(const float *pIn1, const float *pIn2, int *pOut, UINT nCount);
+-extern void MonoMixToFloat(const int *pSrc, float *pOut, UINT nCount);
+-extern void FloatToMonoMix(const float *pIn, int *pOut, UINT nCount);
+-
+-typedef struct _EQBANDSTRUCT
+-{
+- REAL a0, a1, a2, b1, b2;
+- REAL x1, x2, y1, y2;
+- REAL Gain, CenterFrequency;
+- BOOL bEnable;
+-} EQBANDSTRUCT, *PEQBANDSTRUCT;
+-
+-UINT gEqLinearToDB[33] =
+-{
+- 16, 19, 22, 25, 28, 31, 34, 37,
+- 40, 43, 46, 49, 52, 55, 58, 61,
+- 64, 76, 88, 100, 112, 124, 136, 148,
+- 160, 172, 184, 196, 208, 220, 232, 244, 256
+-};
+-
+-
+-//static REAL f2ic = (REAL)(1 << 28);
+-//static REAL i2fc = (REAL)(1.0 / (1 << 28));
+-
+-static EQBANDSTRUCT gEQ[MAX_EQ_BANDS*2] =
+-{
+- // Default: Flat EQ
+- {0,0,0,0,0, 0,0,0,0, 1, 120, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 600, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 1200, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 3000, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 6000, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 10000, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 120, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 600, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 1200, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 3000, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 6000, FALSE},
+- {0,0,0,0,0, 0,0,0,0, 1, 10000, FALSE},
+-};
+-
+-void EQFilter(EQBANDSTRUCT *pbs, REAL *pbuffer, UINT nCount)
+-//----------------------------------------------------------
+-{
+- for (UINT i=0; i<nCount; i++)
+- {
+- REAL x = pbuffer[i];
+- REAL y = pbs->a1 * pbs->x1 + pbs->a2 * pbs->x2 + pbs->a0 * x + pbs->b1 * pbs->y1 + pbs->b2 * pbs->y2;
+- pbs->x2 = pbs->x1;
+- pbs->y2 = pbs->y1;
+- pbs->x1 = x;
+- pbuffer[i] = y;
+- pbs->y1 = y;
+- }
+-}
+-
+-void CSoundFile::EQMono(int *pbuffer, UINT nCount)
+-//------------------------------------------------
+-{
+- MonoMixToFloat(pbuffer, MixFloatBuffer, nCount);
+- for (UINT b=0; b<MAX_EQ_BANDS; b++)
+- {
+- if ((gEQ[b].bEnable) && (gEQ[b].Gain != 1.0f))
+- EQFilter(&gEQ[b], MixFloatBuffer, nCount);
+- }
+- FloatToMonoMix(MixFloatBuffer, pbuffer, nCount);
+-}
+-
+-void CSoundFile::EQStereo(int *pbuffer, UINT nCount)
+-//--------------------------------------------------
+-{
+- StereoMixToFloat(pbuffer, MixFloatBuffer, MixFloatBuffer+MIXBUFFERSIZE, nCount);
+-
+- for (UINT bl=0; bl<MAX_EQ_BANDS; bl++)
+- {
+- if ((gEQ[bl].bEnable) && (gEQ[bl].Gain != 1.0f))
+- EQFilter(&gEQ[bl], MixFloatBuffer, nCount);
+- }
+- for (UINT br=MAX_EQ_BANDS; br<MAX_EQ_BANDS*2; br++)
+- {
+- if ((gEQ[br].bEnable) && (gEQ[br].Gain != 1.0f))
+- EQFilter(&gEQ[br], MixFloatBuffer+MIXBUFFERSIZE, nCount);
+- }
+-
+- FloatToStereoMix(MixFloatBuffer, MixFloatBuffer+MIXBUFFERSIZE, pbuffer, nCount);
+-
+-}
+-
+-void CSoundFile::InitializeEQ(BOOL bReset)
+-//----------------------------------------
+-{
+- REAL fMixingFreq = (REAL)gdwMixingFreq;
+- // Gain = 0.5 (-6dB) .. 2 (+6dB)
+- for (UINT band=0; band<MAX_EQ_BANDS*2; band++) if (gEQ[band].bEnable)
+- {
+- REAL k, k2, r, f;
+- REAL v0, v1;
+- BOOL b = bReset;
+-
+- f = gEQ[band].CenterFrequency / fMixingFreq;
+- if (f > 0.45f) gEQ[band].Gain = 1;
+- // if (f > 0.25) f = 0.25;
+- // k = tan(PI*f);
+- k = f * 3.141592654f;
+- k = k + k*f;
+-// if (k > (REAL)0.707) k = (REAL)0.707;
+- k2 = k*k;
+- v0 = gEQ[band].Gain;
+- v1 = 1;
+- if (gEQ[band].Gain < 1.0)
+- {
+- v0 *= (0.5f/EQ_BANDWIDTH);
+- v1 *= (0.5f/EQ_BANDWIDTH);
+- } else
+- {
+- v0 *= (1.0f/EQ_BANDWIDTH);
+- v1 *= (1.0f/EQ_BANDWIDTH);
+- }
+- r = (1 + v0*k + k2) / (1 + v1*k + k2);
+- if (r != gEQ[band].a0)
+- {
+- gEQ[band].a0 = r;
+- b = TRUE;
+- }
+- r = 2 * (k2 - 1) / (1 + v1*k + k2);
+- if (r != gEQ[band].a1)
+- {
+- gEQ[band].a1 = r;
+- b = TRUE;
+- }
+- r = (1 - v0*k + k2) / (1 + v1*k + k2);
+- if (r != gEQ[band].a2)
+- {
+- gEQ[band].a2 = r;
+- b = TRUE;
+- }
+- r = - 2 * (k2 - 1) / (1 + v1*k + k2);
+- if (r != gEQ[band].b1)
+- {
+- gEQ[band].b1 = r;
+- b = TRUE;
+- }
+- r = - (1 - v1*k + k2) / (1 + v1*k + k2);
+- if (r != gEQ[band].b2)
+- {
+- gEQ[band].b2 = r;
+- b = TRUE;
+- }
+- if (b)
+- {
+- gEQ[band].x1 = 0;
+- gEQ[band].x2 = 0;
+- gEQ[band].y1 = 0;
+- gEQ[band].y2 = 0;
+- }
+- } else
+- {
+- gEQ[band].a0 = 0;
+- gEQ[band].a1 = 0;
+- gEQ[band].a2 = 0;
+- gEQ[band].b1 = 0;
+- gEQ[band].b2 = 0;
+- gEQ[band].x1 = 0;
+- gEQ[band].x2 = 0;
+- gEQ[band].y1 = 0;
+- gEQ[band].y2 = 0;
+- }
+-}
+-
+-
+-void CSoundFile::SetEQGains(const UINT *pGains, UINT nGains, const UINT *pFreqs, BOOL bReset)
+-//-------------------------------------------------------------------------------------------
+-{
+- for (UINT i=0; i<MAX_EQ_BANDS; i++)
+- {
+- REAL g, f = 0;
+- if (i < nGains)
+- {
+- UINT n = pGains[i];
+-// if (n > 32) n = 32;
+- g = 1.0 + (((double)n) / 64.0);
+- if (pFreqs) f = (REAL)(int)pFreqs[i];
+- } else
+- {
+- g = 1;
+- }
+- gEQ[i].Gain = g;
+- gEQ[i].CenterFrequency = f;
+- gEQ[i+MAX_EQ_BANDS].Gain = g;
+- gEQ[i+MAX_EQ_BANDS].CenterFrequency = f;
+- if (f > 20.0f && i < nGains) /* don't enable bands outside... */
+- {
+- gEQ[i].bEnable = TRUE;
+- gEQ[i+MAX_EQ_BANDS].bEnable = TRUE;
+- } else
+- {
+- gEQ[i].bEnable = FALSE;
+- gEQ[i+MAX_EQ_BANDS].bEnable = FALSE;
+- }
+- }
+- InitializeEQ(bReset);
+-}
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/sndfile.cxx audacious-plugins-2.5.4/src/modplug/sndfile.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/sndfile.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/sndfile.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,1690 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include <math.h> //for GCCFIX
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#define MMCMP_SUPPORT
+-
+-#ifdef MMCMP_SUPPORT
+-extern BOOL MMCMP_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength);
+-#endif
+-
+-
+-// External decompressors
+-extern void AMSUnpack(const char *psrc, UINT inputlen, char *pdest, UINT dmax, char packcharacter);
+-extern WORD MDLReadBits(DWORD &bitbuf, UINT &bitnum, LPBYTE &ibuf, CHAR n);
+-extern int DMFUnpack(LPBYTE psample, LPBYTE ibuf, LPBYTE ibufmax, UINT maxlen);
+-extern DWORD ITReadBits(DWORD &bitbuf, UINT &bitnum, LPBYTE &ibuf, CHAR n);
+-extern void ITUnpack8Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215);
+-extern void ITUnpack16Bit(signed char *pSample, DWORD dwLen, LPBYTE lpMemFile, DWORD dwMemLength, BOOL b215);
+-
+-
+-#define MAX_PACK_TABLES 3
+-
+-
+-// Compression table
+-static signed char UnpackTable[MAX_PACK_TABLES][16] =
+-//--------------------------------------------
+-{
+- // CPU-generated dynamic table
+- {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+- // u-Law table
+- {0, 1, 2, 4, 8, 16, 32, 64,
+- -1, -2, -4, -8, -16, -32, -48, -64},
+- // Linear table
+- {0, 1, 2, 3, 5, 7, 12, 19,
+- -1, -2, -3, -5, -7, -12, -19, -31}
+-};
+-
+-
+-//////////////////////////////////////////////////////////
+-// CSoundFile
+-
+-CSoundFile::CSoundFile()
+-//----------------------
+-{
+- m_nType = MOD_TYPE_NONE;
+- m_dwSongFlags = 0;
+- m_nStereoSeparation = 128;
+- m_nChannels = 0;
+- m_nMixChannels = 0;
+- m_nSamples = 0;
+- m_nInstruments = 0;
+- m_nPatternNames = 0;
+- m_lpszPatternNames = NULL;
+- m_lpszSongComments = NULL;
+- m_nFreqFactor = m_nTempoFactor = 128;
+- m_nMasterVolume = 128;
+- m_nMinPeriod = 0x20;
+- m_nMaxPeriod = 0x7FFF;
+- m_nRepeatCount = 0;
+- m_rowHighlightMajor = 16;
+- m_rowHighlightMinor = 4;
+- memset(Chn, 0, sizeof(Chn));
+- memset(ChnMix, 0, sizeof(ChnMix));
+- memset(Ins, 0, sizeof(Ins));
+- memset(ChnSettings, 0, sizeof(ChnSettings));
+- memset(Headers, 0, sizeof(Headers));
+- memset(Order, 0xFF, sizeof(Order));
+- memset(Patterns, 0, sizeof(Patterns));
+- memset(m_szNames, 0, sizeof(m_szNames));
+- memset(m_MixPlugins, 0, sizeof(m_MixPlugins));
+-}
+-
+-
+-CSoundFile::~CSoundFile()
+-//-----------------------
+-{
+- Destroy();
+-}
+-
+-
+-BOOL CSoundFile::Create(LPCBYTE lpStream, DWORD dwMemLength)
+-//----------------------------------------------------------
+-{
+- int i;
+-
+- // deja vu...
+- m_nType = MOD_TYPE_NONE;
+- m_dwSongFlags = 0;
+- m_nStereoSeparation = 128;
+- m_nChannels = 0;
+- m_nMixChannels = 0;
+- m_nSamples = 0;
+- m_nInstruments = 0;
+- m_nFreqFactor = m_nTempoFactor = 128;
+- m_nMasterVolume = 128;
+- m_nDefaultGlobalVolume = 256;
+- m_nGlobalVolume = 256;
+- m_nOldGlbVolSlide = 0;
+- m_nDefaultSpeed = 6;
+- m_nDefaultTempo = 125;
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+- m_nNextRow = 0;
+- m_nRow = 0;
+- m_nPattern = 0;
+- m_nCurrentPattern = 0;
+- m_nNextPattern = 0;
+- m_nRestartPos = 0;
+- m_nMinPeriod = 16;
+- m_nMaxPeriod = 32767;
+- m_nSongPreAmp = 0x30;
+- m_nPatternNames = 0;
+- m_lpszPatternNames = NULL;
+- m_lpszSongComments = NULL;
+- memset(Ins, 0, sizeof(Ins));
+- memset(ChnMix, 0, sizeof(ChnMix));
+- memset(Chn, 0, sizeof(Chn));
+- memset(Headers, 0, sizeof(Headers));
+- memset(Order, 0xFF, sizeof(Order));
+- memset(Patterns, 0, sizeof(Patterns));
+- memset(m_szNames, 0, sizeof(m_szNames));
+- memset(m_MixPlugins, 0, sizeof(m_MixPlugins));
+- ResetMidiCfg();
+- for (UINT npt=0; npt<MAX_PATTERNS; npt++) {
+- PatternSize[npt] = 64;
+- PatternAllocSize[npt] = 64;
+- }
+- for (UINT nch=0; nch<MAX_BASECHANNELS; nch++)
+- {
+- ChnSettings[nch].nPan = 128;
+- ChnSettings[nch].nVolume = 64;
+- ChnSettings[nch].dwFlags = 0;
+- ChnSettings[nch].szName[0] = 0;
+- }
+- if (lpStream)
+- {
+-#ifdef MMCMP_SUPPORT
+- BOOL bMMCmp = MMCMP_Unpack(&lpStream, &dwMemLength);
+-#endif
+- if ((!ReadXM(lpStream, dwMemLength))
+- && (!Read669(lpStream, dwMemLength))
+- && (!ReadS3M(lpStream, dwMemLength))
+- && (!ReadIT(lpStream, dwMemLength))
+- && (!ReadWav(lpStream, dwMemLength))
+- && (!ReadSTM(lpStream, dwMemLength))
+- && (!ReadMed(lpStream, dwMemLength))
+- && (!ReadMTM(lpStream, dwMemLength))
+- && (!ReadMDL(lpStream, dwMemLength))
+- && (!ReadDBM(lpStream, dwMemLength))
+- && (!ReadFAR(lpStream, dwMemLength))
+- && (!ReadAMS(lpStream, dwMemLength))
+- && (!ReadOKT(lpStream, dwMemLength))
+- && (!ReadPTM(lpStream, dwMemLength))
+- && (!ReadUlt(lpStream, dwMemLength))
+- && (!ReadDMF(lpStream, dwMemLength))
+- && (!ReadDSM(lpStream, dwMemLength))
+- && (!ReadUMX(lpStream, dwMemLength))
+- && (!ReadAMF(lpStream, dwMemLength))
+- && (!ReadPSM(lpStream, dwMemLength))
+- && (!ReadMT2(lpStream, dwMemLength))
+- && (!ReadMod(lpStream, dwMemLength))) m_nType = MOD_TYPE_NONE;
+-#ifdef MMCMP_SUPPORT
+- if (bMMCmp)
+- {
+- GlobalFreePtr(lpStream);
+- lpStream = NULL;
+- }
+-#endif
+- }
+- // Adjust channels
+- for (i=0; i<MAX_BASECHANNELS; i++)
+- {
+- if (ChnSettings[i].nVolume > 64) ChnSettings[i].nVolume = 64;
+- if (ChnSettings[i].nPan > 256) ChnSettings[i].nPan = 128;
+- Chn[i].nPan = ChnSettings[i].nPan;
+- Chn[i].nGlobalVol = ChnSettings[i].nVolume;
+- Chn[i].dwFlags = ChnSettings[i].dwFlags;
+- Chn[i].nVolume = 256;
+- Chn[i].nCutOff = 0x7F;
+- }
+- // Checking instruments
+- MODINSTRUMENT *pins = Ins;
+-
+- for (i=0; i<MAX_INSTRUMENTS; i++, pins++)
+- {
+- if (pins->pSample)
+- {
+- if (pins->nLoopEnd > pins->nLength) pins->nLoopEnd = pins->nLength;
+- if (pins->nSustainEnd > pins->nLength) pins->nSustainEnd = pins->nLength;
+- } else {
+- pins->nLength = 0;
+- pins->nLoopStart = 0;
+- pins->nLoopEnd = 0;
+- pins->nSustainStart = 0;
+- pins->nSustainEnd = 0;
+- }
+- if (!pins->nLoopEnd) pins->uFlags &= ~CHN_LOOP;
+- if (!pins->nSustainEnd) pins->uFlags &= ~CHN_SUSTAINLOOP;
+- if (pins->nGlobalVol > 64) pins->nGlobalVol = 64;
+- }
+- // Check invalid instruments
+- while ((m_nInstruments > 0) && (!Headers[m_nInstruments])) m_nInstruments--;
+- // Set default values
+- if (m_nDefaultTempo < 31) m_nDefaultTempo = 31;
+- if (!m_nDefaultSpeed) m_nDefaultSpeed = 6;
+- m_nMusicSpeed = m_nDefaultSpeed;
+- m_nMusicTempo = m_nDefaultTempo;
+- m_nGlobalVolume = m_nDefaultGlobalVolume;
+- m_nNextPattern = 0;
+- m_nCurrentPattern = 0;
+- m_nPattern = 0;
+- m_nBufferCount = 0;
+- m_nTickCount = m_nMusicSpeed;
+- m_nNextRow = 0;
+- m_nRow = 0;
+- if ((m_nRestartPos >= MAX_ORDERS) || (Order[m_nRestartPos] >= MAX_PATTERNS)) m_nRestartPos = 0;
+- // Load plugins
+- if (gpMixPluginCreateProc)
+- {
+- for (UINT iPlug=0; iPlug<MAX_MIXPLUGINS; iPlug++)
+- {
+- if ((m_MixPlugins[iPlug].Info.dwPluginId1)
+- || (m_MixPlugins[iPlug].Info.dwPluginId2))
+- {
+- gpMixPluginCreateProc(&m_MixPlugins[iPlug]);
+- if (m_MixPlugins[iPlug].pMixPlugin)
+- {
+- m_MixPlugins[iPlug].pMixPlugin->RestoreAllParameters();
+- }
+- }
+- }
+- }
+- return m_nType ? TRUE : FALSE;
+-}
+-
+-
+-BOOL CSoundFile::Destroy()
+-
+-//------------------------
+-{
+- int i;
+- for (i=0; i<MAX_PATTERNS; i++) if (Patterns[i])
+- {
+- FreePattern(Patterns[i]);
+- Patterns[i] = NULL;
+- }
+- m_nPatternNames = 0;
+- if (m_lpszPatternNames)
+- {
+- delete m_lpszPatternNames;
+- m_lpszPatternNames = NULL;
+- }
+- if (m_lpszSongComments)
+- {
+- delete m_lpszSongComments;
+- m_lpszSongComments = NULL;
+- }
+- for (i=1; i<MAX_SAMPLES; i++)
+- {
+- MODINSTRUMENT *pins = &Ins[i];
+- if (pins->pSample)
+- {
+- FreeSample(pins->pSample);
+- pins->pSample = NULL;
+- }
+- }
+- for (i=0; i<MAX_INSTRUMENTS; i++)
+- {
+- if (Headers[i])
+- {
+- delete Headers[i];
+- Headers[i] = NULL;
+- }
+- }
+- for (i=0; i<MAX_MIXPLUGINS; i++)
+- {
+- if ((m_MixPlugins[i].nPluginDataSize) && (m_MixPlugins[i].pPluginData))
+- {
+- m_MixPlugins[i].nPluginDataSize = 0;
+- delete [] (signed char*)m_MixPlugins[i].pPluginData;
+- m_MixPlugins[i].pPluginData = NULL;
+- }
+- m_MixPlugins[i].pMixState = NULL;
+- if (m_MixPlugins[i].pMixPlugin)
+- {
+- m_MixPlugins[i].pMixPlugin->Release();
+- m_MixPlugins[i].pMixPlugin = NULL;
+- }
+- }
+- m_nType = MOD_TYPE_NONE;
+- m_nChannels = m_nSamples = m_nInstruments = 0;
+- return TRUE;
+-}
+-
+-
+-//////////////////////////////////////////////////////////////////////////
+-// Memory Allocation
+-
+-MODCOMMAND *CSoundFile::AllocatePattern(UINT rows, UINT nchns)
+-//------------------------------------------------------------
+-{
+- MODCOMMAND *p = new MODCOMMAND[rows*nchns];
+- if (p) memset(p, 0, rows*nchns*sizeof(MODCOMMAND));
+- return p;
+-}
+-
+-
+-void CSoundFile::FreePattern(LPVOID pat)
+-//--------------------------------------
+-{
+- if (pat) delete [] (signed char*)pat;
+-}
+-
+-
+-signed char* CSoundFile::AllocateSample(UINT nbytes)
+-//-------------------------------------------
+-{
+- signed char * p = (signed char *)GlobalAllocPtr(GHND, (nbytes+39) & ~7);
+- if (p) p += 16;
+- return p;
+-}
+-
+-
+-void CSoundFile::FreeSample(LPVOID p)
+-//-----------------------------------
+-{
+- if (p)
+- {
+- GlobalFreePtr(((LPSTR)p)-16);
+- }
+-}
+-
+-
+-//////////////////////////////////////////////////////////////////////////
+-// Misc functions
+-
+-void CSoundFile::ResetMidiCfg()
+-//-----------------------------
+-{
+- memset(&m_MidiCfg, 0, sizeof(m_MidiCfg));
+- lstrcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_START*32], "FF");
+- lstrcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_STOP*32], "FC");
+- lstrcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_NOTEON*32], "9c n v");
+- lstrcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_NOTEOFF*32], "9c n 0");
+- lstrcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_PROGRAM*32], "Cc p");
+- lstrcpy(&m_MidiCfg.szMidiSFXExt[0], "F0F000z");
+- for (int iz=0; iz<16; iz++) wsprintf(&m_MidiCfg.szMidiZXXExt[iz*32], "F0F001%02X", iz*8);
+-}
+-
+-
+-UINT CSoundFile::GetNumChannels() const
+-//-------------------------------------
+-{
+- UINT n = 0;
+- for (UINT i=0; i<m_nChannels; i++) if (ChnSettings[i].nVolume) n++;
+- return n;
+-}
+-
+-
+-UINT CSoundFile::GetSongComments(LPSTR s, UINT len, UINT linesize)
+-//----------------------------------------------------------------
+-{
+- LPCSTR p = m_lpszSongComments;
+- if (!p) return 0;
+- UINT i = 2, ln=0;
+- if ((len) && (s)) s[0] = '\x0D';
+- if ((len > 1) && (s)) s[1] = '\x0A';
+- while ((*p) && (i+2 < len))
+- {
+- BYTE c = (BYTE)*p++;
+- if ((c == 0x0D) || ((c == ' ') && (ln >= linesize)))
+- { if (s) { s[i++] = '\x0D'; s[i++] = '\x0A'; } else i+= 2; ln=0; }
+- else
+- if (c >= 0x20) { if (s) s[i++] = c; else i++; ln++; }
+- }
+- if (s) s[i] = 0;
+- return i;
+-}
+-
+-
+-UINT CSoundFile::GetRawSongComments(LPSTR s, UINT len, UINT linesize)
+-//-------------------------------------------------------------------
+-{
+- LPCSTR p = m_lpszSongComments;
+- if (!p) return 0;
+- UINT i = 0, ln=0;
+- while ((*p) && (i < len-1))
+- {
+- BYTE c = (BYTE)*p++;
+- if ((c == 0x0D) || (c == 0x0A))
+- {
+- if (ln)
+- {
+- while (ln < linesize) { if (s) s[i] = ' '; i++; ln++; }
+- ln = 0;
+- }
+- } else
+- if ((c == ' ') && (!ln))
+- {
+- UINT k=0;
+- while ((p[k]) && (p[k] >= ' ')) k++;
+- if (k <= linesize)
+- {
+- if (s) s[i] = ' ';
+- i++;
+- ln++;
+- }
+- } else
+- {
+- if (s) s[i] = c;
+- i++;
+- ln++;
+- if (ln == linesize) ln = 0;
+- }
+- }
+- if (ln)
+- {
+- while ((ln < linesize) && (i < len))
+- {
+- if (s) s[i] = ' ';
+- i++;
+- ln++;
+- }
+- }
+- if (s) s[i] = 0;
+- return i;
+-}
+-
+-
+-BOOL CSoundFile::SetWaveConfig(UINT nRate,UINT nBits,UINT nChannels,BOOL bMMX)
+-//----------------------------------------------------------------------------
+-{
+- BOOL bReset = FALSE;
+- DWORD d = gdwSoundSetup & ~SNDMIX_ENABLEMMX;
+- if (bMMX) d |= SNDMIX_ENABLEMMX;
+- if ((gdwMixingFreq != nRate) || (gnBitsPerSample != nBits) || (gnChannels != nChannels) || (d != gdwSoundSetup)) bReset = TRUE;
+- gnChannels = nChannels;
+- gdwSoundSetup = d;
+- gdwMixingFreq = nRate;
+- gnBitsPerSample = nBits;
+- InitPlayer(bReset);
+-//printf("Rate=%u Bits=%u Channels=%u MMX=%u\n",gdwMixingFreq,gnBitsPerSample,gnChannels,bMMX);
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::SetResamplingMode(UINT nMode)
+-//--------------------------------------------
+-{
+- DWORD d = gdwSoundSetup & ~(SNDMIX_NORESAMPLING|SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE);
+- switch(nMode)
+- {
+- case SRCMODE_NEAREST: d |= SNDMIX_NORESAMPLING; break;
+- case SRCMODE_LINEAR: break;
+- case SRCMODE_SPLINE: d |= SNDMIX_HQRESAMPLER; break;
+- case SRCMODE_POLYPHASE: d |= (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE); break;
+- default:
+- return FALSE;
+- }
+- gdwSoundSetup = d;
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::SetMasterVolume(UINT nVol, BOOL bAdjustAGC)
+-//----------------------------------------------------------
+-{
+- if (nVol < 1) nVol = 1;
+- if (nVol > 0x200) nVol = 0x200; // x4 maximum
+- if ((gdwSoundSetup & SNDMIX_AGC) && (bAdjustAGC))
+- {
+- gnAGC = gnAGC * m_nMasterVolume / nVol;
+- if (gnAGC > AGC_UNITY) gnAGC = AGC_UNITY;
+- }
+- m_nMasterVolume = nVol;
+- return TRUE;
+-}
+-
+-
+-void CSoundFile::SetAGC(BOOL b)
+-//-----------------------------
+-{
+- if (b)
+- {
+- if (!(gdwSoundSetup & SNDMIX_AGC))
+- {
+- gdwSoundSetup |= SNDMIX_AGC;
+- gnAGC = AGC_UNITY;
+- }
+- } else gdwSoundSetup &= ~SNDMIX_AGC;
+-}
+-
+-
+-UINT CSoundFile::GetNumPatterns() const
+-//-------------------------------------
+-{
+- UINT i = 0;
+- while ((i < MAX_ORDERS) && (Order[i] < 0xFF)) i++;
+- return i;
+-}
+-
+-
+-UINT CSoundFile::GetNumInstruments() const
+-//----------------------------------------
+-{
+- UINT n=0;
+- for (UINT i=0; i<MAX_INSTRUMENTS; i++) if (Ins[i].pSample) n++;
+- return n;
+-}
+-
+-
+-UINT CSoundFile::GetMaxPosition() const
+-//-------------------------------------
+-{
+- UINT max = 0;
+- UINT i = 0;
+-
+- while ((i < MAX_ORDERS) && (Order[i] != 0xFF))
+- {
+- if (Order[i] < MAX_PATTERNS) max += PatternSize[Order[i]];
+- i++;
+- }
+- return max;
+-}
+-
+-
+-UINT CSoundFile::GetCurrentPos() const
+-//------------------------------------
+-{
+- UINT pos = 0;
+-
+- for (UINT i=0; i<m_nCurrentPattern; i++) if (Order[i] < MAX_PATTERNS)
+- pos += PatternSize[Order[i]];
+- return pos + m_nRow;
+-}
+-
+-
+-void CSoundFile::SetCurrentPos(UINT nPos)
+-//---------------------------------------
+-{
+- UINT i, nPattern;
+-
+- for (i=0; i<MAX_CHANNELS; i++)
+- {
+- Chn[i].nNote = Chn[i].nNewNote = Chn[i].nNewIns = 0;
+- Chn[i].pInstrument = NULL;
+- Chn[i].pHeader = NULL;
+- Chn[i].nPortamentoDest = 0;
+- Chn[i].nCommand = 0;
+- Chn[i].nPatternLoopCount = 0;
+- Chn[i].nPatternLoop = 0;
+- Chn[i].nFadeOutVol = 0;
+- Chn[i].dwFlags |= CHN_KEYOFF|CHN_NOTEFADE;
+- Chn[i].nTremorCount = 0;
+- }
+- if (!nPos)
+- {
+- for (i=0; i<MAX_CHANNELS; i++)
+- {
+- Chn[i].nPeriod = 0;
+- Chn[i].nPos = Chn[i].nLength = 0;
+- Chn[i].nLoopStart = 0;
+- Chn[i].nLoopEnd = 0;
+- Chn[i].nROfs = Chn[i].nLOfs = 0;
+- Chn[i].pSample = NULL;
+- Chn[i].pInstrument = NULL;
+- Chn[i].pHeader = NULL;
+- Chn[i].nCutOff = 0x7F;
+- Chn[i].nResonance = 0;
+- Chn[i].nLeftVol = Chn[i].nRightVol = 0;
+- Chn[i].nNewLeftVol = Chn[i].nNewRightVol = 0;
+- Chn[i].nLeftRamp = Chn[i].nRightRamp = 0;
+- Chn[i].nVolume = 256;
+- if (i < MAX_BASECHANNELS)
+- {
+- Chn[i].dwFlags = ChnSettings[i].dwFlags;
+- Chn[i].nPan = ChnSettings[i].nPan;
+- Chn[i].nGlobalVol = ChnSettings[i].nVolume;
+- } else
+- {
+- Chn[i].dwFlags = 0;
+- Chn[i].nPan = 128;
+- Chn[i].nGlobalVol = 64;
+- }
+- }
+- m_nGlobalVolume = m_nDefaultGlobalVolume;
+- m_nMusicSpeed = m_nDefaultSpeed;
+- m_nMusicTempo = m_nDefaultTempo;
+- }
+- m_dwSongFlags &= ~(SONG_PATTERNLOOP|SONG_CPUVERYHIGH|SONG_FADINGSONG|SONG_ENDREACHED|SONG_GLOBALFADE);
+- for (nPattern = 0; nPattern < MAX_ORDERS; nPattern++)
+- {
+- UINT ord = Order[nPattern];
+- if (ord == 0xFE) continue;
+- if (ord == 0xFF) break;
+- if (ord < MAX_PATTERNS)
+- {
+- if (nPos < (UINT)PatternSize[ord]) break;
+- nPos -= PatternSize[ord];
+- }
+- }
+- // Buggy position ?
+- if ((nPattern >= MAX_ORDERS)
+- || (Order[nPattern] >= MAX_PATTERNS)
+- || (nPos >= PatternSize[Order[nPattern]]))
+- {
+- nPos = 0;
+- nPattern = 0;
+- }
+- UINT nRow = nPos;
+- if ((nRow) && (Order[nPattern] < MAX_PATTERNS))
+- {
+- MODCOMMAND *p = Patterns[Order[nPattern]];
+- if ((p) && (nRow < PatternSize[Order[nPattern]]))
+- {
+- BOOL bOk = FALSE;
+- while ((!bOk) && (nRow > 0))
+- {
+- UINT n = nRow * m_nChannels;
+- for (UINT k=0; k<m_nChannels; k++, n++)
+- {
+- if (p[n].note)
+- {
+- bOk = TRUE;
+- break;
+- }
+- }
+- if (!bOk) nRow--;
+- }
+- }
+- }
+- m_nNextPattern = nPattern;
+- m_nNextRow = nRow;
+- m_nTickCount = m_nMusicSpeed;
+- m_nBufferCount = 0;
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+-}
+-
+-
+-void CSoundFile::SetCurrentOrder(UINT nPos)
+-//-----------------------------------------
+-{
+- while ((nPos < MAX_ORDERS) && (Order[nPos] == 0xFE)) nPos++;
+- if ((nPos >= MAX_ORDERS) || (Order[nPos] >= MAX_PATTERNS)) return;
+- for (UINT j=0; j<MAX_CHANNELS; j++)
+- {
+- Chn[j].nPeriod = 0;
+- Chn[j].nNote = 0;
+- Chn[j].nPortamentoDest = 0;
+- Chn[j].nCommand = 0;
+- Chn[j].nPatternLoopCount = 0;
+- Chn[j].nPatternLoop = 0;
+- Chn[j].nTremorCount = 0;
+- }
+- if (!nPos)
+- {
+- SetCurrentPos(0);
+- } else
+- {
+- m_nNextPattern = nPos;
+- m_nRow = m_nNextRow = 0;
+- m_nPattern = 0;
+- m_nTickCount = m_nMusicSpeed;
+- m_nBufferCount = 0;
+- m_nTotalCount = 0;
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+- }
+- m_dwSongFlags &= ~(SONG_PATTERNLOOP|SONG_CPUVERYHIGH|SONG_FADINGSONG|SONG_ENDREACHED|SONG_GLOBALFADE);
+-}
+-
+-void CSoundFile::ResetChannels()
+-//------------------------------
+-{
+- m_dwSongFlags &= ~(SONG_CPUVERYHIGH|SONG_FADINGSONG|SONG_ENDREACHED|SONG_GLOBALFADE);
+- m_nBufferCount = 0;
+- for (UINT i=0; i<MAX_CHANNELS; i++)
+- {
+- Chn[i].nROfs = Chn[i].nLOfs = 0;
+- }
+-}
+-
+-
+-void CSoundFile::ResetTimestamps()
+-//--------------------------------
+-{
+- int n;
+-
+- for (n = 1; n < MAX_SAMPLES; n++) {
+- Ins[n].played = 0;
+- }
+- for (n = 1; n < MAX_INSTRUMENTS; n++) {
+- if (Headers[n])
+- Headers[n]->played = 0;
+- }
+-}
+-
+-
+-void CSoundFile::LoopPattern(int nPat, int nRow)
+-//----------------------------------------------
+-{
+- if ((nPat < 0) || (nPat >= MAX_PATTERNS) || (!Patterns[nPat]))
+- {
+- m_dwSongFlags &= ~SONG_PATTERNLOOP;
+- } else
+- {
+- if ((nRow < 0) || (nRow >= PatternSize[nPat])) nRow = 0;
+- m_nPattern = nPat;
+- m_nRow = m_nNextRow = nRow;
+- m_nTickCount = m_nMusicSpeed;
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+- m_nBufferCount = 0;
+- m_dwSongFlags |= SONG_PATTERNLOOP;
+- }
+-}
+-
+-
+-UINT CSoundFile::GetBestSaveFormat() const
+-//----------------------------------------
+-{
+- if ((!m_nSamples) || (!m_nChannels)) return MOD_TYPE_NONE;
+- if (!m_nType) return MOD_TYPE_NONE;
+- if (m_nType & (MOD_TYPE_MOD|MOD_TYPE_OKT))
+- return MOD_TYPE_MOD;
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_STM|MOD_TYPE_ULT|MOD_TYPE_FAR|MOD_TYPE_PTM))
+- return MOD_TYPE_S3M;
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MED|MOD_TYPE_MTM|MOD_TYPE_MT2))
+- return MOD_TYPE_XM;
+- return MOD_TYPE_IT;
+-}
+-
+-
+-UINT CSoundFile::GetSaveFormats() const
+-//-------------------------------------
+-{
+- UINT n = 0;
+- if ((!m_nSamples) || (!m_nChannels) || (m_nType == MOD_TYPE_NONE)) return 0;
+- switch(m_nType)
+- {
+- case MOD_TYPE_MOD: n = MOD_TYPE_MOD;
+- case MOD_TYPE_S3M: n = MOD_TYPE_S3M;
+- }
+- n |= MOD_TYPE_XM | MOD_TYPE_IT;
+- if (!(m_dwSongFlags & SONG_INSTRUMENTMODE))
+- {
+- if (m_nSamples < 32) n |= MOD_TYPE_MOD;
+- n |= MOD_TYPE_S3M;
+- }
+- return n;
+-}
+-
+-
+-UINT CSoundFile::GetSampleName(UINT nSample,LPSTR s) const
+-//--------------------------------------------------------
+-{
+- char sztmp[40] = ""; // changed from CHAR
+- memcpy(sztmp, m_szNames[nSample],32);
+- sztmp[31] = 0;
+- if (s) strcpy(s, sztmp);
+- return strlen(sztmp);
+-}
+-
+-
+-UINT CSoundFile::GetInstrumentName(UINT nInstr,LPSTR s) const
+-//-----------------------------------------------------------
+-{
+- char sztmp[40] = ""; // changed from CHAR
+- if ((nInstr >= MAX_INSTRUMENTS) || (!Headers[nInstr]))
+- {
+- if (s) *s = 0;
+- return 0;
+- }
+- INSTRUMENTHEADER *penv = Headers[nInstr];
+- memcpy(sztmp, penv->name, 32);
+- sztmp[31] = 0;
+- if (s) strcpy(s, sztmp);
+- return strlen(sztmp);
+-}
+-
+-
+-#ifndef NO_PACKING
+-UINT CSoundFile::PackSample(int &sample, int next)
+-//------------------------------------------------
+-{
+- UINT i = 0;
+- int delta = next - sample;
+- if (delta >= 0)
+- {
+- for (i=0; i<7; i++) if (delta <= (int)CompressionTable[i+1]) break;
+- } else
+- {
+- for (i=8; i<15; i++) if (delta >= (int)CompressionTable[i+1]) break;
+- }
+- sample += (int)CompressionTable[i];
+- return i;
+-}
+-
+-
+-BOOL CSoundFile::CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result)
+-//-----------------------------------------------------------------------------------
+-{
+- int pos, old, oldpos, besttable = 0;
+- DWORD dwErr, dwTotal, dwResult;
+- int i,j;
+-
+- if (result) *result = 0;
+- if ((!pSample) || (nLen < 1024)) return FALSE;
+- // Try packing with different tables
+- dwResult = 0;
+- for (j=1; j<MAX_PACK_TABLES; j++)
+- {
+- memcpy(CompressionTable, UnpackTable[j], 16);
+- dwErr = 0;
+- dwTotal = 1;
+- old = pos = oldpos = 0;
+- for (i=0; i<(int)nLen; i++)
+- {
+- int s = (int)pSample[i];
+- PackSample(pos, s);
+- dwErr += abs(pos - oldpos);
+- dwTotal += abs(s - old);
+- old = s;
+- oldpos = pos;
+- }
+- dwErr = _muldiv(dwErr, 100, dwTotal);
+- if (dwErr >= dwResult)
+- {
+- dwResult = dwErr;
+- besttable = j;
+- }
+- }
+- memcpy(CompressionTable, UnpackTable[besttable], 16);
+- if (result)
+- {
+- if (dwResult > 100) *result = 100; else *result = (BYTE)dwResult;
+- }
+- return (dwResult >= nPacking) ? TRUE : FALSE;
+-}
+-#endif // NO_PACKING
+-
+-
+-
+-// Flags:
+-// 0 = signed 8-bit PCM data (default)
+-// 1 = unsigned 8-bit PCM data
+-// 2 = 8-bit ADPCM data with linear table
+-// 3 = 4-bit ADPCM data
+-// 4 = 16-bit ADPCM data with linear table
+-// 5 = signed 16-bit PCM data
+-// 6 = unsigned 16-bit PCM data
+-
+-
+-UINT CSoundFile::ReadSample(MODINSTRUMENT *pIns, UINT nFlags, LPCSTR lpMemFile, DWORD dwMemLength)
+-//------------------------------------------------------------------------------------------------
+-{
+- UINT len = 0, mem = pIns->nLength+6;
+-
+- if ((!pIns) || (pIns->nLength < 1) || (!lpMemFile)) return 0;
+- if (pIns->nLength > MAX_SAMPLE_LENGTH) pIns->nLength = MAX_SAMPLE_LENGTH;
+- pIns->uFlags &= ~(CHN_16BIT|CHN_STEREO);
+- if (nFlags & RSF_16BIT)
+- {
+- mem *= 2;
+- pIns->uFlags |= CHN_16BIT;
+- }
+- if (nFlags & RSF_STEREO)
+- {
+- mem *= 2;
+- pIns->uFlags |= CHN_STEREO;
+- }
+- if ((pIns->pSample = AllocateSample(mem)) == NULL)
+- {
+- pIns->nLength = 0;
+- return 0;
+- }
+- switch(nFlags)
+- {
+- // 1: 8-bit unsigned PCM data
+- case RS_PCM8U:
+- {
+- len = pIns->nLength;
+- if (len > dwMemLength) len = pIns->nLength = dwMemLength;
+- signed char *pSample = pIns->pSample;
+- for (UINT j=0; j<len; j++) pSample[j] = (signed char)(lpMemFile[j] - 0x80);
+- }
+- break;
+-
+- // 2: 8-bit ADPCM data with linear table
+- case RS_PCM8D:
+- {
+- len = pIns->nLength;
+- if (len > dwMemLength) break;
+- signed char *pSample = pIns->pSample;
+- const signed char *p = (const signed char *)lpMemFile;
+- int delta = 0;
+-
+- for (UINT j=0; j<len; j++)
+- {
+- delta += p[j];
+- *pSample++ = (signed char)delta;
+- }
+- }
+- break;
+-
+- // 3: 4-bit ADPCM data
+- case RS_ADPCM4:
+- {
+- len = (pIns->nLength + 1) / 2;
+- if (len > dwMemLength - 16) break;
+- memcpy(CompressionTable, lpMemFile, 16);
+- lpMemFile += 16;
+- signed char *pSample = pIns->pSample;
+- signed char delta = 0;
+- for (UINT j=0; j<len; j++)
+- {
+- BYTE b0 = (BYTE)lpMemFile[j];
+- BYTE b1 = (BYTE)(lpMemFile[j] >> 4);
+- delta = (signed char)GetDeltaValue((int)delta, b0);
+- pSample[0] = delta;
+- delta = (signed char)GetDeltaValue((int)delta, b1);
+- pSample[1] = delta;
+- pSample += 2;
+- }
+- len += 16;
+- }
+- break;
+-
+- // 4: 16-bit ADPCM data with linear table
+- case RS_PCM16D:
+- {
+- len = pIns->nLength * 2;
+- if (len > dwMemLength) break;
+- short *pSample = (short *)pIns->pSample;
+- short *p = (short *)lpMemFile;
+- unsigned short tmp;
+- int delta16 = 0;
+- for (UINT j=0; j<len; j+=2)
+- {
+- tmp = *((unsigned short *)p++);
+- delta16 += bswapLE16(tmp);
+- *pSample++ = (short) delta16;
+- }
+- }
+- break;
+-
+- // 5: 16-bit signed PCM data
+- case RS_PCM16S:
+- {
+- len = pIns->nLength * 2;
+- if (len <= dwMemLength) memcpy(pIns->pSample, lpMemFile, len);
+- short int *pSample = (short int *)pIns->pSample;
+- for (UINT j=0; j<len; j+=2)
+- {
+- *pSample = bswapLE16(*pSample);
+- pSample++;
+- }
+- }
+- break;
+-
+- // 16-bit signed mono PCM motorola byte order
+- case RS_PCM16M:
+- len = pIns->nLength * 2;
+- if (len > dwMemLength) len = dwMemLength & ~1;
+- if (len > 1)
+- {
+- signed char *pSample = (signed char *)pIns->pSample;
+- signed char *pSrc = (signed char *)lpMemFile;
+- for (UINT j=0; j<len; j+=2)
+- {
+- // pSample[j] = pSrc[j+1];
+- // pSample[j+1] = pSrc[j];
+- *((unsigned short *)(pSample+j)) = bswapBE16(*((unsigned short *)(pSrc+j)));
+- }
+- }
+- break;
+-
+- // 6: 16-bit unsigned PCM data
+- case RS_PCM16U:
+- {
+- len = pIns->nLength * 2;
+- if (len <= dwMemLength) memcpy(pIns->pSample, lpMemFile, len);
+- short int *pSample = (short int *)pIns->pSample;
+- for (UINT j=0; j<len; j+=2)
+- {
+- *pSample = bswapLE16(*pSample) - 0x8000;
+- pSample++;
+- }
+- }
+- break;
+-
+- // 16-bit signed stereo big endian
+- case RS_STPCM16M:
+- len = pIns->nLength * 2;
+- if (len*2 <= dwMemLength)
+- {
+- signed char *pSample = (signed char *)pIns->pSample;
+- signed char *pSrc = (signed char *)lpMemFile;
+- for (UINT j=0; j<len; j+=2)
+- {
+- // pSample[j*2] = pSrc[j+1];
+- // pSample[j*2+1] = pSrc[j];
+- // pSample[j*2+2] = pSrc[j+1+len];
+- // pSample[j*2+3] = pSrc[j+len];
+- *((unsigned short *)(pSample+j*2)) = bswapBE16(*((unsigned short *)(pSrc+j)));
+- *((unsigned short *)(pSample+j*2+2)) = bswapBE16(*((unsigned short *)(pSrc+j+len)));
+- }
+- len *= 2;
+- }
+- break;
+-
+- // 8-bit stereo samples
+- case RS_STPCM8S:
+- case RS_STPCM8U:
+- case RS_STPCM8D:
+- {
+- int iadd_l = 0, iadd_r = 0;
+- if (nFlags == RS_STPCM8U) { iadd_l = iadd_r = -128; }
+- len = pIns->nLength;
+- signed char *psrc = (signed char *)lpMemFile;
+- signed char *pSample = (signed char *)pIns->pSample;
+- if (len*2 > dwMemLength) break;
+- for (UINT j=0; j<len; j++)
+- {
+- pSample[j*2] = (signed char)(psrc[0] + iadd_l);
+- pSample[j*2+1] = (signed char)(psrc[len] + iadd_r);
+- psrc++;
+- if (nFlags == RS_STPCM8D)
+- {
+- iadd_l = pSample[j*2];
+- iadd_r = pSample[j*2+1];
+- }
+- }
+- len *= 2;
+- }
+- break;
+-
+- // 16-bit stereo samples
+- case RS_STPCM16S:
+- case RS_STPCM16U:
+- case RS_STPCM16D:
+- {
+- int iadd_l = 0, iadd_r = 0;
+- if (nFlags == RS_STPCM16U) { iadd_l = iadd_r = -0x8000; }
+- len = pIns->nLength;
+- short int *psrc = (short int *)lpMemFile;
+- short int *pSample = (short int *)pIns->pSample;
+- if (len*4 > dwMemLength) break;
+- for (UINT j=0; j<len; j++)
+- {
+- pSample[j*2] = (short int) (bswapLE16(psrc[0]) + iadd_l);
+- pSample[j*2+1] = (short int) (bswapLE16(psrc[len]) + iadd_r);
+- psrc++;
+- if (nFlags == RS_STPCM16D)
+- {
+- iadd_l = pSample[j*2];
+- iadd_r = pSample[j*2+1];
+- }
+- }
+- len *= 4;
+- }
+- break;
+-
+- // IT 2.14 compressed samples
+- case RS_IT2148:
+- case RS_IT21416:
+- case RS_IT2158:
+- case RS_IT21516:
+- len = dwMemLength;
+- if (len < 2) break;
+- if ((nFlags == RS_IT2148) || (nFlags == RS_IT2158))
+- ITUnpack8Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, (nFlags == RS_IT2158));
+- else
+- ITUnpack16Bit(pIns->pSample, pIns->nLength, (LPBYTE)lpMemFile, dwMemLength, (nFlags == RS_IT21516));
+- break;
+-
+-#ifndef MODPLUG_FASTSOUNDLIB
+- // 8-bit interleaved stereo samples
+- case RS_STIPCM8S:
+- case RS_STIPCM8U:
+- {
+- int iadd = 0;
+- if (nFlags == RS_STIPCM8U) { iadd = -0x80; }
+- len = pIns->nLength;
+- if (len*2 > dwMemLength) len = dwMemLength >> 1;
+- LPBYTE psrc = (LPBYTE)lpMemFile;
+- LPBYTE pSample = (LPBYTE)pIns->pSample;
+- for (UINT j=0; j<len; j++)
+- {
+- pSample[j*2] = (signed char)(psrc[0] + iadd);
+- pSample[j*2+1] = (signed char)(psrc[1] + iadd);
+- psrc+=2;
+- }
+- len *= 2;
+- }
+- break;
+-
+- // 16-bit interleaved stereo samples
+- case RS_STIPCM16S:
+- case RS_STIPCM16U:
+- {
+- int iadd = 0;
+- if (nFlags == RS_STIPCM16U) iadd = -32768;
+- len = pIns->nLength;
+- if (len*4 > dwMemLength) len = dwMemLength >> 2;
+- short int *psrc = (short int *)lpMemFile;
+- short int *pSample = (short int *)pIns->pSample;
+- for (UINT j=0; j<len; j++)
+- {
+- pSample[j*2] = (short int)(bswapLE16(psrc[0]) + iadd);
+- pSample[j*2+1] = (short int)(bswapLE16(psrc[1]) + iadd);
+- psrc += 2;
+- }
+- len *= 4;
+- }
+- break;
+-
+- // AMS compressed samples
+- case RS_AMS8:
+- case RS_AMS16:
+- len = 9;
+- if (dwMemLength > 9)
+- {
+- const char *psrc = lpMemFile;
+- char packcharacter = lpMemFile[8], *pdest = (char *)pIns->pSample;
+- len += bswapLE32(*((LPDWORD)(lpMemFile+4)));
+- if (len > dwMemLength) len = dwMemLength;
+- UINT dmax = pIns->nLength;
+- if (pIns->uFlags & CHN_16BIT) dmax <<= 1;
+- AMSUnpack(psrc+9, len-9, pdest, dmax, packcharacter);
+- }
+- break;
+-
+- // PTM 8bit delta to 16-bit sample
+- case RS_PTM8DTO16:
+- {
+- len = pIns->nLength * 2;
+- if (len > dwMemLength) break;
+- signed char *pSample = (signed char *)pIns->pSample;
+- signed char delta8 = 0;
+- for (UINT j=0; j<len; j++)
+- {
+- delta8 += lpMemFile[j];
+- *pSample++ = delta8;
+- }
+- WORD *pSampleW = (WORD *)pIns->pSample;
+- for (UINT j=0; j<len; j+=2) // swaparoni!
+- {
+- *pSampleW = bswapLE16(*pSampleW);
+- pSampleW++;
+- }
+- }
+- break;
+-
+- // Huffman MDL compressed samples
+- case RS_MDL8:
+- case RS_MDL16:
+- len = dwMemLength;
+- if (len >= 4)
+- {
+- LPBYTE pSample = (LPBYTE)pIns->pSample;
+- LPBYTE ibuf = (LPBYTE)lpMemFile;
+- DWORD bitbuf = bswapLE32(*((DWORD *)ibuf));
+- UINT bitnum = 32;
+- BYTE dlt = 0, lowbyte = 0;
+- ibuf += 4;
+- for (UINT j=0; j<pIns->nLength; j++)
+- {
+- BYTE hibyte;
+- BYTE sign;
+- if (nFlags == RS_MDL16) lowbyte = (BYTE)MDLReadBits(bitbuf, bitnum, ibuf, 8);
+- sign = (BYTE)MDLReadBits(bitbuf, bitnum, ibuf, 1);
+- if (MDLReadBits(bitbuf, bitnum, ibuf, 1))
+- {
+- hibyte = (BYTE)MDLReadBits(bitbuf, bitnum, ibuf, 3);
+- } else
+- {
+- hibyte = 8;
+- while (!MDLReadBits(bitbuf, bitnum, ibuf, 1)) hibyte += 0x10;
+- hibyte += MDLReadBits(bitbuf, bitnum, ibuf, 4);
+- }
+- if (sign) hibyte = ~hibyte;
+- dlt += hibyte;
+- if (nFlags != RS_MDL16)
+- pSample[j] = dlt;
+- else
+- {
+- pSample[j<<1] = lowbyte;
+- pSample[(j<<1)+1] = dlt;
+- }
+- }
+- }
+- break;
+-
+- case RS_DMF8:
+- case RS_DMF16:
+- len = dwMemLength;
+- if (len >= 4)
+- {
+- UINT maxlen = pIns->nLength;
+- if (pIns->uFlags & CHN_16BIT) maxlen <<= 1;
+- LPBYTE ibuf = (LPBYTE)lpMemFile, ibufmax = (LPBYTE)(lpMemFile+dwMemLength);
+- len = DMFUnpack((LPBYTE)pIns->pSample, ibuf, ibufmax, maxlen);
+- }
+- break;
+-
+-#ifdef MODPLUG_TRACKER
+- // PCM 24-bit signed -> load sample, and normalize it to 16-bit
+- case RS_PCM24S:
+- case RS_PCM32S:
+- len = pIns->nLength * 3;
+- if (nFlags == RS_PCM32S) len += pIns->nLength;
+- if (len > dwMemLength) break;
+- if (len > 4*8)
+- {
+- UINT slsize = (nFlags == RS_PCM32S) ? 4 : 3;
+- LPBYTE pSrc = (LPBYTE)lpMemFile;
+- LONG max = 255;
+- if (nFlags == RS_PCM32S) pSrc++;
+- for (UINT j=0; j<len; j+=slsize)
+- {
+- LONG l = ((((pSrc[j+2] << 8) + pSrc[j+1]) << 8) + pSrc[j]) << 8;
+- l /= 256;
+- if (l > max) max = l;
+- if (-l > max) max = -l;
+- }
+- max = (max / 128) + 1;
+- signed short *pDest = (signed short *)pIns->pSample;
+- for (UINT k=0; k<len; k+=slsize)
+- {
+- LONG l = ((((pSrc[k+2] << 8) + pSrc[k+1]) << 8) + pSrc[k]) << 8;
+- *pDest++ = (signed short)(l / max);
+- }
+- }
+- break;
+-
+- // Stereo PCM 24-bit signed -> load sample, and normalize it to 16-bit
+- case RS_STIPCM24S:
+- case RS_STIPCM32S:
+- len = pIns->nLength * 6;
+- if (nFlags == RS_STIPCM32S) len += pIns->nLength * 2;
+- if (len > dwMemLength) break;
+- if (len > 8*8)
+- {
+- UINT slsize = (nFlags == RS_STIPCM32S) ? 4 : 3;
+- LPBYTE pSrc = (LPBYTE)lpMemFile;
+- LONG max = 255;
+- if (nFlags == RS_STIPCM32S) pSrc++;
+- for (UINT j=0; j<len; j+=slsize)
+- {
+- LONG l = ((((pSrc[j+2] << 8) + pSrc[j+1]) << 8) + pSrc[j]) << 8;
+- l /= 256;
+- if (l > max) max = l;
+- if (-l > max) max = -l;
+- }
+- max = (max / 128) + 1;
+- signed short *pDest = (signed short *)pIns->pSample;
+- for (UINT k=0; k<len; k+=slsize)
+- {
+- LONG lr = ((((pSrc[k+2] << 8) + pSrc[k+1]) << 8) + pSrc[k]) << 8;
+- k += slsize;
+- LONG ll = ((((pSrc[k+2] << 8) + pSrc[k+1]) << 8) + pSrc[k]) << 8;
+- pDest[0] = (signed short)ll;
+- pDest[1] = (signed short)lr;
+- pDest += 2;
+- }
+- }
+- break;
+-
+- // 16-bit signed big endian interleaved stereo
+- case RS_STIPCM16M:
+- {
+- len = pIns->nLength;
+- if (len*4 > dwMemLength) len = dwMemLength >> 2;
+- LPCBYTE psrc = (LPCBYTE)lpMemFile;
+- short int *pSample = (short int *)pIns->pSample;
+- for (UINT j=0; j<len; j++)
+- {
+- pSample[j*2] = (signed short)(((UINT)psrc[0] << 8) | (psrc[1]));
+- pSample[j*2+1] = (signed short)(((UINT)psrc[2] << 8) | (psrc[3]));
+- psrc += 4;
+- }
+- len *= 4;
+- }
+- break;
+-
+-#endif // MODPLUG_TRACKER
+-#endif // !MODPLUG_FASTSOUNDLIB
+-
+- // Default: 8-bit signed PCM data
+- default:
+- len = pIns->nLength;
+- if (len > dwMemLength) len = pIns->nLength = dwMemLength;
+- memcpy(pIns->pSample, lpMemFile, len);
+- }
+- if (len > dwMemLength)
+- {
+- if (pIns->pSample)
+- {
+- pIns->nLength = 0;
+- FreeSample(pIns->pSample);
+- pIns->pSample = NULL;
+- }
+- return 0;
+- }
+- AdjustSampleLoop(pIns);
+- return len;
+-}
+-
+-
+-void CSoundFile::AdjustSampleLoop(MODINSTRUMENT *pIns)
+-//----------------------------------------------------
+-{
+- if (!pIns->pSample) return;
+- if (pIns->nLoopEnd > pIns->nLength) pIns->nLoopEnd = pIns->nLength;
+- if (pIns->nLoopStart+2 >= pIns->nLoopEnd)
+- {
+- pIns->nLoopStart = pIns->nLoopEnd = 0;
+- pIns->uFlags &= ~CHN_LOOP;
+- }
+- UINT len = pIns->nLength;
+- if (pIns->uFlags & CHN_16BIT)
+- {
+- short int *pSample = (short int *)pIns->pSample;
+- // Adjust end of sample
+- if (pIns->uFlags & CHN_STEREO)
+- {
+- pSample[len*2+6] = pSample[len*2+4] = pSample[len*2+2] = pSample[len*2] = pSample[len*2-2];
+- pSample[len*2+7] = pSample[len*2+5] = pSample[len*2+3] = pSample[len*2+1] = pSample[len*2-1];
+- } else
+- {
+- pSample[len+4] = pSample[len+3] = pSample[len+2] = pSample[len+1] = pSample[len] = pSample[len-1];
+- }
+- if ((pIns->uFlags & (CHN_LOOP|CHN_PINGPONGLOOP|CHN_STEREO)) == CHN_LOOP)
+- {
+- // Fix bad loops
+- if ((pIns->nLoopEnd+3 >= pIns->nLength) || (m_nType & MOD_TYPE_S3M))
+- {
+- pSample[pIns->nLoopEnd] = pSample[pIns->nLoopStart];
+- pSample[pIns->nLoopEnd+1] = pSample[pIns->nLoopStart+1];
+- pSample[pIns->nLoopEnd+2] = pSample[pIns->nLoopStart+2];
+- pSample[pIns->nLoopEnd+3] = pSample[pIns->nLoopStart+3];
+- pSample[pIns->nLoopEnd+4] = pSample[pIns->nLoopStart+4];
+- }
+- }
+- } else
+- {
+- signed char *pSample = pIns->pSample;
+-#ifndef MODPLUG_FASTSOUNDLIB
+- // Crappy samples (except chiptunes) ?
+- if ((pIns->nLength > 0x100) && (m_nType & (MOD_TYPE_MOD|MOD_TYPE_S3M))
+- && (!(pIns->uFlags & CHN_STEREO)))
+- {
+- int smpend = pSample[pIns->nLength-1], smpfix = 0, kscan;
+- for (kscan=pIns->nLength-1; kscan>0; kscan--)
+- {
+- smpfix = pSample[kscan-1];
+- if (smpfix != smpend) break;
+- }
+- int delta = smpfix - smpend;
+- if (((!(pIns->uFlags & CHN_LOOP)) || (kscan > (int)pIns->nLoopEnd))
+- && ((delta < -8) || (delta > 8)))
+- {
+- while (kscan<(int)pIns->nLength)
+- {
+- if (!(kscan & 7))
+- {
+- if (smpfix > 0) smpfix--;
+- if (smpfix < 0) smpfix++;
+- }
+- pSample[kscan] = (signed char)smpfix;
+- kscan++;
+- }
+- }
+- }
+-#endif
+- // Adjust end of sample
+- if (pIns->uFlags & CHN_STEREO)
+- {
+- pSample[len*2+6] = pSample[len*2+4] = pSample[len*2+2] = pSample[len*2] = pSample[len*2-2];
+- pSample[len*2+7] = pSample[len*2+5] = pSample[len*2+3] = pSample[len*2+1] = pSample[len*2-1];
+- } else
+- {
+- pSample[len+4] = pSample[len+3] = pSample[len+2] = pSample[len+1] = pSample[len] = pSample[len-1];
+- }
+- if ((pIns->uFlags & (CHN_LOOP|CHN_PINGPONGLOOP|CHN_STEREO)) == CHN_LOOP)
+- {
+- if ((pIns->nLoopEnd+3 >= pIns->nLength) || (m_nType & (MOD_TYPE_MOD|MOD_TYPE_S3M)))
+- {
+- pSample[pIns->nLoopEnd] = pSample[pIns->nLoopStart];
+- pSample[pIns->nLoopEnd+1] = pSample[pIns->nLoopStart+1];
+- pSample[pIns->nLoopEnd+2] = pSample[pIns->nLoopStart+2];
+- pSample[pIns->nLoopEnd+3] = pSample[pIns->nLoopStart+3];
+- pSample[pIns->nLoopEnd+4] = pSample[pIns->nLoopStart+4];
+- }
+- }
+- }
+-}
+-
+-
+-/////////////////////////////////////////////////////////////
+-// Transpose <-> Frequency conversions
+-
+-// returns 8363*2^((transp*128+ftune)/(12*128))
+-DWORD CSoundFile::TransposeToFrequency(int transp, int ftune)
+-//-----------------------------------------------------------
+-{
+- //---GCCFIX: Removed assembly.
+-#ifdef MSC_VER
+- const float _fbase = 8363;
+- const float _factor = 1.0f/(12.0f*128.0f);
+- int result;
+- DWORD freq;
+-
+- transp = (transp << 7) + ftune;
+- _asm {
+- fild transp
+- fld _factor
+- fmulp st(1), st(0)
+- fist result
+- fisub result
+- f2xm1
+- fild result
+- fld _fbase
+- fscale
+- fstp st(1)
+- fmul st(1), st(0)
+- faddp st(1), st(0)
+- fistp freq
+- }
+- UINT derr = freq % 11025;
+- if (derr <= 8) freq -= derr;
+- if (derr >= 11015) freq += 11025-derr;
+- derr = freq % 1000;
+- if (derr <= 5) freq -= derr;
+- if (derr >= 995) freq += 1000-derr;
+- return freq;
+-#else
+- return (DWORD) (8363.0 * pow(2, (transp * 128.0 + ftune) / 1536.0));
+-#endif
+-}
+-
+-
+-// returns 12*128*log2(freq/8363)
+-int CSoundFile::FrequencyToTranspose(DWORD freq)
+-//----------------------------------------------
+-{
+- //---GCCFIX: Removed assembly.
+-#ifdef MSC_VER
+- const float _f1_8363 = 1.0f / 8363.0f;
+- const float _factor = 128 * 12;
+- LONG result;
+-
+- if (!freq) return 0;
+- _asm {
+- fld _factor
+- fild freq
+- fld _f1_8363
+- fmulp st(1), st(0)
+- fyl2x
+- fistp result
+- }
+- return result;
+-#else
+- return (int) (1536.0 * (log(freq / 8363.0) / log(2)));
+-#endif
+-}
+-
+-
+-void CSoundFile::FrequencyToTranspose(MODINSTRUMENT *psmp)
+-//--------------------------------------------------------
+-{
+- int f2t = FrequencyToTranspose(psmp->nC4Speed);
+- int transp = f2t >> 7;
+- int ftune = f2t & 0x7F;
+- if (ftune > 80)
+- {
+- transp++;
+- ftune -= 128;
+- }
+- if (transp > 127) transp = 127;
+- if (transp < -127) transp = -127;
+- psmp->RelativeTone = transp;
+- psmp->nFineTune = ftune;
+-}
+-
+-
+-void CSoundFile::CheckCPUUsage(UINT nCPU)
+-//---------------------------------------
+-{
+- if (nCPU > 100) nCPU = 100;
+- gnCPUUsage = nCPU;
+- if (nCPU < 90)
+- {
+- m_dwSongFlags &= ~SONG_CPUVERYHIGH;
+- } else
+- if ((m_dwSongFlags & SONG_CPUVERYHIGH) && (nCPU >= 94))
+- {
+- UINT i=MAX_CHANNELS;
+- while (i >= 8)
+- {
+- i--;
+- if (Chn[i].nLength)
+- {
+- Chn[i].nLength = Chn[i].nPos = 0;
+- nCPU -= 2;
+- if (nCPU < 94) break;
+- }
+- }
+- } else
+- if (nCPU > 90)
+- {
+- m_dwSongFlags |= SONG_CPUVERYHIGH;
+- }
+-}
+-
+-
+-BOOL CSoundFile::SetPatternName(UINT nPat, LPCSTR lpszName)
+-//---------------------------------------------------------
+-{
+- char szName[MAX_PATTERNNAME] = ""; // changed from CHAR
+- if (nPat >= MAX_PATTERNS) return FALSE;
+- if (lpszName) lstrcpyn(szName, lpszName, MAX_PATTERNNAME);
+- szName[MAX_PATTERNNAME-1] = 0;
+- if (!m_lpszPatternNames) m_nPatternNames = 0;
+- if (nPat >= m_nPatternNames)
+- {
+- if (!lpszName[0]) return TRUE;
+- UINT len = (nPat+1)*MAX_PATTERNNAME;
+- char *p = new char[len]; // changed from CHAR
+- if (!p) return FALSE;
+- memset(p, 0, len);
+- if (m_lpszPatternNames)
+- {
+- memcpy(p, m_lpszPatternNames, m_nPatternNames * MAX_PATTERNNAME);
+- delete m_lpszPatternNames;
+- m_lpszPatternNames = NULL;
+- }
+- m_lpszPatternNames = p;
+- m_nPatternNames = nPat + 1;
+- }
+- memcpy(m_lpszPatternNames + nPat * MAX_PATTERNNAME, szName, MAX_PATTERNNAME);
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::GetPatternName(UINT nPat, LPSTR lpszName, UINT cbSize) const
+-//---------------------------------------------------------------------------
+-{
+- if ((!lpszName) || (!cbSize)) return FALSE;
+- lpszName[0] = 0;
+- if (cbSize > MAX_PATTERNNAME) cbSize = MAX_PATTERNNAME;
+- if ((m_lpszPatternNames) && (nPat < m_nPatternNames))
+- {
+- memcpy(lpszName, m_lpszPatternNames + nPat * MAX_PATTERNNAME, cbSize);
+- lpszName[cbSize-1] = 0;
+- return TRUE;
+- }
+- return FALSE;
+-}
+-
+-UINT CSoundFile::GetHighestUsedChannel()
+-//------------------------------
+-{
+- UINT highchan = 0;
+-
+- for (UINT ipat=0; ipat<MAX_PATTERNS; ipat++)
+- {
+- MODCOMMAND *p = Patterns[ipat];
+- if (p)
+- {
+- UINT jmax = PatternSize[ipat] * m_nChannels;
+- for (UINT j=0; j<jmax; j++, p++)
+- {
+- if ((p->note) && (p->note <= 120))
+- {
+- if ((j % m_nChannels) > highchan)
+- highchan = j % m_nChannels;
+- }
+- }
+- }
+- }
+-
+- return highchan;
+-}
+-
+-
+-
+-#ifndef MODPLUG_FASTSOUNDLIB
+-
+-UINT CSoundFile::DetectUnusedSamples(BOOL *pbIns)
+-//-----------------------------------------------
+-{
+- UINT nExt = 0;
+-
+- if (!pbIns) return 0;
+- if (m_dwSongFlags & SONG_INSTRUMENTMODE)
+- {
+- memset(pbIns, 0, MAX_SAMPLES * sizeof(BOOL));
+- for (UINT ipat=0; ipat<MAX_PATTERNS; ipat++)
+- {
+- MODCOMMAND *p = Patterns[ipat];
+- if (p)
+- {
+- UINT jmax = PatternSize[ipat] * m_nChannels;
+- for (UINT j=0; j<jmax; j++, p++)
+- {
+- if ((p->note) && (p->note <= 120))
+- {
+- if ((p->instr) && (p->instr < MAX_INSTRUMENTS))
+- {
+- INSTRUMENTHEADER *penv = Headers[p->instr];
+- if (penv)
+- {
+- UINT n = penv->Keyboard[p->note-1];
+- if (n < MAX_SAMPLES) pbIns[n] = TRUE;
+- }
+- } else
+- {
+- for (UINT k=1; k<=m_nInstruments; k++)
+- {
+- INSTRUMENTHEADER *penv = Headers[k];
+- if (penv)
+- {
+- UINT n = penv->Keyboard[p->note-1];
+- if (n < MAX_SAMPLES) pbIns[n] = TRUE;
+- }
+- }
+- }
+- }
+- }
+- }
+- }
+- for (UINT ichk=1; ichk<=m_nSamples; ichk++)
+- {
+- if ((!pbIns[ichk]) && (Ins[ichk].pSample)) nExt++;
+- }
+- }
+- return nExt;
+-}
+-
+-
+-BOOL CSoundFile::RemoveSelectedSamples(BOOL *pbIns)
+-//-------------------------------------------------
+-{
+- if (!pbIns) return FALSE;
+- for (UINT j=1; j<MAX_SAMPLES; j++)
+- {
+- if ((!pbIns[j]) && (Ins[j].pSample))
+- {
+- DestroySample(j);
+- if ((j == m_nSamples) && (j > 1)) m_nSamples--;
+- }
+- }
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::DestroySample(UINT nSample)
+-//------------------------------------------
+-{
+- if ((!nSample) || (nSample >= MAX_SAMPLES)) return FALSE;
+- if (!Ins[nSample].pSample) return TRUE;
+- MODINSTRUMENT *pins = &Ins[nSample];
+- signed char *pSample = pins->pSample;
+- pins->pSample = NULL;
+- pins->nLength = 0;
+- pins->uFlags &= ~(CHN_16BIT);
+- for (UINT i=0; i<MAX_CHANNELS; i++)
+- {
+- if (Chn[i].pSample == pSample)
+- {
+- Chn[i].nPos = Chn[i].nLength = 0;
+- Chn[i].pSample = Chn[i].pCurrentSample = NULL;
+- }
+- }
+- FreeSample(pSample);
+- return TRUE;
+-}
+-
+-#endif // MODPLUG_FASTSOUNDLIB
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/sndfile.h audacious-plugins-2.5.4/src/modplug/sndfile.h
+--- audacious-plugins-2.5.4-orig/src/modplug/sndfile.h 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/sndfile.h 1970-01-01 01:00:00.000000000 +0100
+@@ -1,1042 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#include <config.h>
+-
+-#ifndef __SNDFILE_H
+-#define __SNDFILE_H
+-
+-#define MODPLUG_TRACKER 1
+-#define MODPLUG_PLAYER 1
+-
+-#ifdef UNDER_CE
+-int _strnicmp(const char *str1,const char *str2, int n);
+-#endif
+-
+-#ifndef LPCBYTE
+-typedef const BYTE * LPCBYTE;
+-#endif
+-
+-#define MOD_AMIGAC2 0x1AB
+-#define MAX_SAMPLE_LENGTH 16000000
+-#define MAX_SAMPLE_RATE 192000
+-#define MAX_ORDERS 256
+-#define MAX_PATTERNS 240
+-#define MAX_SAMPLES 240
+-#define MAX_INSTRUMENTS MAX_SAMPLES
+-#ifdef MODPLUG_FASTSOUNDLIB
+-#define MAX_CHANNELS 80
+-#else
+-#define MAX_CHANNELS 256
+-#endif
+-#define MAX_BASECHANNELS 64
+-#define MAX_ENVPOINTS 32
+-#define MIN_PERIOD 0x0020
+-#define MAX_PERIOD 0xFFFF
+-#define MAX_PATTERNNAME 32
+-#define MAX_CHANNELNAME 20
+-#define MAX_INFONAME 80
+-#define MAX_EQ_BANDS 6
+-#define MAX_MIXPLUGINS 8
+-
+-
+-#define MOD_TYPE_NONE 0x00
+-#define MOD_TYPE_MOD 0x01
+-#define MOD_TYPE_S3M 0x02
+-#define MOD_TYPE_XM 0x04
+-#define MOD_TYPE_MED 0x08
+-#define MOD_TYPE_MTM 0x10
+-#define MOD_TYPE_IT 0x20
+-#define MOD_TYPE_669 0x40
+-#define MOD_TYPE_ULT 0x80
+-#define MOD_TYPE_STM 0x100
+-#define MOD_TYPE_FAR 0x200
+-#define MOD_TYPE_WAV 0x400
+-#define MOD_TYPE_AMF 0x800
+-#define MOD_TYPE_AMS 0x1000
+-#define MOD_TYPE_DSM 0x2000
+-#define MOD_TYPE_MDL 0x4000
+-#define MOD_TYPE_OKT 0x8000
+-#define MOD_TYPE_MID 0x10000
+-#define MOD_TYPE_DMF 0x20000
+-#define MOD_TYPE_PTM 0x40000
+-#define MOD_TYPE_DBM 0x80000
+-#define MOD_TYPE_MT2 0x100000
+-#define MOD_TYPE_AMF0 0x200000
+-#define MOD_TYPE_PSM 0x400000
+-#define MOD_TYPE_UMX 0x80000000 // Fake type
+-#define MAX_MODTYPE 23
+-
+-
+-
+-// Channel flags:
+-// Bits 0-7: Sample Flags
+-#define CHN_16BIT 0x01
+-#define CHN_LOOP 0x02
+-#define CHN_PINGPONGLOOP 0x04
+-#define CHN_SUSTAINLOOP 0x08
+-#define CHN_PINGPONGSUSTAIN 0x10
+-#define CHN_PANNING 0x20
+-#define CHN_STEREO 0x40
+-#define CHN_PINGPONGFLAG 0x80
+-// Bits 8-31: Channel Flags
+-#define CHN_MUTE 0x100
+-#define CHN_KEYOFF 0x200
+-#define CHN_NOTEFADE 0x400
+-#define CHN_SURROUND 0x800
+-#define CHN_NOIDO 0x1000
+-#define CHN_HQSRC 0x2000
+-#define CHN_FILTER 0x4000
+-#define CHN_VOLUMERAMP 0x8000
+-#define CHN_VIBRATO 0x10000
+-#define CHN_TREMOLO 0x20000
+-#define CHN_PANBRELLO 0x40000
+-#define CHN_PORTAMENTO 0x80000
+-#define CHN_GLISSANDO 0x100000
+-#define CHN_VOLENV 0x200000
+-#define CHN_PANENV 0x400000
+-#define CHN_PITCHENV 0x800000
+-#define CHN_FASTVOLRAMP 0x1000000
+-#define CHN_EXTRALOUD 0x2000000
+-#define CHN_REVERB 0x4000000
+-#define CHN_NOREVERB 0x8000000
+-// used to turn off mute but have it reset later
+-#define CHN_NNAMUTE 0x10000000
+-
+-
+-#define ENV_VOLUME 0x0001
+-#define ENV_VOLSUSTAIN 0x0002
+-#define ENV_VOLLOOP 0x0004
+-#define ENV_PANNING 0x0008
+-#define ENV_PANSUSTAIN 0x0010
+-#define ENV_PANLOOP 0x0020
+-#define ENV_PITCH 0x0040
+-#define ENV_PITCHSUSTAIN 0x0080
+-#define ENV_PITCHLOOP 0x0100
+-#define ENV_SETPANNING 0x0200
+-#define ENV_FILTER 0x0400
+-#define ENV_VOLCARRY 0x0800
+-#define ENV_PANCARRY 0x1000
+-#define ENV_PITCHCARRY 0x2000
+-#define ENV_MUTE 0x4000
+-
+-#define CMD_NONE 0
+-#define CMD_ARPEGGIO 1
+-#define CMD_PORTAMENTOUP 2
+-#define CMD_PORTAMENTODOWN 3
+-#define CMD_TONEPORTAMENTO 4
+-#define CMD_VIBRATO 5
+-#define CMD_TONEPORTAVOL 6
+-#define CMD_VIBRATOVOL 7
+-#define CMD_TREMOLO 8
+-#define CMD_PANNING8 9
+-#define CMD_OFFSET 10
+-#define CMD_VOLUMESLIDE 11
+-#define CMD_POSITIONJUMP 12
+-#define CMD_VOLUME 13
+-#define CMD_PATTERNBREAK 14
+-#define CMD_RETRIG 15
+-#define CMD_SPEED 16
+-#define CMD_TEMPO 17
+-#define CMD_TREMOR 18
+-#define CMD_MODCMDEX 19
+-#define CMD_S3MCMDEX 20
+-#define CMD_CHANNELVOLUME 21
+-#define CMD_CHANNELVOLSLIDE 22
+-#define CMD_GLOBALVOLUME 23
+-#define CMD_GLOBALVOLSLIDE 24
+-#define CMD_KEYOFF 25
+-#define CMD_FINEVIBRATO 26
+-#define CMD_PANBRELLO 27
+-#define CMD_XFINEPORTAUPDOWN 28
+-#define CMD_PANNINGSLIDE 29
+-#define CMD_SETENVPOSITION 30
+-#define CMD_MIDI 31
+-
+-
+-// Volume Column commands
+-#define VOLCMD_VOLUME 1
+-#define VOLCMD_PANNING 2
+-#define VOLCMD_VOLSLIDEUP 3
+-#define VOLCMD_VOLSLIDEDOWN 4
+-#define VOLCMD_FINEVOLUP 5
+-#define VOLCMD_FINEVOLDOWN 6
+-#define VOLCMD_VIBRATOSPEED 7
+-#define VOLCMD_VIBRATO 8
+-#define VOLCMD_PANSLIDELEFT 9
+-#define VOLCMD_PANSLIDERIGHT 10
+-#define VOLCMD_TONEPORTAMENTO 11
+-#define VOLCMD_PORTAUP 12
+-#define VOLCMD_PORTADOWN 13
+-
+-#define RSF_16BIT 0x04
+-#define RSF_STEREO 0x08
+-
+-#define RS_PCM8S 0 // 8-bit signed
+-#define RS_PCM8U 1 // 8-bit unsigned
+-#define RS_PCM8D 2 // 8-bit delta values
+-#define RS_ADPCM4 3 // 4-bit ADPCM-packed
+-#define RS_PCM16D 4 // 16-bit delta values
+-#define RS_PCM16S 5 // 16-bit signed
+-#define RS_PCM16U 6 // 16-bit unsigned
+-#define RS_PCM16M 7 // 16-bit motorola order
+-#define RS_STPCM8S (RS_PCM8S|RSF_STEREO) // stereo 8-bit signed
+-#define RS_STPCM8U (RS_PCM8U|RSF_STEREO) // stereo 8-bit unsigned
+-#define RS_STPCM8D (RS_PCM8D|RSF_STEREO) // stereo 8-bit delta values
+-#define RS_STPCM16S (RS_PCM16S|RSF_STEREO) // stereo 16-bit signed
+-#define RS_STPCM16U (RS_PCM16U|RSF_STEREO) // stereo 16-bit unsigned
+-#define RS_STPCM16D (RS_PCM16D|RSF_STEREO) // stereo 16-bit delta values
+-#define RS_STPCM16M (RS_PCM16M|RSF_STEREO) // stereo 16-bit signed big endian
+-// IT 2.14 compressed samples
+-#define RS_IT2148 0x10
+-#define RS_IT21416 0x14
+-#define RS_IT2158 0x12
+-#define RS_IT21516 0x16
+-// AMS Packed Samples
+-#define RS_AMS8 0x11
+-#define RS_AMS16 0x15
+-// DMF Huffman compression
+-#define RS_DMF8 0x13
+-#define RS_DMF16 0x17
+-// MDL Huffman compression
+-#define RS_MDL8 0x20
+-#define RS_MDL16 0x24
+-#define RS_PTM8DTO16 0x25
+-// Stereo Interleaved Samples
+-#define RS_STIPCM8S (RS_PCM8S|0x40|RSF_STEREO) // stereo 8-bit signed
+-#define RS_STIPCM8U (RS_PCM8U|0x40|RSF_STEREO) // stereo 8-bit unsigned
+-#define RS_STIPCM16S (RS_PCM16S|0x40|RSF_STEREO) // stereo 16-bit signed
+-#define RS_STIPCM16U (RS_PCM16U|0x40|RSF_STEREO) // stereo 16-bit unsigned
+-#define RS_STIPCM16M (RS_PCM16M|0x40|RSF_STEREO) // stereo 16-bit signed big endian
+-// 24-bit signed
+-#define RS_PCM24S (RS_PCM16S|0x80) // mono 24-bit signed
+-#define RS_STIPCM24S (RS_PCM16S|0x80|RSF_STEREO) // stereo 24-bit signed
+-#define RS_PCM32S (RS_PCM16S|0xC0) // mono 24-bit signed
+-#define RS_STIPCM32S (RS_PCM16S|0xC0|RSF_STEREO) // stereo 24-bit signed
+-
+-// NNA types
+-#define NNA_NOTECUT 0
+-#define NNA_CONTINUE 1
+-#define NNA_NOTEOFF 2
+-#define NNA_NOTEFADE 3
+-
+-// DCT types
+-#define DCT_NONE 0
+-#define DCT_NOTE 1
+-#define DCT_SAMPLE 2
+-#define DCT_INSTRUMENT 3
+-
+-// DNA types
+-#define DNA_NOTECUT 0
+-#define DNA_NOTEOFF 1
+-#define DNA_NOTEFADE 2
+-
+-// Mixer Hardware-Dependent features
+-#define SYSMIX_ENABLEMMX 0x01
+-#define SYSMIX_WINDOWSNT 0x02
+-#define SYSMIX_SLOWCPU 0x04
+-#define SYSMIX_FASTCPU 0x08
+-
+-// Module flags
+-#define SONG_EMBEDMIDICFG 0x0001
+-#define SONG_FASTVOLSLIDES 0x0002
+-#define SONG_ITOLDEFFECTS 0x0004
+-#define SONG_ITCOMPATMODE 0x0008
+-#define SONG_LINEARSLIDES 0x0010
+-#define SONG_PATTERNLOOP 0x0020
+-#define SONG_STEP 0x0040
+-#define SONG_PAUSED 0x0080
+-#define SONG_FADINGSONG 0x0100
+-#define SONG_ENDREACHED 0x0200
+-#define SONG_GLOBALFADE 0x0400
+-#define SONG_CPUVERYHIGH 0x0800
+-#define SONG_FIRSTTICK 0x1000
+-#define SONG_MPTFILTERMODE 0x2000
+-#define SONG_SURROUNDPAN 0x4000
+-#define SONG_EXFILTERRANGE 0x8000
+-#define SONG_AMIGALIMITS 0x10000
+-#define SONG_INSTRUMENTMODE 0x20000
+-#define SONG_ORDERLOCKED 0x40000
+-#define SONG_NOSTEREO 0x80000
+-
+-// Global Options (Renderer)
+-#define SNDMIX_REVERSESTEREO 0x0001
+-#define SNDMIX_NOISEREDUCTION 0x0002
+-#define SNDMIX_AGC 0x0004
+-#define SNDMIX_NORESAMPLING 0x0008
+-#define SNDMIX_HQRESAMPLER 0x0010
+-#define SNDMIX_MEGABASS 0x0020
+-#define SNDMIX_SURROUND 0x0040
+-#define SNDMIX_REVERB 0x0080
+-#define SNDMIX_EQ 0x0100
+-#define SNDMIX_SOFTPANNING 0x0200
+-#define SNDMIX_ULTRAHQSRCMODE 0x0400
+-// Misc Flags (can safely be turned on or off)
+-#define SNDMIX_DIRECTTODISK 0x10000
+-#define SNDMIX_ENABLEMMX 0x20000
+-#define SNDMIX_NOBACKWARDJUMPS 0x40000
+-#define SNDMIX_MAXDEFAULTPAN 0x80000 // Used by the MOD loader
+-#define SNDMIX_MUTECHNMODE 0x100000 // Notes are not played on muted channels
+-#define SNDMIX_NOSURROUND 0x200000
+-#define SNDMIX_NOMIXING 0x400000 // don't actually do any mixing (values only)
+-#define SNDMIX_NORAMPING 0x800000
+-
+-// Reverb Types (GM2 Presets)
+-enum {
+- REVERBTYPE_SMALLROOM,
+- REVERBTYPE_MEDIUMROOM,
+- REVERBTYPE_LARGEROOM,
+- REVERBTYPE_SMALLHALL,
+- REVERBTYPE_MEDIUMHALL,
+- REVERBTYPE_LARGEHALL,
+- NUM_REVERBTYPES
+-};
+-
+-
+-enum {
+- SRCMODE_NEAREST,
+- SRCMODE_LINEAR,
+- SRCMODE_SPLINE,
+- SRCMODE_POLYPHASE,
+- NUM_SRC_MODES
+-};
+-
+-
+-// Sample Struct
+-typedef struct _MODINSTRUMENT
+-{
+- UINT nLength,nLoopStart,nLoopEnd;
+- UINT nSustainStart, nSustainEnd;
+- signed char *pSample;
+- UINT nC4Speed;
+- UINT nPan;
+- UINT nVolume;
+- UINT nGlobalVol;
+- UINT uFlags;
+- int RelativeTone;
+- int nFineTune;
+- UINT nVibType;
+- UINT nVibSweep;
+- UINT nVibDepth;
+- UINT nVibRate;
+- CHAR name[22];
+- int played; // for note playback dots
+-} MODINSTRUMENT;
+-
+-typedef struct _INSTRUMENTENVELOPE {
+- int Ticks[32];
+- BYTE Values[32];
+- int nNodes;
+- int nLoopStart;
+- int nLoopEnd;
+- int nSustainStart;
+- int nSustainEnd;
+-} INSTRUMENTENVELOPE;
+-
+-
+-// Instrument Struct
+-typedef struct _INSTRUMENTHEADER
+-{
+- UINT nFadeOut;
+- DWORD dwFlags;
+- unsigned int nGlobalVol;
+- unsigned int nPan;
+- unsigned int Keyboard[128];
+- unsigned int NoteMap[128];
+- INSTRUMENTENVELOPE VolEnv;
+- INSTRUMENTENVELOPE PanEnv;
+- INSTRUMENTENVELOPE PitchEnv;
+- unsigned int nNNA;
+- unsigned int nDCT;
+- unsigned int nDNA;
+- unsigned int nPanSwing;
+- unsigned int nVolSwing;
+- unsigned int nIFC;
+- unsigned int nIFR;
+- unsigned int wMidiBank;
+- unsigned int nMidiProgram;
+- unsigned int nMidiChannel;
+- unsigned int nMidiDrumKey;
+- int nPPS;
+- unsigned int nPPC;
+- CHAR name[32];
+- CHAR filename[12];
+- int played; // for note playback dots
+-} INSTRUMENTHEADER;
+-
+-
+-// Channel Struct
+-typedef struct _MODCHANNEL
+-{
+- // First 32-bytes: Most used mixing information: don't change it
+- signed char * pCurrentSample;
+- DWORD nPos;
+- DWORD nPosLo; // actually 16-bit
+- unsigned int topnote_offset;
+- LONG nInc; // 16.16
+- LONG nRightVol;
+- LONG nLeftVol;
+- LONG nRightRamp;
+- LONG nLeftRamp;
+- // 2nd cache line
+- DWORD nLength;
+- DWORD dwFlags;
+- DWORD nLoopStart;
+- DWORD nLoopEnd;
+- LONG nRampRightVol;
+- LONG nRampLeftVol;
+-
+- double nFilter_Y1, nFilter_Y2, nFilter_Y3, nFilter_Y4;
+- double nFilter_A0, nFilter_B0, nFilter_B1;
+-
+- LONG nROfs, nLOfs;
+- LONG nRampLength;
+- // Information not used in the mixer
+- signed char * pSample;
+- LONG nNewRightVol, nNewLeftVol;
+- LONG nRealVolume, nRealPan;
+- LONG nVolume, nPan, nFadeOutVol;
+- LONG nPeriod, nC4Speed, sample_freq, nPortamentoDest;
+- INSTRUMENTHEADER *pHeader;
+- MODINSTRUMENT *pInstrument;
+- int nVolEnvPosition, nPanEnvPosition, nPitchEnvPosition;
+- DWORD nMasterChn, nVUMeter;
+- LONG nGlobalVol, nInsVol;
+- LONG nFineTune, nTranspose;
+- LONG nPortamentoSlide, nAutoVibDepth;
+- UINT nAutoVibPos, nVibratoPos, nTremoloPos, nPanbrelloPos;
+- // 16-bit members
+- int nVolSwing, nPanSwing;
+-
+- // formally 8-bit members
+- unsigned int nNote, nNNA;
+- unsigned int nNewNote, nNewIns, nCommand, nArpeggio;
+- unsigned int nOldVolumeSlide, nOldFineVolUpDown;
+- unsigned int nOldPortaUpDown, nOldFinePortaUpDown;
+- unsigned int nOldPanSlide, nOldChnVolSlide;
+- unsigned int nVibratoType, nVibratoSpeed, nVibratoDepth;
+- unsigned int nTremoloType, nTremoloSpeed, nTremoloDepth;
+- unsigned int nPanbrelloType, nPanbrelloSpeed, nPanbrelloDepth;
+- unsigned int nOldCmdEx, nOldVolParam, nOldTempo;
+- unsigned int nOldOffset, nOldHiOffset;
+- unsigned int nCutOff, nResonance;
+- unsigned int nRetrigCount, nRetrigParam;
+- unsigned int nTremorCount, nTremorParam;
+- unsigned int nPatternLoop, nPatternLoopCount;
+- unsigned int nRowNote, nRowInstr;
+- unsigned int nRowVolCmd, nRowVolume;
+- unsigned int nRowCommand, nRowParam;
+- unsigned int nLeftVU, nRightVU;
+- unsigned int nActiveMacro, nLastInstr;
+- unsigned int nTickStart;
+- unsigned int nRealtime;
+- BYTE stupid_gcc_workaround;
+-
+-} MODCHANNEL;
+-
+-
+-typedef struct _MODCHANNELSETTINGS
+-{
+- UINT nPan;
+- UINT nVolume;
+- DWORD dwFlags;
+- UINT nMixPlugin;
+- char szName[MAX_CHANNELNAME]; // changed from CHAR
+-} MODCHANNELSETTINGS;
+-
+-
+-typedef struct _MODCOMMAND
+-{
+- BYTE note;
+- BYTE instr;
+- BYTE volcmd;
+- BYTE command;
+- BYTE vol;
+- BYTE param;
+-} MODCOMMAND, *LPMODCOMMAND;
+-
+-////////////////////////////////////////////////////////////////////
+-// Mix Plugins
+-#define MIXPLUG_MIXREADY 0x01 // Set when cleared
+-
+-class IMixPlugin
+-{
+-public:
+- virtual ~IMixPlugin() = 0;
+- virtual int AddRef() = 0;
+- virtual int Release() = 0;
+- virtual void SaveAllParameters() = 0;
+- virtual void RestoreAllParameters() = 0;
+- virtual void Process(float *pOutL, float *pOutR, unsigned int nSamples) = 0;
+- virtual void Init(unsigned int nFreq, int bReset) = 0;
+- virtual void MidiSend(DWORD dwMidiCode) = 0;
+- virtual void MidiCommand(UINT nMidiCh, UINT nMidiProg, UINT note, UINT vol) = 0;
+-};
+-
+-
+-#define MIXPLUG_INPUTF_MASTEREFFECT 0x01 // Apply to master mix
+-#define MIXPLUG_INPUTF_BYPASS 0x02 // Bypass effect
+-#define MIXPLUG_INPUTF_WETMIX 0x04 // Wet Mix (dry added)
+-
+-typedef struct _SNDMIXPLUGINSTATE
+-{
+- DWORD dwFlags; // MIXPLUG_XXXX
+- LONG nVolDecayL, nVolDecayR; // Buffer click removal
+- int *pMixBuffer; // Stereo effect send buffer
+- float *pOutBufferL; // Temp storage for int -> float conversion
+- float *pOutBufferR;
+-} SNDMIXPLUGINSTATE, *PSNDMIXPLUGINSTATE;
+-
+-typedef struct _SNDMIXPLUGININFO
+-{
+- DWORD dwPluginId1;
+- DWORD dwPluginId2;
+- DWORD dwInputRouting; // MIXPLUG_INPUTF_XXXX
+- DWORD dwOutputRouting; // 0=mix 0x80+=fx
+- DWORD dwReserved[4]; // Reserved for routing info
+- CHAR szName[32];
+- CHAR szLibraryName[64]; // original DLL name
+-} SNDMIXPLUGININFO, *PSNDMIXPLUGININFO; // Size should be 128
+-
+-typedef struct _SNDMIXPLUGIN
+-{
+- IMixPlugin *pMixPlugin;
+- PSNDMIXPLUGINSTATE pMixState;
+- ULONG nPluginDataSize;
+- PVOID pPluginData;
+- SNDMIXPLUGININFO Info;
+-} SNDMIXPLUGIN, *PSNDMIXPLUGIN;
+-
+-typedef BOOL (*PMIXPLUGINCREATEPROC)(PSNDMIXPLUGIN);
+-
+-////////////////////////////////////////////////////////////////////
+-
+-enum {
+- MIDIOUT_START=0,
+- MIDIOUT_STOP,
+- MIDIOUT_TICK,
+- MIDIOUT_NOTEON,
+- MIDIOUT_NOTEOFF,
+- MIDIOUT_VOLUME,
+- MIDIOUT_PAN,
+- MIDIOUT_BANKSEL,
+- MIDIOUT_PROGRAM,
+-};
+-
+-
+-typedef struct MODMIDICFG
+-{
+- char szMidiGlb[9*32]; // changed from CHAR
+- char szMidiSFXExt[16*32]; // changed from CHAR
+- char szMidiZXXExt[128*32]; // changed from CHAR
+-} MODMIDICFG, *LPMODMIDICFG;
+-
+-
+-typedef VOID (* LPSNDMIXHOOKPROC)(int *, unsigned int, unsigned int); // buffer, samples, channels
+-
+-
+-
+-//==============
+-class CSoundFile
+-//==============
+-{
+-public: // Static Members
+- static UINT m_nXBassDepth, m_nXBassRange;
+- static UINT m_nReverbDepth, m_nReverbDelay, gnReverbType;
+- static UINT m_nProLogicDepth, m_nProLogicDelay;
+- static UINT m_nMaxMixChannels;
+- static LONG m_nStreamVolume;
+- static DWORD gdwSysInfo, gdwSoundSetup, gdwMixingFreq, gnBitsPerSample, gnChannels;
+- static UINT gnAGC, gnVolumeRampSamples, gnCPUUsage;
+- static UINT gnVULeft, gnVURight;
+- static LPSNDMIXHOOKPROC gpSndMixHook;
+- static PMIXPLUGINCREATEPROC gpMixPluginCreateProc;
+-
+-public: // for Editing
+- MODCHANNEL Chn[MAX_CHANNELS]; // Channels
+- UINT ChnMix[MAX_CHANNELS]; // Channels to be mixed
+- MODINSTRUMENT Ins[MAX_SAMPLES]; // Instruments
+- INSTRUMENTHEADER *Headers[MAX_INSTRUMENTS]; // Instrument Headers
+- MODCHANNELSETTINGS ChnSettings[MAX_BASECHANNELS]; // Channels settings
+- MODCOMMAND *Patterns[MAX_PATTERNS]; // Patterns
+- WORD PatternSize[MAX_PATTERNS]; // Patterns Lengths
+- WORD PatternAllocSize[MAX_PATTERNS]; // Allocated pattern lengths (for async. resizing/playback)
+- BYTE Order[MAX_ORDERS]; // Pattern Orders
+- MODMIDICFG m_MidiCfg; // Midi macro config table
+- SNDMIXPLUGIN m_MixPlugins[MAX_MIXPLUGINS]; // Mix plugins
+- UINT m_nDefaultSpeed, m_nDefaultTempo, m_nDefaultGlobalVolume;
+- DWORD m_dwSongFlags; // Song flags SONG_XXXX
+- UINT m_nStereoSeparation;
+- UINT m_nChannels, m_nMixChannels, m_nMixStat, m_nBufferCount;
+- UINT m_nType, m_nSamples, m_nInstruments;
+- UINT m_nTickCount, m_nTotalCount, m_nPatternDelay, m_nFrameDelay;
+- UINT m_nMusicSpeed, m_nMusicTempo;
+- UINT m_nNextRow, m_nRow;
+- UINT m_nPattern,m_nCurrentPattern,m_nNextPattern,m_nLockedPattern,m_nRestartPos;
+- UINT m_nMasterVolume, m_nGlobalVolume, m_nSongPreAmp;
+- UINT m_nFreqFactor, m_nTempoFactor, m_nOldGlbVolSlide;
+- LONG m_nMinPeriod, m_nMaxPeriod, m_nRepeatCount, m_nInitialRepeatCount;
+- DWORD m_nGlobalFadeSamples, m_nGlobalFadeMaxSamples;
+- BYTE m_rowHighlightMajor, m_rowHighlightMinor;
+- UINT m_nPatternNames;
+- LPSTR m_lpszSongComments, m_lpszPatternNames;
+- char m_szNames[MAX_INSTRUMENTS][32]; // changed from CHAR
+- CHAR CompressionTable[16];
+-
+-public:
+- CSoundFile();
+- ~CSoundFile();
+-
+-public:
+- BOOL Create(LPCBYTE lpStream, DWORD dwMemLength=0);
+- BOOL Destroy();
+- UINT GetHighestUsedChannel();
+- UINT GetType() const { return m_nType; }
+- UINT GetNumChannels() const;
+- UINT GetLogicalChannels() const { return m_nChannels; }
+- BOOL SetMasterVolume(UINT vol, BOOL bAdjustAGC=FALSE);
+- UINT GetMasterVolume() const { return m_nMasterVolume; }
+- UINT GetNumPatterns() const;
+- UINT GetNumInstruments() const;
+- UINT GetNumSamples() const { return m_nSamples; }
+- UINT GetCurrentPos() const;
+- UINT GetCurrentPattern() const { return m_nPattern; }
+- UINT GetCurrentOrder() const { return m_nCurrentPattern; }
+- UINT GetSongComments(LPSTR s, UINT cbsize, UINT linesize=32);
+- UINT GetRawSongComments(LPSTR s, UINT cbsize, UINT linesize=32);
+- UINT GetMaxPosition() const;
+- void SetCurrentPos(UINT nPos);
+- void SetCurrentOrder(UINT nOrder);
+- void GetTitle(LPSTR s) const { lstrcpyn(s,m_szNames[0],32); }
+- LPCSTR GetTitle() const { return m_szNames[0]; }
+- UINT GetSampleName(UINT nSample,LPSTR s=NULL) const;
+- UINT GetInstrumentName(UINT nInstr,LPSTR s=NULL) const;
+- UINT GetMusicSpeed() const { return m_nMusicSpeed; }
+- UINT GetMusicTempo() const { return m_nMusicTempo; }
+- DWORD GetLength(BOOL bAdjust, BOOL bTotal=FALSE);
+- DWORD GetSongTime() { return GetLength(FALSE, TRUE); }
+- void SetRepeatCount(int n) { m_nRepeatCount = n; m_nInitialRepeatCount = n; }
+- int GetRepeatCount() const { return m_nRepeatCount; }
+- BOOL IsPaused() const { return (m_dwSongFlags & SONG_PAUSED) ? TRUE : FALSE; }
+- void LoopPattern(int nPat, int nRow=0);
+- void CheckCPUUsage(UINT nCPU);
+- BOOL SetPatternName(UINT nPat, LPCSTR lpszName);
+- BOOL GetPatternName(UINT nPat, LPSTR lpszName, UINT cbSize=MAX_PATTERNNAME) const;
+- // Module Loaders
+- BOOL ReadXM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadS3M(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadMod(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadMed(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadMTM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadSTM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadIT(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL Read669(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadUlt(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadWav(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadDSM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadFAR(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadAMS(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadAMS2(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadMDL(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadOKT(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadDMF(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadPTM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadDBM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadAMF(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadMT2(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadPSM(LPCBYTE lpStream, DWORD dwMemLength);
+- BOOL ReadUMX(LPCBYTE lpStream, DWORD dwMemLength);
+- // MOD Convert function
+- UINT GetBestSaveFormat() const;
+- UINT GetSaveFormats() const;
+- void ConvertModCommand(MODCOMMAND *) const;
+- void S3MConvert(MODCOMMAND *m, BOOL bIT) const;
+- void S3MSaveConvert(UINT *pcmd, UINT *pprm, BOOL bIT) const;
+- WORD ModSaveCommand(const MODCOMMAND *m, BOOL bXM) const;
+-public:
+- // backhooks :)
+- static void (*_midi_out_note)(int chan, const MODCOMMAND *m);
+- static void (*_midi_out_raw)(unsigned char *,unsigned int, unsigned int);
+-
+-public:
+- // Real-time sound functions
+- VOID ResetChannels();
+-
+- UINT Read(LPVOID lpBuffer, UINT cbBuffer);
+- UINT CreateStereoMix(int count);
+- BOOL FadeSong(UINT msec);
+- BOOL GlobalFadeSong(UINT msec);
+- UINT GetTotalTickCount() const { return m_nTotalCount; }
+- VOID ResetTotalTickCount() { m_nTotalCount = 0; }
+-
+-public:
+- // Mixer Config
+- static BOOL InitPlayer(BOOL bReset=FALSE);
+- static BOOL SetWaveConfig(UINT nRate,UINT nBits,UINT nChannels,BOOL bMMX=FALSE);
+- static BOOL SetResamplingMode(UINT nMode); // SRCMODE_XXXX
+- static BOOL IsStereo() { return (gnChannels > 1) ? TRUE : FALSE; }
+- static DWORD GetSampleRate() { return gdwMixingFreq; }
+- static DWORD GetBitsPerSample() { return gnBitsPerSample; }
+- static DWORD InitSysInfo();
+- static DWORD GetSysInfo() { return gdwSysInfo; }
+- // AGC
+- static BOOL GetAGC() { return (gdwSoundSetup & SNDMIX_AGC) ? TRUE : FALSE; }
+- static void SetAGC(BOOL b);
+- static void ResetAGC();
+- static void ProcessAGC(int count);
+-
+- // Floats
+- static VOID StereoMixToFloat(const int *pSrc, float *pOut1, float *pOut2, UINT nCount);
+- static VOID FloatToStereoMix(const float *pIn1, const float *pIn2, int *pOut, UINT nCount);
+- static VOID MonoMixToFloat(const int *pSrc, float *pOut, UINT nCount);
+- static VOID FloatToMonoMix(const float *pIn, int *pOut, UINT nCount);
+-
+-
+-
+-
+-
+- // wee...
+- static void InitializeEQ(BOOL bReset=TRUE);
+- static void SetEQGains(const UINT *pGains, UINT nBands, const UINT *pFreqs=NULL, BOOL bReset=FALSE); // 0=-12dB, 32=+12dB
+- /*static*/ void EQStereo(int *pbuffer, UINT nCount);
+- /*static*/ void EQMono(int *pbuffer, UINT nCount);
+-
+-
+- //GCCFIX -- added these functions back in!
+- static BOOL SetWaveConfigEx(BOOL bSurround,BOOL bNoOverSampling,BOOL bReverb,BOOL hqido,BOOL bMegaBass,BOOL bNR,BOOL bEQ);
+- // DSP Effects
+- static void InitializeDSP(BOOL bReset);
+- static void ProcessStereoDSP(int count);
+- static void ProcessMonoDSP(int count);
+- // [Reverb level 0(quiet)-100(loud)], [delay in ms, usually 40-200ms]
+- static BOOL SetReverbParameters(UINT nDepth, UINT nDelay);
+- // [XBass level 0(quiet)-100(loud)], [cutoff in Hz 10-100]
+- static BOOL SetXBassParameters(UINT nDepth, UINT nRange);
+- // [Surround level 0(quiet)-100(heavy)] [delay in ms, usually 5-40ms]
+- static BOOL SetSurroundParameters(UINT nDepth, UINT nDelay);
+-public:
+- BOOL ReadNote();
+- BOOL ProcessRow();
+- BOOL ProcessEffects();
+- UINT GetNNAChannel(UINT nChn);
+- void CheckNNA(UINT nChn, UINT instr, int note, BOOL bForceCut);
+- void NoteChange(UINT nChn, int note, BOOL bPorta=FALSE, BOOL bResetEnv=TRUE, BOOL bManual=FALSE);
+- void InstrumentChange(MODCHANNEL *pChn, UINT instr, BOOL bPorta=FALSE,BOOL bUpdVol=TRUE,BOOL bResetEnv=TRUE);
+- // Channel Effects
+- void PortamentoUp(MODCHANNEL *pChn, UINT param);
+- void PortamentoDown(MODCHANNEL *pChn, UINT param);
+- void FinePortamentoUp(MODCHANNEL *pChn, UINT param);
+- void FinePortamentoDown(MODCHANNEL *pChn, UINT param);
+- void ExtraFinePortamentoUp(MODCHANNEL *pChn, UINT param);
+- void ExtraFinePortamentoDown(MODCHANNEL *pChn, UINT param);
+- void TonePortamento(MODCHANNEL *pChn, UINT param);
+- void Vibrato(MODCHANNEL *pChn, UINT param);
+- void FineVibrato(MODCHANNEL *pChn, UINT param);
+- void VolumeSlide(MODCHANNEL *pChn, UINT param);
+- void PanningSlide(MODCHANNEL *pChn, UINT param);
+- void ChannelVolSlide(MODCHANNEL *pChn, UINT param);
+- void FineVolumeUp(MODCHANNEL *pChn, UINT param);
+- void FineVolumeDown(MODCHANNEL *pChn, UINT param);
+- void Tremolo(MODCHANNEL *pChn, UINT param);
+- void Panbrello(MODCHANNEL *pChn, UINT param);
+- void RetrigNote(UINT nChn, UINT param);
+- void NoteCut(UINT nChn, UINT nTick);
+- void KeyOff(UINT nChn);
+- int PatternLoop(MODCHANNEL *, UINT param);
+- void ExtendedMODCommands(UINT nChn, UINT param);
+- void ExtendedS3MCommands(UINT nChn, UINT param);
+- void ExtendedChannelEffect(MODCHANNEL *, UINT param);
+- void MidiSend(unsigned char *data, unsigned int len, UINT nChn=0, int fake = 0);
+- void ProcessMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param=0,
+- UINT note=0, UINT velocity=0, UINT use_instr=0);
+- void SetupChannelFilter(MODCHANNEL *pChn, BOOL bReset, int flt_modifier=256,int freq=0) const;
+- // Low-Level effect processing
+- void DoFreqSlide(MODCHANNEL *pChn, LONG nFreqSlide);
+- // Global Effects
+- void SetTempo(UINT param);
+- void SetSpeed(UINT param);
+- void GlobalVolSlide(UINT param);
+- DWORD IsSongFinished(UINT nOrder, UINT nRow) const;
+- BOOL IsValidBackwardJump(UINT nStartOrder, UINT nStartRow, UINT nJumpOrder, UINT nJumpRow) const;
+- // Read/Write sample functions
+- signed char GetDeltaValue(signed char prev, UINT n) const { return (signed char)(prev + CompressionTable[n & 0x0F]); }
+- UINT PackSample(int &sample, int next);
+- BOOL CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result=NULL);
+- UINT ReadSample(MODINSTRUMENT *pIns, UINT nFlags, LPCSTR pMemFile, DWORD dwMemLength);
+- BOOL DestroySample(UINT nSample);
+- BOOL DestroyInstrument(UINT nInstr);
+- BOOL IsSampleUsed(UINT nSample);
+- BOOL IsInstrumentUsed(UINT nInstr);
+- BOOL RemoveInstrumentSamples(UINT nInstr);
+- UINT DetectUnusedSamples(BOOL *);
+- BOOL RemoveSelectedSamples(BOOL *);
+- void AdjustSampleLoop(MODINSTRUMENT *pIns);
+- // I/O from another sound file
+- BOOL ReadInstrumentFromSong(UINT nInstr, CSoundFile *, UINT nSrcInstrument);
+- BOOL ReadSampleFromSong(UINT nSample, CSoundFile *, UINT nSrcSample);
+- // Period/Note functions
+- UINT GetNoteFromPeriod(UINT period) const;
+- UINT GetPeriodFromNote(UINT note, int nFineTune, UINT nC4Speed) const;
+- UINT GetLinearPeriodFromNote(UINT note, int nFineTune, UINT nC4Speed) const;
+- UINT GetFreqFromPeriod(UINT period, UINT nC4Speed, int nPeriodFrac=0) const;
+- // Misc functions
+- MODINSTRUMENT *GetSample(UINT n) { return Ins+n; }
+- void ResetMidiCfg();
+- UINT MapMidiInstrument(DWORD dwProgram, UINT nChannel, UINT nNote);
+- BOOL ITInstrToMPT(const void *p, INSTRUMENTHEADER *penv, UINT trkvers);
+- UINT SaveMixPlugins(FILE *f=NULL, BOOL bUpdate=TRUE);
+- UINT LoadMixPlugins(const void *pData, UINT nLen);
+- void ResetTimestamps(); // for note playback dots
+-
+- // Static helper functions
+-public:
+- static DWORD TransposeToFrequency(int transp, int ftune=0);
+- static int FrequencyToTranspose(DWORD freq);
+- static void FrequencyToTranspose(MODINSTRUMENT *psmp);
+-
+- // System-Dependant functions
+-public:
+- static MODCOMMAND *AllocatePattern(UINT rows, UINT nchns);
+- static signed char* AllocateSample(UINT nbytes);
+- static void FreePattern(LPVOID pat);
+- static void FreeSample(LPVOID p);
+- static UINT Normalize24BitBuffer(LPBYTE pbuffer, UINT cbsizebytes, DWORD lmax24, DWORD dwByteInc);
+-};
+-
+-
+-// inline DWORD BigEndian(DWORD x) { return ((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24); }
+-// inline WORD BigEndianW(WORD x) { return (WORD)(((x >> 8) & 0xFF) | ((x << 8) & 0xFF00)); }
+-
+-
+-//////////////////////////////////////////////////////////
+-// WAVE format information
+-
+-#pragma pack(1)
+-
+-// Standard IFF chunks IDs
+-#define IFFID_FORM 0x4d524f46
+-#define IFFID_RIFF 0x46464952
+-#define IFFID_WAVE 0x45564157
+-#define IFFID_LIST 0x5453494C
+-#define IFFID_INFO 0x4F464E49
+-
+-// IFF Info fields
+-#define IFFID_ICOP 0x504F4349
+-#define IFFID_IART 0x54524149
+-#define IFFID_IPRD 0x44525049
+-#define IFFID_INAM 0x4D414E49
+-#define IFFID_ICMT 0x544D4349
+-#define IFFID_IENG 0x474E4549
+-#define IFFID_ISFT 0x54465349
+-#define IFFID_ISBJ 0x4A425349
+-#define IFFID_IGNR 0x524E4749
+-#define IFFID_ICRD 0x44524349
+-
+-// Wave IFF chunks IDs
+-#define IFFID_wave 0x65766177
+-#define IFFID_fmt 0x20746D66
+-#define IFFID_wsmp 0x706D7377
+-#define IFFID_pcm 0x206d6370
+-#define IFFID_data 0x61746164
+-#define IFFID_smpl 0x6C706D73
+-#define IFFID_xtra 0x61727478
+-
+-typedef struct WAVEFILEHEADER
+-{
+- DWORD id_RIFF; // "RIFF"
+- DWORD filesize; // file length-8
+- DWORD id_WAVE;
+-} WAVEFILEHEADER;
+-
+-
+-typedef struct WAVEFORMATHEADER
+-{
+- DWORD id_fmt; // "fmt "
+- DWORD hdrlen; // 16
+- WORD format; // 1
+- WORD channels; // 1:mono, 2:stereo
+- DWORD freqHz; // sampling freq
+- DWORD bytessec; // bytes/sec=freqHz*samplesize
+- WORD samplesize; // sizeof(sample)
+- WORD bitspersample; // bits per sample (8/16)
+-} WAVEFORMATHEADER;
+-
+-
+-typedef struct WAVEDATAHEADER
+-{
+- DWORD id_data; // "data"
+- DWORD length; // length of data
+-} WAVEDATAHEADER;
+-
+-
+-typedef struct WAVESMPLHEADER
+-{
+- // SMPL
+- DWORD smpl_id; // "smpl" -> 0x6C706D73
+- DWORD smpl_len; // length of smpl: 3Ch (54h with sustain loop)
+- DWORD dwManufacturer;
+- DWORD dwProduct;
+- DWORD dwSamplePeriod; // 1000000000/freqHz
+- DWORD dwBaseNote; // 3Ch = C-4 -> 60 + RelativeTone
+- DWORD dwPitchFraction;
+- DWORD dwSMPTEFormat;
+- DWORD dwSMPTEOffset;
+- DWORD dwSampleLoops; // number of loops
+- DWORD cbSamplerData;
+-} WAVESMPLHEADER;
+-
+-
+-typedef struct SAMPLELOOPSTRUCT
+-{
+- DWORD dwIdentifier;
+- DWORD dwLoopType; // 0=normal, 1=bidi
+- DWORD dwLoopStart;
+- DWORD dwLoopEnd; // Byte offset ?
+- DWORD dwFraction;
+- DWORD dwPlayCount; // Loop Count, 0=infinite
+-} SAMPLELOOPSTRUCT;
+-
+-
+-typedef struct WAVESAMPLERINFO
+-{
+- WAVESMPLHEADER wsiHdr;
+- SAMPLELOOPSTRUCT wsiLoops[2];
+-} WAVESAMPLERINFO;
+-
+-
+-typedef struct WAVELISTHEADER
+-{
+- DWORD list_id; // "LIST" -> 0x5453494C
+- DWORD list_len;
+- DWORD info; // "INFO"
+-} WAVELISTHEADER;
+-
+-
+-typedef struct WAVEEXTRAHEADER
+-{
+- DWORD xtra_id; // "xtra" -> 0x61727478
+- DWORD xtra_len;
+- DWORD dwFlags;
+- WORD wPan;
+- WORD wVolume;
+- WORD wGlobalVol;
+- WORD wReserved;
+- BYTE nVibType;
+- BYTE nVibSweep;
+- BYTE nVibDepth;
+- BYTE nVibRate;
+-} WAVEEXTRAHEADER;
+-
+-#pragma pack()
+-
+-///////////////////////////////////////////////////////////
+-// Low-level Mixing functions
+-
+-#define MIXBUFFERSIZE 512
+-#define MIXING_ATTENUATION 4
+-#define MIXING_CLIPMIN (-0x04000000)
+-#define MIXING_CLIPMAX (0x03FFFFFF)
+-#define VOLUMERAMPPRECISION 12
+-#define FADESONGDELAY 100
+-#define EQ_BUFFERSIZE (MIXBUFFERSIZE)
+-#define AGC_PRECISION 9
+-#define AGC_UNITY (1 << AGC_PRECISION)
+-
+-// Calling conventions
+-#ifdef MSC_VER
+-#define MPPASMCALL __cdecl
+-#define MPPFASTCALL __fastcall
+-#else
+-#define MPPASMCALL
+-#define MPPFASTCALL
+-#endif
+-
+-#define MOD2XMFineTune(k) ((int)( (signed char)((k)<<4) ))
+-#define XM2MODFineTune(k) ((int)( (k>>4)&0x0f ))
+-
+-// Return (a*b)/c - no divide error
+-static inline int _muldiv(int a, int b, int c)
+-{
+- return ((unsigned long long) a * (unsigned long long) b ) / c;
+-}
+-
+-
+-// Return (a*b+c/2)/c - no divide error
+-static inline int _muldivr(int a, int b, int c)
+-{
+- return ((unsigned long long) a * (unsigned long long) b + (c >> 1)) / c;
+-}
+-
+-
+-// Byte swapping functions from the GNU C Library and libsdl
+-
+-/* Swap bytes in 16 bit value. */
+-#ifdef __GNUC__
+-# define bswap_16(x) \
+- (__extension__ \
+- ({ unsigned short int __bsx = (x); \
+- ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8)); }))
+-#else
+-static __inline unsigned short int
+-bswap_16 (unsigned short int __bsx)
+-{
+- return ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8));
+-}
+-#endif
+-
+-/* Swap bytes in 32 bit value. */
+-#ifdef __GNUC__
+-# define bswap_32(x) \
+- (__extension__ \
+- ({ unsigned int __bsx = (x); \
+- ((((__bsx) & 0xff000000) >> 24) | (((__bsx) & 0x00ff0000) >> 8) | \
+- (((__bsx) & 0x0000ff00) << 8) | (((__bsx) & 0x000000ff) << 24)); }))
+-#else
+-static __inline unsigned int
+-bswap_32 (unsigned int __bsx)
+-{
+- return ((((__bsx) & 0xff000000) >> 24) | (((__bsx) & 0x00ff0000) >> 8) |
+- (((__bsx) & 0x0000ff00) << 8) | (((__bsx) & 0x000000ff) << 24));
+-}
+-#endif
+-
+-#if (defined ARM) && (defined _WIN32_WCE)
+-static __inline unsigned short int
+-ARM_get16(const void *data)
+-{
+- unsigned short int s;
+- memcpy(&s,data,sizeof(s));
+- return s;
+-}
+-
+-static __inline unsigned int
+-ARM_get32(const void *data)
+-{
+- unsigned int s;
+- memcpy(&s,data,sizeof(s));
+- return s;
+-}
+-
+-#define bswapLE16(X) ARM_get16(&X)
+-#define bswapLE32(X) ARM_get32(&X)
+-#define bswapBE16(X) bswap_16(ARM_get16(&X))
+-#define bswapBE32(X) bswap_32(ARM_get32(&X))
+-
+-// From libsdl
+-#elif WORDS_BIGENDIAN
+-#define bswapLE16(X) bswap_16(X)
+-#define bswapLE32(X) bswap_32(X)
+-#define bswapBE16(X) (X)
+-#define bswapBE32(X) (X)
+-#else
+-#define bswapLE16(X) (X)
+-#define bswapLE32(X) (X)
+-#define bswapBE16(X) bswap_16(X)
+-#define bswapBE32(X) bswap_32(X)
+-#endif
+-
+-#endif
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/snd_flt.cxx audacious-plugins-2.5.4/src/modplug/snd_flt.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/snd_flt.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/snd_flt.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,130 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-// AWE32: cutoff = reg[0-255] * 31.25 + 100 -> [100Hz-8060Hz]
+-// EMU10K1 docs: cutoff = reg[0-127]*62+100
+-
+-#ifndef NO_FILTER
+-
+-static int filter_cutoff[] = {
+- 130, 132, 134, 136, 138, 140, 142, 144,
+- 146, 148, 151, 153, 155, 157, 160, 162,
+- 164, 167, 169, 172, 174, 177, 179, 182,
+- 184, 187, 190, 193, 195, 198, 201, 204,
+- 207, 210, 213, 216, 220, 223, 226, 229,
+- 233, 236, 239, 243, 246, 250, 254, 257,
+- 261, 265, 269, 273, 277, 281, 285, 289,
+- 293, 297, 302, 306, 311, 315, 320, 324,
+- 329, 334, 339, 344, 349, 354, 359, 364,
+- 369, 375, 380, 386, 391, 397, 403, 409,
+- 415, 421, 427, 433, 440, 446, 452, 459,
+- 466, 472, 479, 486, 493, 501, 508, 515,
+- 523, 530, 538, 546, 554, 562, 570, 578,
+- 587, 595, 604, 613, 622, 631, 640, 649,
+- 659, 668, 678, 688, 698, 708, 718, 729,
+- 739, 750, 761, 772, 783, 795, 806, 818,
+- 830, 842, 854, 867, 880, 892, 905, 918,
+- 932, 945, 959, 973, 987, 1002, 1016, 1031,
+- 1046, 1061, 1077, 1092, 1108, 1124, 1141, 1157,
+- 1174, 1191, 1209, 1226, 1244, 1262, 1280, 1299,
+- 1318, 1337, 1357, 1376, 1396, 1417, 1437, 1458,
+- 1479, 1501, 1523, 1545, 1567, 1590, 1613, 1637,
+- 1661, 1685, 1709, 1734, 1760, 1785, 1811, 1837,
+- 1864, 1891, 1919, 1947, 1975, 2004, 2033, 2062,
+- 2093, 2123, 2154, 2185, 2217, 2249, 2282, 2315,
+- 2349, 2383, 2418, 2453, 2489, 2525, 2561, 2599,
+- 2637, 2675, 2714, 2753, 2793, 2834, 2875, 2917,
+- 2959, 3003, 3046, 3091, 3135, 3181, 3227, 3274,
+- 3322, 3370, 3419, 3469, 3520, 3571, 3623, 3675,
+- 3729, 3783, 3838, 3894, 3951, 4008, 4066, 4125,
+- 4186, 4246, 4308, 4371, 4434, 4499, 4564, 4631,
+- 4698, 4766, 4836, 4906, 4978, 5050, 5123, 5198
+-};
+-int dmpfac[] = {
+- 131072, 128272, 125533, 122852, 120229, 117661, 115148, 112689,
+- 110283, 107928, 105623, 103367, 101160, 98999, 96885, 94816,
+- 92791, 90810, 88870, 86973, 85115, 83298, 81519, 79778,
+- 78074, 76407, 74775, 73178, 71615, 70086, 68589, 67125,
+- 65691, 64288, 62915, 61572, 60257, 58970, 57711, 56478,
+- 55272, 54092, 52937, 51806, 50700, 49617, 48557, 47520,
+- 46506, 45512, 44540, 43589, 42658, 41747, 40856, 39983,
+- 39130, 38294, 37476, 36676, 35893, 35126, 34376, 33642,
+- 32923, 32220, 31532, 30859, 30200, 29555, 28924, 28306,
+- 27701, 27110, 26531, 25964, 25410, 24867, 24336, 23816,
+- 23308, 22810, 22323, 21846, 21380, 20923, 20476, 20039,
+- 19611, 19192, 18782, 18381, 17989, 17604, 17228, 16861,
+- 16500, 16148, 15803, 15466, 15135, 14812, 14496, 14186,
+- 13883, 13587, 13297, 13013, 12735, 12463, 12197, 11936,
+- 11681, 11432, 11188, 10949, 10715, 10486, 10262, 10043,
+- 9829, 9619, 9413, 9212, 9015, 8823, 8634, 8450,
+- 8270, 8093, 7920, 7751, 7585, 7423, 7265, 7110,
+- 6958, 6809, 6664, 6522, 6382, 6246, 6113, 5982,
+- 5854, 5729, 5607, 5487, 5370, 5255, 5143, 5033,
+- 4926, 4820, 4718, 4617, 4518, 4422, 4327, 4235,
+- 4144, 4056, 3969, 3884, 3801, 3720, 3641, 3563,
+- 3487, 3412, 3340, 3268, 3198, 3130, 3063, 2998,
+- 2934, 2871, 2810, 2750, 2691, 2634, 2577, 2522,
+- 2468, 2416, 2364, 2314, 2264, 2216, 2169, 2122,
+- 2077, 2032, 1989, 1947, 1905, 1864, 1824, 1786,
+- 1747, 1710, 1674, 1638, 1603, 1569, 1535, 1502,
+- 1470, 1439, 1408, 1378, 1348, 1320, 1291, 1264,
+- 1237, 1210, 1185, 1159, 1135, 1110, 1087, 1063,
+- 1041, 1018, 997, 975, 955, 934, 914, 895,
+- 876, 857, 838, 821, 803, 786, 769, 753,
+- 737, 721, 705, 690, 676, 661, 647, 633,
+- 620, 606, 593, 581, 568, 556, 544, 533
+-};
+-
+-
+-#include <math.h>
+-
+-
+-#define PI ((double)3.14159265358979323846)
+-// Simple 2-poles resonant filter
+-void CSoundFile::SetupChannelFilter(MODCHANNEL *pChn, BOOL bReset, int flt_modifier, int) const
+-//----------------------------------------------------------------------------------------
+-{
+- int cutoff = pChn->nCutOff * 2;
+- cutoff *= (flt_modifier+256) / 2;
+- cutoff /= 256;
+- if (cutoff>=255) cutoff=255;
+-
+- int resonance = pChn->nResonance;
+- if (resonance>=255) resonance=255;
+-
+- float fc = (float)filter_cutoff[cutoff];
+- float fs = (float)gdwMixingFreq;
+- float fg, fb0, fb1;
+- float d2, d, e;
+-
+- fc *= 3.14159265358979 * 2 / fs;
+- d2 = ((float)dmpfac[resonance]) / 65536.0;
+- d = (1.0 - d2) * fc;
+-
+- if (d > 2.0)
+- d = 2.0;
+-
+- d = (d2 - d) / fc;
+- e = 1.0 / (fc * fc);
+-
+- fg = 1.0 / (1 + d + e);
+- fb0 = (d + e + e) / (1 + d + e);
+- fb1 = -e / (1 + d + e);
+-
+- pChn->nFilter_A0 = (double)fg;
+- pChn->nFilter_B0 = (double)fb0;
+- pChn->nFilter_B1 = (double)fb1;
+-
+- if (bReset) {
+- pChn->nFilter_Y1 = pChn->nFilter_Y2 = 0;
+- pChn->nFilter_Y3 = pChn->nFilter_Y4 = 0;
+- }
+- pChn->dwFlags |= CHN_FILTER;
+-}
+-#endif // NO_FILTER
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/snd_fx.cxx audacious-plugins-2.5.4/src/modplug/snd_fx.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/snd_fx.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/snd_fx.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,2614 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-#ifdef MSC_VER
+-#pragma warning(disable:4244)
+-#endif
+-
+-// Tables defined in tables.cpp
+-extern BYTE ImpulseTrackerPortaVolCmd[16];
+-extern WORD S3MFineTuneTable[16];
+-extern WORD ProTrackerPeriodTable[6*12];
+-extern WORD ProTrackerTunedPeriods[15*12];
+-extern WORD FreqS3MTable[];
+-extern WORD XMPeriodTable[96+8];
+-extern UINT XMLinearTable[768];
+-extern DWORD FineLinearSlideUpTable[16];
+-extern DWORD FineLinearSlideDownTable[16];
+-extern DWORD LinearSlideUpTable[256];
+-extern DWORD LinearSlideDownTable[256];
+-extern signed char retrigTable1[16];
+-extern signed char retrigTable2[16];
+-extern short int ModRandomTable[64];
+-
+-
+-////////////////////////////////////////////////////////////
+-// Length
+-
+-DWORD CSoundFile::GetLength(BOOL bAdjust, BOOL bTotal)
+-//----------------------------------------------------
+-{
+- UINT dwElapsedTime=0, nRow=0, nCurrentPattern=0, nNextPattern=0, nPattern=Order[0];
+- UINT nMusicSpeed=m_nDefaultSpeed, nMusicTempo=m_nDefaultTempo, nNextRow=0;
+- UINT nMaxRow = 0, nMaxPattern = 0;
+- LONG nGlbVol = m_nDefaultGlobalVolume, nOldGlbVolSlide = 0;
+- BYTE samples[MAX_CHANNELS];
+- BYTE instr[MAX_CHANNELS];
+- BYTE notes[MAX_CHANNELS];
+- BYTE vols[MAX_CHANNELS];
+- BYTE oldparam[MAX_CHANNELS];
+- BYTE chnvols[MAX_CHANNELS];
+- DWORD patloop[MAX_CHANNELS];
+-
+- memset(instr, 0, sizeof(instr));
+- memset(notes, 0, sizeof(notes));
+- memset(vols, 0xFF, sizeof(vols));
+- memset(patloop, 0, sizeof(patloop));
+- memset(oldparam, 0, sizeof(oldparam));
+- memset(chnvols, 64, sizeof(chnvols));
+- memset(samples, 0, sizeof(samples));
+- for (UINT icv=0; icv<m_nChannels; icv++) chnvols[icv] = ChnSettings[icv].nVolume;
+- nMaxRow = m_nNextRow;
+- nMaxPattern = m_nNextPattern;
+- nCurrentPattern = nNextPattern = 0;
+- nPattern = Order[0];
+- nRow = nNextRow = 0;
+- for (;;)
+- {
+- UINT nSpeedCount = 0;
+- nRow = nNextRow;
+- nCurrentPattern = nNextPattern;
+-
+- // Check if pattern is valid
+- nPattern = Order[nCurrentPattern];
+- while (nPattern >= MAX_PATTERNS)
+- {
+- // End of song ?
+- if ((nPattern == 0xFF) || (nCurrentPattern >= MAX_ORDERS))
+- {
+- goto EndMod;
+- } else
+- {
+- nCurrentPattern++;
+- nPattern = (nCurrentPattern < MAX_ORDERS) ? Order[nCurrentPattern] : 0xFF;
+- }
+- nNextPattern = nCurrentPattern;
+- }
+- // Weird stuff?
+- if ((nPattern >= MAX_PATTERNS) || (!Patterns[nPattern])) break;
+- // Should never happen
+- if (nRow >= PatternSize[nPattern]) nRow = 0;
+- // Update next position
+- nNextRow = nRow + 1;
+- if (nNextRow >= PatternSize[nPattern])
+- {
+- nNextPattern = nCurrentPattern + 1;
+- nNextRow = 0;
+- }
+- if (!nRow)
+- {
+- for (UINT ipck=0; ipck<m_nChannels; ipck++) patloop[ipck] = dwElapsedTime;
+- }
+- if (!bTotal)
+- {
+- if ((nCurrentPattern > nMaxPattern) || ((nCurrentPattern == nMaxPattern) && (nRow >= nMaxRow)))
+- {
+- if (bAdjust)
+- {
+- m_nMusicSpeed = nMusicSpeed;
+- m_nMusicTempo = nMusicTempo;
+- }
+- break;
+- }
+- }
+- MODCHANNEL *pChn = Chn;
+- MODCOMMAND *p = Patterns[nPattern] + nRow * m_nChannels;
+- for (UINT nChn=0; nChn<m_nChannels; p++,pChn++, nChn++) if (*((DWORD *)p))
+- {
+- UINT command = p->command;
+- UINT param = p->param;
+- UINT note = p->note;
+- if (p->instr) { instr[nChn] = p->instr; notes[nChn] = 0; vols[nChn] = 0xFF; }
+- if ((note) && (note <= 120)) notes[nChn] = note;
+- if (p->volcmd == VOLCMD_VOLUME) { vols[nChn] = p->vol; }
+- if (command) switch (command)
+- {
+- // Position Jump
+- case CMD_POSITIONJUMP:
+- if (param <= nCurrentPattern) goto EndMod;
+- nNextPattern = param;
+- nNextRow = 0;
+- if (bAdjust)
+- {
+- pChn->nPatternLoopCount = 0;
+- pChn->nPatternLoop = 0;
+- }
+- break;
+- // Pattern Break
+- case CMD_PATTERNBREAK:
+- nNextRow = param;
+- nNextPattern = nCurrentPattern + 1;
+- if (bAdjust)
+- {
+- pChn->nPatternLoopCount = 0;
+- pChn->nPatternLoop = 0;
+- }
+- break;
+- // Set Speed
+- case CMD_SPEED:
+- if (!param) break;
+- if ((param <= 0x20) || (m_nType != MOD_TYPE_MOD))
+- {
+- if (param < 128) nMusicSpeed = param;
+- }
+- break;
+- // Set Tempo
+- case CMD_TEMPO:
+- if ((bAdjust) && (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT)))
+- {
+- if (param) pChn->nOldTempo = param; else param = pChn->nOldTempo;
+- }
+- if (param >= 0x20) nMusicTempo = param; else
+- // Tempo Slide
+- // FIXME: this is totally wrong!
+- if ((param & 0xF0) == 0x10)
+- {
+- nMusicTempo += param & 0x0F;
+- if (nMusicTempo > 255) nMusicTempo = 255;
+- } else
+- {
+- nMusicTempo -= param & 0x0F;
+- if (nMusicTempo < 32) nMusicTempo = 32;
+- }
+- break;
+- // Pattern Delay
+- case CMD_S3MCMDEX:
+- if ((param & 0xF0) == 0x60) { nSpeedCount = param & 0x0F; break; } else
+- if ((param & 0xF0) == 0xB0) { param &= 0x0F; param |= 0x60; }
+- case CMD_MODCMDEX:
+- if ((param & 0xF0) == 0xE0) nSpeedCount = (param & 0x0F) * nMusicSpeed; else
+- if ((param & 0xF0) == 0x60)
+- {
+- if (param & 0x0F) dwElapsedTime += (dwElapsedTime - patloop[nChn]) * (param & 0x0F);
+- else patloop[nChn] = dwElapsedTime;
+- }
+- break;
+- }
+- if (!bAdjust) continue;
+- switch(command)
+- {
+- // Portamento Up/Down
+- case CMD_PORTAMENTOUP:
+- case CMD_PORTAMENTODOWN:
+- if (param) pChn->nOldPortaUpDown = param;
+- break;
+- // Tone-Portamento
+- case CMD_TONEPORTAMENTO:
+- if (param) pChn->nPortamentoSlide = param << 2;
+- break;
+- // Offset
+- case CMD_OFFSET:
+- if (param) pChn->nOldOffset = param;
+- break;
+- // Volume Slide
+- case CMD_VOLUMESLIDE:
+- case CMD_TONEPORTAVOL:
+- case CMD_VIBRATOVOL:
+- if (param) pChn->nOldVolumeSlide = param;
+- break;
+- // Set Volume
+- case CMD_VOLUME:
+- vols[nChn] = param;
+- break;
+- // Global Volume
+- case CMD_GLOBALVOLUME:
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- if (param > 128) param = 128;
+- nGlbVol = param << 1;
+- break;
+- // Global Volume Slide
+- case CMD_GLOBALVOLSLIDE:
+- if (param) nOldGlbVolSlide = param; else param = nOldGlbVolSlide;
+- if (((param & 0x0F) == 0x0F) && (param & 0xF0))
+- {
+- param >>= 4;
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- nGlbVol += param << 1;
+- } else
+- if (((param & 0xF0) == 0xF0) && (param & 0x0F))
+- {
+- param = (param & 0x0F) << 1;
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- nGlbVol -= param;
+- } else
+- if (param & 0xF0)
+- {
+- param >>= 4;
+- param <<= 1;
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- nGlbVol += param * nMusicSpeed;
+- } else
+- {
+- param = (param & 0x0F) << 1;
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- nGlbVol -= param * nMusicSpeed;
+- }
+- if (nGlbVol < 0) nGlbVol = 0;
+- if (nGlbVol > 256) nGlbVol = 256;
+- break;
+- case CMD_CHANNELVOLUME:
+- if (param <= 64) chnvols[nChn] = param;
+- break;
+- case CMD_CHANNELVOLSLIDE:
+- if (param) oldparam[nChn] = param; else param = oldparam[nChn];
+- pChn->nOldChnVolSlide = param;
+- if (((param & 0x0F) == 0x0F) && (param & 0xF0))
+- {
+- param = (param >> 4) + chnvols[nChn];
+- } else
+- if (((param & 0xF0) == 0xF0) && (param & 0x0F))
+- {
+- if (chnvols[nChn] > (int)(param & 0x0F)) param = chnvols[nChn] - (param & 0x0F);
+- else param = 0;
+- } else
+- if (param & 0x0F)
+- {
+- param = (param & 0x0F) * nMusicSpeed;
+- param = (chnvols[nChn] > param) ? chnvols[nChn] - param : 0;
+- } else param = ((param & 0xF0) >> 4) * nMusicSpeed + chnvols[nChn];
+- if (param > 64) param = 64;
+- chnvols[nChn] = param;
+- break;
+- }
+- }
+- nSpeedCount += nMusicSpeed;
+- dwElapsedTime += (2500 * nSpeedCount) / nMusicTempo;
+- }
+-EndMod:
+- if ((bAdjust) && (!bTotal))
+- {
+- m_nGlobalVolume = nGlbVol;
+- m_nOldGlbVolSlide = nOldGlbVolSlide;
+- for (UINT n=0; n<m_nChannels; n++)
+- {
+- Chn[n].nGlobalVol = chnvols[n];
+- if (notes[n]) Chn[n].nNewNote = notes[n];
+- if (instr[n]) Chn[n].nNewIns = instr[n];
+- if (vols[n] != 0xFF)
+- {
+- if (vols[n] > 64) vols[n] = 64;
+- Chn[n].nVolume = vols[n] << 2;
+- }
+- }
+- }
+- return (dwElapsedTime+500) / 1000;
+-}
+-
+-
+-//////////////////////////////////////////////////////////////////////////////////////////////////
+-// Effects
+-
+-void CSoundFile::InstrumentChange(MODCHANNEL *pChn, UINT instr, BOOL bPorta, BOOL bUpdVol, BOOL bResetEnv)
+-//--------------------------------------------------------------------------------------------------------
+-{
+- BOOL bInstrumentChanged = FALSE;
+-
+- if (instr >= MAX_INSTRUMENTS) return;
+- INSTRUMENTHEADER *penv = (m_dwSongFlags & SONG_INSTRUMENTMODE) ? Headers[instr] : NULL;
+- MODINSTRUMENT *psmp = &Ins[instr];
+- UINT note = pChn->nNewNote;
+- if ((penv) && (note) && (note <= 128))
+- {
+- if (penv->NoteMap[note-1] >= 0xFE) return;
+- UINT n = penv->Keyboard[note-1];
+- psmp = ((n) && (n < MAX_SAMPLES)) ? &Ins[n] : NULL;
+- pChn->dwFlags &= ~CHN_SUSTAINLOOP; // turn off sustain
+- } else
+- if (m_dwSongFlags & SONG_INSTRUMENTMODE)
+- {
+- if (note >= 0xFE) return;
+- psmp = NULL;
+- }
+- // Update Volume
+- if (bUpdVol) pChn->nVolume = (psmp) ? psmp->nVolume : 0;
+- // bInstrumentChanged is used for IT carry-on env option
+- if (penv != pChn->pHeader)
+- {
+- bInstrumentChanged = TRUE;
+- pChn->pHeader = penv;
+- } else
+- // Special XM hack
+- if ((bPorta) && (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) && (penv)
+- && (pChn->pInstrument) && (psmp != pChn->pInstrument))
+- {
+- // FT2 doesn't change the sample in this case,
+- // but still uses the sample info from the old one (bug?)
+- return;
+- }
+- // Instrument adjust
+- pChn->nNewIns = 0;
+- if (psmp)
+- {
+- psmp->played = 1;
+- if (penv)
+- {
+- penv->played = 1;
+- pChn->nInsVol = (psmp->nGlobalVol * penv->nGlobalVol) >> 7;
+- if (penv->dwFlags & ENV_SETPANNING) pChn->nPan = penv->nPan;
+- pChn->nNNA = penv->nNNA;
+- } else
+- {
+- pChn->nInsVol = psmp->nGlobalVol;
+- }
+- if (psmp->uFlags & CHN_PANNING) pChn->nPan = psmp->nPan;
+- }
+- // Reset envelopes
+- if (bResetEnv)
+- {
+- if ((!bPorta) || (!(m_nType & MOD_TYPE_IT)) || (m_dwSongFlags & SONG_ITCOMPATMODE)
+- || (!pChn->nLength) || ((pChn->dwFlags & CHN_NOTEFADE) && (!pChn->nFadeOutVol)))
+- {
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- if ((m_nType & MOD_TYPE_IT) && (!bInstrumentChanged) && (penv) && (!(pChn->dwFlags & (CHN_KEYOFF|CHN_NOTEFADE))))
+- {
+- if (!(penv->dwFlags & ENV_VOLCARRY)) pChn->nVolEnvPosition = 0;
+- if (!(penv->dwFlags & ENV_PANCARRY)) pChn->nPanEnvPosition = 0;
+- if (!(penv->dwFlags & ENV_PITCHCARRY)) pChn->nPitchEnvPosition = 0;
+- } else
+- {
+- pChn->nVolEnvPosition = 0;
+- pChn->nPanEnvPosition = 0;
+- pChn->nPitchEnvPosition = 0;
+- }
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- } else
+- if ((penv) && (!(penv->dwFlags & ENV_VOLUME)))
+- {
+- pChn->nVolEnvPosition = 0;
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- }
+- }
+- // Invalid sample ?
+- if (!psmp)
+- {
+- pChn->pInstrument = NULL;
+- pChn->nInsVol = 0;
+- return;
+- }
+- // Tone-Portamento doesn't reset the pingpong direction flag
+- if ((bPorta) && (psmp == pChn->pInstrument))
+- {
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT)) return;
+- pChn->dwFlags &= ~(CHN_KEYOFF|CHN_NOTEFADE);
+- pChn->dwFlags = (pChn->dwFlags & (0xFFFFFF00 | CHN_PINGPONGFLAG)) | (psmp->uFlags);
+- } else
+- {
+- pChn->dwFlags &= ~(CHN_KEYOFF|CHN_NOTEFADE|CHN_VOLENV|CHN_PANENV|CHN_PITCHENV);
+- pChn->dwFlags = (pChn->dwFlags & 0xFFFFFF00) | (psmp->uFlags);
+- if (penv)
+- {
+- if (penv->dwFlags & ENV_VOLUME) pChn->dwFlags |= CHN_VOLENV;
+- if (penv->dwFlags & ENV_PANNING) pChn->dwFlags |= CHN_PANENV;
+- if (penv->dwFlags & ENV_PITCH) pChn->dwFlags |= CHN_PITCHENV;
+- if ((penv->dwFlags & ENV_PITCH) && (penv->dwFlags & ENV_FILTER))
+- {
+- if (!pChn->nCutOff) pChn->nCutOff = 0x7F;
+- }
+- if (penv->nIFC & 0x80) pChn->nCutOff = penv->nIFC & 0x7F;
+- if (penv->nIFR & 0x80) pChn->nResonance = penv->nIFR & 0x7F;
+- }
+- pChn->nVolSwing = pChn->nPanSwing = 0;
+- }
+- pChn->pInstrument = psmp;
+- pChn->nLength = psmp->nLength;
+- pChn->nLoopStart = psmp->nLoopStart;
+- pChn->nLoopEnd = psmp->nLoopEnd;
+- pChn->nC4Speed = psmp->nC4Speed;
+- pChn->pSample = psmp->pSample;
+- pChn->nTranspose = psmp->RelativeTone;
+- pChn->nFineTune = psmp->nFineTune;
+- if (pChn->dwFlags & CHN_SUSTAINLOOP)
+- {
+- pChn->nLoopStart = psmp->nSustainStart;
+- pChn->nLoopEnd = psmp->nSustainEnd;
+- pChn->dwFlags |= CHN_LOOP;
+- if (pChn->dwFlags & CHN_PINGPONGSUSTAIN) pChn->dwFlags |= CHN_PINGPONGLOOP;
+- }
+- if ((pChn->dwFlags & CHN_LOOP) && (pChn->nLoopEnd < pChn->nLength)) pChn->nLength = pChn->nLoopEnd;
+-}
+-
+-
+-void CSoundFile::NoteChange(UINT nChn, int note, BOOL bPorta, BOOL bResetEnv, BOOL bManual)
+-//-----------------------------------------------------------------------------------------
+-{
+- if (note < 1) return;
+- MODCHANNEL * const pChn = &Chn[nChn];
+- MODINSTRUMENT *pins = pChn->pInstrument;
+- INSTRUMENTHEADER *penv = (m_dwSongFlags & SONG_INSTRUMENTMODE) ? pChn->pHeader : NULL;
+- if ((penv) && (note <= 0x80))
+- {
+- UINT n = penv->Keyboard[note - 1];
+- if ((n) && (n < MAX_SAMPLES)) pins = &Ins[n];
+- note = penv->NoteMap[note-1];
+- pChn->dwFlags &= ~CHN_SUSTAINLOOP; // turn off sustain
+- }
+- // Key Off
+- if (note >= 0x80) // 0xFE or invalid note => key off
+- {
+- // technically this is "wrong", as anything besides ^^^, ===, and a valid note
+- // should cause a note fade... (oh well, it's just a quick hack anyway.)
+- if (note == 0xFD) {
+- pChn->dwFlags |= CHN_NOTEFADE;
+- return;
+- }
+-
+- // Key Off
+- KeyOff(nChn);
+- // Note Cut
+- if (note == 0xFE)
+- {
+- pChn->dwFlags |= (CHN_NOTEFADE|CHN_FASTVOLRAMP);
+- if ((!(m_nType & MOD_TYPE_IT)) || (m_dwSongFlags & SONG_INSTRUMENTMODE))
+- pChn->nVolume = 0;
+- pChn->nFadeOutVol = 0;
+- }
+- return;
+- }
+- if (!pins) return;
+- if ((!bPorta) && (m_nType & (MOD_TYPE_XM|MOD_TYPE_MED|MOD_TYPE_MT2)))
+- {
+- pChn->nTranspose = pins->RelativeTone;
+- pChn->nFineTune = pins->nFineTune;
+- }
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2|MOD_TYPE_MED)) note += pChn->nTranspose;
+- if (note < 1) note = 1;
+- if (note > 132) note = 132;
+- pChn->nNote = note;
+- if ((!bPorta) || (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))) pChn->nNewIns = 0;
+- UINT period = GetPeriodFromNote(note, pChn->nFineTune, pChn->nC4Speed);
+- if (period)
+- {
+- if ((!bPorta) || (!pChn->nPeriod)) pChn->nPeriod = period;
+- pChn->nPortamentoDest = period;
+- if ((!bPorta) || ((!pChn->nLength) && (!(m_nType & MOD_TYPE_S3M))))
+- {
+- pChn->pInstrument = pins;
+- pChn->pSample = pins->pSample;
+- pChn->nLength = pins->nLength;
+- pChn->nLoopEnd = pins->nLength;
+- pChn->nLoopStart = 0;
+- pChn->dwFlags = (pChn->dwFlags & 0xFFFFFF00) | (pins->uFlags);
+- if (pChn->dwFlags & CHN_SUSTAINLOOP)
+- {
+- pChn->nLoopStart = pins->nSustainStart;
+- pChn->nLoopEnd = pins->nSustainEnd;
+- pChn->dwFlags &= ~CHN_PINGPONGLOOP;
+- pChn->dwFlags |= CHN_LOOP;
+- if (pChn->dwFlags & CHN_PINGPONGSUSTAIN) pChn->dwFlags |= CHN_PINGPONGLOOP;
+- if (pChn->nLength > pChn->nLoopEnd) pChn->nLength = pChn->nLoopEnd;
+- } else
+- if (pChn->dwFlags & CHN_LOOP)
+- {
+- pChn->nLoopStart = pins->nLoopStart;
+- pChn->nLoopEnd = pins->nLoopEnd;
+- if (pChn->nLength > pChn->nLoopEnd) pChn->nLength = pChn->nLoopEnd;
+- }
+- pChn->nPos = 0;
+- pChn->nPosLo = 0;
+- if (pChn->nVibratoType < 4) pChn->nVibratoPos = ((m_nType & MOD_TYPE_IT) && (!(m_dwSongFlags & SONG_ITOLDEFFECTS))) ? 0x10 : 0;
+- if (pChn->nTremoloType < 4) pChn->nTremoloPos = 0;
+- }
+- if (pChn->nPos >= pChn->nLength) pChn->nPos = pChn->nLoopStart;
+- } else bPorta = FALSE;
+- if ((!bPorta) || (!(m_nType & MOD_TYPE_IT))
+- || ((pChn->dwFlags & CHN_NOTEFADE) && (!pChn->nFadeOutVol))
+- || ((m_dwSongFlags & SONG_ITCOMPATMODE) && (pChn->nRowInstr)))
+- {
+- if ((m_nType & MOD_TYPE_IT) && (pChn->dwFlags & CHN_NOTEFADE) && (!pChn->nFadeOutVol))
+- {
+- pChn->nVolEnvPosition = 0;
+- pChn->nPanEnvPosition = 0;
+- pChn->nPitchEnvPosition = 0;
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- pChn->dwFlags &= ~CHN_NOTEFADE;
+- pChn->nFadeOutVol = 65536;
+- }
+- if ((!bPorta) || (!(m_dwSongFlags & SONG_ITCOMPATMODE)) || (pChn->nRowInstr))
+- {
+- if ((!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) || (pChn->nRowInstr))
+- {
+- pChn->dwFlags &= ~CHN_NOTEFADE;
+- pChn->nFadeOutVol = 65536;
+- }
+- }
+- }
+- pChn->dwFlags &= ~(CHN_EXTRALOUD|CHN_KEYOFF);
+- // Enable Ramping
+- if (!bPorta)
+- {
+- pChn->nVUMeter = 0x100;
+- pChn->nLeftVU = pChn->nRightVU = 0xFF;
+- pChn->dwFlags &= ~CHN_FILTER;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->nRetrigCount = 0;
+- pChn->nTremorCount = 0;
+- if (bResetEnv)
+- {
+- pChn->nVolSwing = pChn->nPanSwing = 0;
+- if (penv)
+- {
+- if (!(penv->dwFlags & ENV_VOLCARRY)) pChn->nVolEnvPosition = 0;
+- if (!(penv->dwFlags & ENV_PANCARRY)) pChn->nPanEnvPosition = 0;
+- if (!(penv->dwFlags & ENV_PITCHCARRY)) pChn->nPitchEnvPosition = 0;
+- if (m_nType & MOD_TYPE_IT)
+- {
+- // Volume Swing
+- if (penv->nVolSwing)
+- {
+- /* this was wrong */
+- int d = ((LONG)penv->nVolSwing*(LONG)((rand() & 0xFF) - 0x7F)) / 256;
+- pChn->nVolSwing = (signed short)((d * pChn->nVolume + 1)/256);
+- }
+- // Pan Swing
+- if (penv->nPanSwing)
+- {
+- int d = ((LONG)penv->nPanSwing*(LONG)((rand() & 0xFF) - 0x7F)) / 128;
+- pChn->nPanSwing = (signed short)d;
+- }
+- }
+- }
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- }
+- pChn->nLeftVol = pChn->nRightVol = 0;
+- BOOL bFlt = (m_dwSongFlags & SONG_MPTFILTERMODE) ? FALSE : TRUE;
+- // Setup Initial Filter for this note
+- if (penv)
+- {
+- if (penv->nIFR & 0x80) { pChn->nResonance = penv->nIFR & 0x7F; bFlt = TRUE; }
+- if (penv->nIFC & 0x80) { pChn->nCutOff = penv->nIFC & 0x7F; bFlt = TRUE; }
+- } else
+- {
+- pChn->nVolSwing = pChn->nPanSwing = 0;
+- }
+-#ifndef NO_FILTER
+- if ((pChn->nCutOff < 0x7F) && (bFlt)) SetupChannelFilter(pChn, TRUE);
+-#endif // NO_FILTER
+- }
+- // Special case for MPT
+- if (bManual) pChn->dwFlags &= ~CHN_MUTE;
+- if (((pChn->dwFlags & CHN_MUTE) && (gdwSoundSetup & SNDMIX_MUTECHNMODE))
+- || ((pChn->pInstrument) && (pChn->pInstrument->uFlags & CHN_MUTE) && (!bManual))
+- || ((m_dwSongFlags & SONG_INSTRUMENTMODE) && (pChn->pHeader)
+- && (pChn->pHeader->dwFlags & ENV_MUTE) && (!bManual)))
+- {
+- if (!bManual) pChn->nPeriod = 0;
+- }
+-}
+-
+-
+-UINT CSoundFile::GetNNAChannel(UINT nChn)
+-//---------------------------------------------
+-{
+- MODCHANNEL *pChn = &Chn[nChn];
+- // Check for empty channel
+- MODCHANNEL *pi = &Chn[m_nChannels];
+- for (UINT i=m_nChannels; i<MAX_CHANNELS; i++, pi++) {
+- if (!pi->nLength) {
+- if (pi->dwFlags & CHN_MUTE) {
+- if (pi->dwFlags & CHN_NNAMUTE) {
+- pi->dwFlags &= ~(CHN_NNAMUTE|CHN_MUTE);
+- } else {
+- /* this channel is muted; skip */
+- continue;
+- }
+- }
+- return i;
+- }
+- }
+- if (!pChn->nFadeOutVol) return 0;
+- // All channels are used: check for lowest volume
+- UINT result = 0;
+- DWORD vol = 64*65536; // 25%
+- int envpos = 0xFFFFFF;
+- const MODCHANNEL *pj = &Chn[m_nChannels];
+- for (UINT j=m_nChannels; j<MAX_CHANNELS; j++, pj++)
+- {
+- if (!pj->nFadeOutVol) return j;
+- DWORD v = pj->nVolume;
+- if (pj->dwFlags & CHN_NOTEFADE)
+- v = v * pj->nFadeOutVol;
+- else
+- v <<= 16;
+- if (pj->dwFlags & CHN_LOOP) v >>= 1;
+- if ((v < vol) || ((v == vol) && (pj->nVolEnvPosition > envpos)))
+- {
+- envpos = pj->nVolEnvPosition;
+- vol = v;
+- result = j;
+- }
+- }
+- if (result) {
+- /* unmute new nna channel */
+- Chn[result].dwFlags &= ~(CHN_MUTE|CHN_NNAMUTE);
+- }
+- return result;
+-}
+-
+-
+-void CSoundFile::CheckNNA(UINT nChn, UINT instr, int note, BOOL bForceCut)
+-//------------------------------------------------------------------------
+-{
+- MODCHANNEL *p;
+- MODCHANNEL *pChn = &Chn[nChn];
+- INSTRUMENTHEADER *penv = (m_dwSongFlags & SONG_INSTRUMENTMODE) ? pChn->pHeader : NULL;
+- INSTRUMENTHEADER *pHeader;
+- signed char *pSample;
+- if (note > 0x80) note = 0;
+- if (note < 1) return;
+- // Always NNA cut - using
+- if ((!(m_nType & (MOD_TYPE_IT|MOD_TYPE_MT2))) || (!(m_dwSongFlags & SONG_INSTRUMENTMODE)) || (bForceCut))
+- {
+- if ((m_dwSongFlags & SONG_CPUVERYHIGH)
+- || (!pChn->nLength) || (pChn->dwFlags & CHN_MUTE)
+- || ((!pChn->nLeftVol) && (!pChn->nRightVol))) return;
+- UINT n = GetNNAChannel(nChn);
+- if (!n) return;
+- p = &Chn[n];
+- // Copy Channel
+- *p = *pChn;
+- p->dwFlags &= ~(CHN_VIBRATO|CHN_TREMOLO|CHN_PANBRELLO|CHN_PORTAMENTO);
+- p->nMasterChn = nChn+1;
+- p->nCommand = 0;
+- // Cut the note
+- p->nFadeOutVol = 0;
+- p->dwFlags |= (CHN_NOTEFADE|CHN_FASTVOLRAMP);
+- // Stop this channel
+- pChn->nLength = pChn->nPos = pChn->nPosLo = 0;
+- pChn->nROfs = pChn->nLOfs = 0;
+- pChn->nLeftVol = pChn->nRightVol = 0;
+- return;
+- }
+- if (instr >= MAX_INSTRUMENTS) instr = 0;
+- pSample = pChn->pSample;
+- pHeader = pChn->pHeader;
+- if ((instr) && (note))
+- {
+- pHeader = (m_dwSongFlags & SONG_INSTRUMENTMODE) ? Headers[instr] : NULL;
+- if (pHeader)
+- {
+- UINT n = 0;
+- if (note <= 0x80)
+- {
+- n = pHeader->Keyboard[note-1];
+- note = pHeader->NoteMap[note-1];
+- if ((n) && (n < MAX_SAMPLES)) pSample = Ins[n].pSample;
+- }
+- } else pSample = NULL;
+- }
+- if (!penv) return;
+- p = pChn;
+- for (UINT i=nChn; i<MAX_CHANNELS; p++, i++)
+- if ((i >= m_nChannels) || (p == pChn))
+- {
+- if (((p->nMasterChn == nChn+1) || (p == pChn)) && (p->pHeader))
+- {
+- BOOL bOk = FALSE;
+- // Duplicate Check Type
+- switch(p->pHeader->nDCT)
+- {
+- // Note
+- case DCT_NOTE:
+- if ((note) && ((int)p->nNote == note) && (pHeader == p->pHeader)) bOk = TRUE;
+- break;
+- // Sample
+- case DCT_SAMPLE:
+- if ((pSample) && (pSample == p->pSample)) bOk = TRUE;
+- break;
+- // Instrument
+- case DCT_INSTRUMENT:
+- if (pHeader == p->pHeader) bOk = TRUE;
+- break;
+- }
+- // Duplicate Note Action
+- if (bOk)
+- {
+- switch(p->pHeader->nDNA)
+- {
+- // Cut
+- case DNA_NOTECUT:
+- KeyOff(i);
+- p->nVolume = 0;
+- break;
+- // Note Off
+- case DNA_NOTEOFF:
+- KeyOff(i);
+- break;
+- // Note Fade
+- case DNA_NOTEFADE:
+- p->dwFlags |= CHN_NOTEFADE;
+- break;
+- }
+- if (!p->nVolume)
+- {
+- p->nFadeOutVol = 0;
+- p->dwFlags |= (CHN_NOTEFADE|CHN_FASTVOLRAMP);
+- }
+- }
+- }
+- }
+- if (pChn->dwFlags & CHN_MUTE) return;
+- // New Note Action
+- if ((pChn->nVolume) && (pChn->nLength))
+- {
+- UINT n = GetNNAChannel(nChn);
+- if (n)
+- {
+- p = &Chn[n];
+- // Copy Channel
+- *p = *pChn;
+- p->dwFlags &= ~(CHN_VIBRATO|CHN_TREMOLO|CHN_PANBRELLO|CHN_PORTAMENTO);
+- p->nMasterChn = nChn+1;
+- p->nCommand = 0;
+- // Key Off the note
+- switch(pChn->nNNA)
+- {
+- case NNA_NOTEOFF: KeyOff(n); break;
+- case NNA_NOTECUT:
+- p->nFadeOutVol = 0;
+- case NNA_NOTEFADE: p->dwFlags |= CHN_NOTEFADE; break;
+- }
+- if (!p->nVolume)
+- {
+- p->nFadeOutVol = 0;
+- p->dwFlags |= (CHN_NOTEFADE|CHN_FASTVOLRAMP);
+- }
+- // Stop this channel
+- pChn->nLength = pChn->nPos = pChn->nPosLo = 0;
+- pChn->nROfs = pChn->nLOfs = 0;
+- }
+- }
+-}
+-
+-
+-BOOL CSoundFile::ProcessEffects()
+-//-------------------------------
+-{
+- int nBreakRow = -1, nPosJump = -1, nPatLoopRow = -1;
+- MODCHANNEL *pChn = Chn;
+- for (UINT nChn=0; nChn<m_nChannels; nChn++, pChn++)
+- {
+- pChn->nCommand=0;
+-
+- UINT instr = pChn->nRowInstr;
+- UINT volcmd = pChn->nRowVolCmd;
+- UINT vol = pChn->nRowVolume;
+- UINT cmd = pChn->nRowCommand;
+- UINT param = pChn->nRowParam;
+- BOOL bPorta = ((cmd != CMD_TONEPORTAMENTO) && (cmd != CMD_TONEPORTAVOL) && (volcmd != VOLCMD_TONEPORTAMENTO)) ? FALSE : TRUE;
+- UINT nStartTick = pChn->nTickStart;
+-
+- pChn->dwFlags &= ~CHN_FASTVOLRAMP;
+- // Process special effects (note delay, pattern delay, pattern loop)
+- if (((cmd == CMD_MODCMDEX) || (cmd == CMD_S3MCMDEX)))
+- {
+- if ((!param) && (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))) param = pChn->nOldCmdEx; else pChn->nOldCmdEx = param;
+- // Note Delay ?
+- if ((param & 0xF0) == 0xD0)
+- {
+- nStartTick = param & 0x0F;
+- } else
+- if (!m_nTickCount)
+- {
+- // Pattern Loop ?
+- if ((((param & 0xF0) == 0x60) && (cmd == CMD_MODCMDEX))
+- || (((param & 0xF0) == 0xB0) && (cmd == CMD_S3MCMDEX)))
+- {
+- int nloop = PatternLoop(pChn, param & 0x0F);
+- if (nloop >= 0) nPatLoopRow = nloop;
+- } else
+- // Pattern Delay
+- if ((param & 0xF0) == 0xE0)
+- {
+- m_nPatternDelay = param & 0x0F;
+- }
+- }
+- }
+-
+- // Handles note/instrument/volume changes
+- if (m_nTickCount == nStartTick) // can be delayed by a note delay effect
+- {
+- UINT note = pChn->nRowNote;
+- if (instr) pChn->nNewIns = instr;
+- // XM: Key-Off + Sample == Note Cut
+- if (m_nType & (MOD_TYPE_MOD|MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if ((note == 0xFF) && ((!pChn->pHeader) || (!(pChn->pHeader->dwFlags & ENV_VOLUME))))
+- {
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->nVolume = 0;
+- note = instr = 0;
+- }
+- }
+- if ((!note) && (instr))
+- {
+- if (m_dwSongFlags & SONG_INSTRUMENTMODE)
+- {
+- if (pChn->pInstrument) pChn->nVolume = pChn->pInstrument->nVolume;
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->nVolEnvPosition = 0;
+- pChn->nPanEnvPosition = 0;
+- pChn->nPitchEnvPosition = 0;
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- pChn->dwFlags &= ~CHN_NOTEFADE;
+- pChn->nFadeOutVol = 65536;
+- }
+- } else
+- {
+- if (instr < MAX_SAMPLES) pChn->nVolume = Ins[instr].nVolume;
+- }
+- if (!(m_nType & MOD_TYPE_IT)) instr = 0;
+- }
+- // Invalid Instrument ?
+- if (instr >= MAX_INSTRUMENTS) instr = 0;
+- // Note Cut/Off => ignore instrument
+- if (note >= 0xFE) instr = 0;
+- if ((note) && (note <= 128)) pChn->nNewNote = note;
+- // New Note Action ? (not when paused!!!)
+- if ((note) && (note <= 128) && (!bPorta))
+- {
+- CheckNNA(nChn, instr, note, FALSE);
+- }
+- // Instrument Change ?
+- if (instr)
+- {
+- MODINSTRUMENT *psmp = pChn->pInstrument;
+- InstrumentChange(pChn, instr, bPorta, TRUE);
+- pChn->nNewIns = 0;
+- // Special IT case: portamento+note causes sample change -> ignore portamento
+- if ((m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))
+- && (psmp != pChn->pInstrument) && (note) && (note < 0x80))
+- {
+- bPorta = FALSE;
+- }
+- }
+- // New Note ?
+- if (note)
+- {
+- if ((!instr) && (pChn->nNewIns) && (note < 0x80))
+- {
+- InstrumentChange(pChn, pChn->nNewIns, bPorta, FALSE, (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? FALSE : TRUE);
+- pChn->nNewIns = 0;
+- }
+- NoteChange(nChn, note, bPorta, (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? FALSE : TRUE);
+- if ((bPorta) && (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) && (instr))
+- {
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->nVolEnvPosition = 0;
+- pChn->nPanEnvPosition = 0;
+- pChn->nPitchEnvPosition = 0;
+- pChn->nAutoVibDepth = 0;
+- pChn->nAutoVibPos = 0;
+- }
+- }
+- // Tick-0 only volume commands
+- if (volcmd == VOLCMD_VOLUME)
+- {
+- if (vol > 64) vol = 64;
+- pChn->nVolume = vol << 2;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- } else
+- if (volcmd == VOLCMD_PANNING)
+- {
+- if (vol > 64) vol = 64;
+- pChn->nPan = vol << 2;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->dwFlags &= ~CHN_SURROUND;
+- }
+- }
+-
+- // Volume Column Effect (except volume & panning)
+- if ((volcmd > VOLCMD_PANNING) && (m_nTickCount >= nStartTick))
+- {
+- if (volcmd == VOLCMD_TONEPORTAMENTO)
+- {
+- if (m_nType & MOD_TYPE_IT)
+- TonePortamento(pChn, ImpulseTrackerPortaVolCmd[vol & 0x0F]);
+- else
+- TonePortamento(pChn, vol * 16);
+- } else
+- {
+- if (vol) pChn->nOldVolParam = vol; else vol = pChn->nOldVolParam;
+- switch(volcmd)
+- {
+- case VOLCMD_VOLSLIDEUP:
+- VolumeSlide(pChn, vol << 4);
+- break;
+-
+- case VOLCMD_VOLSLIDEDOWN:
+- VolumeSlide(pChn, vol);
+- break;
+-
+- case VOLCMD_FINEVOLUP:
+- if (m_nType & MOD_TYPE_IT)
+- {
+- if (m_nTickCount == nStartTick) VolumeSlide(pChn, (vol << 4) | 0x0F);
+- } else
+- FineVolumeUp(pChn, vol);
+- break;
+-
+- case VOLCMD_FINEVOLDOWN:
+- if (m_nType & MOD_TYPE_IT)
+- {
+- if (m_nTickCount == nStartTick) VolumeSlide(pChn, 0xF0 | vol);
+- } else
+- FineVolumeDown(pChn, vol);
+- break;
+-
+- case VOLCMD_VIBRATOSPEED:
+- Vibrato(pChn, vol << 4);
+- break;
+-
+- case VOLCMD_VIBRATO:
+- Vibrato(pChn, vol);
+- break;
+-
+- case VOLCMD_PANSLIDELEFT:
+- PanningSlide(pChn, vol);
+- break;
+-
+- case VOLCMD_PANSLIDERIGHT:
+- PanningSlide(pChn, vol << 4);
+- break;
+-
+- case VOLCMD_PORTAUP:
+- PortamentoUp(pChn, vol << 2);
+- break;
+-
+- case VOLCMD_PORTADOWN:
+- PortamentoDown(pChn, vol << 2);
+- break;
+- }
+- }
+- }
+-
+- // Effects
+- if (cmd) switch (cmd)
+- {
+- // Set Volume
+- case CMD_VOLUME:
+- if (!m_nTickCount)
+- {
+- pChn->nVolume = (param < 64) ? param*4 : 256;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- for (UINT i=m_nChannels; i<MAX_CHANNELS; i++)
+- {
+- MODCHANNEL *c = &Chn[i];
+- if (c->nMasterChn == (nChn+1)) {
+- c->nVolume = pChn->nVolume;
+- c->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- }
+- }
+- break;
+-
+- // Portamento Up
+- case CMD_PORTAMENTOUP:
+- if ((!param) && (m_nType & MOD_TYPE_MOD)) break;
+- PortamentoUp(pChn, param);
+- break;
+-
+- // Portamento Down
+- case CMD_PORTAMENTODOWN:
+- if ((!param) && (m_nType & MOD_TYPE_MOD)) break;
+- PortamentoDown(pChn, param);
+- break;
+-
+- // Volume Slide
+- case CMD_VOLUMESLIDE:
+- if ((param) || (m_nType != MOD_TYPE_MOD)) VolumeSlide(pChn, param);
+- break;
+-
+- // Tone-Portamento
+- case CMD_TONEPORTAMENTO:
+- TonePortamento(pChn, param);
+- break;
+-
+- // Tone-Portamento + Volume Slide
+- case CMD_TONEPORTAVOL:
+- if ((param) || (m_nType != MOD_TYPE_MOD)) VolumeSlide(pChn, param);
+- TonePortamento(pChn, 0);
+- break;
+-
+- // Vibrato
+- case CMD_VIBRATO:
+- Vibrato(pChn, param);
+- break;
+-
+- // Vibrato + Volume Slide
+- case CMD_VIBRATOVOL:
+- if ((param) || (m_nType != MOD_TYPE_MOD)) VolumeSlide(pChn, param);
+- Vibrato(pChn, 0);
+- break;
+-
+- // Set Speed
+- case CMD_SPEED:
+- if (!m_nTickCount) SetSpeed(param);
+- break;
+-
+- // Set Tempo
+- case CMD_TEMPO:
+- if (!m_nTickCount)
+- {
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))
+- {
+- if (param) pChn->nOldTempo = param; else param = pChn->nOldTempo;
+- }
+- SetTempo(param);
+- } else {
+- param = pChn->nOldTempo; // this just got set on tick zero
+-
+- switch (param >> 4) {
+- case 0:
+- m_nMusicTempo -= param & 0xf;
+- if (m_nMusicTempo < 32)
+- m_nMusicTempo = 32;
+- break;
+- case 1:
+- m_nMusicTempo += param & 0xf;
+- if (m_nMusicTempo > 255)
+- m_nMusicTempo = 255;
+- break;
+- }
+- }
+- break;
+-
+- // Set Offset
+- case CMD_OFFSET:
+- if (m_nTickCount) break;
+- if (param) pChn->nOldOffset = param; else param = pChn->nOldOffset;
+- param <<= 8;
+- param |= (UINT)(pChn->nOldHiOffset) << 16;
+- if ((pChn->nRowNote) && (pChn->nRowNote < 0x80))
+- {
+- if (bPorta)
+- pChn->nPos = param;
+- else
+- pChn->nPos += param;
+- if (pChn->nPos >= pChn->nLength)
+- {
+- if (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)))
+- {
+- pChn->nPos = pChn->nLoopStart;
+- if ((m_dwSongFlags & SONG_ITOLDEFFECTS) && (pChn->nLength > 4))
+- {
+- pChn->nPos = pChn->nLength - 2;
+- }
+- }
+- }
+- } else
+- if ((param < pChn->nLength) && (m_nType & (MOD_TYPE_MTM|MOD_TYPE_DMF)))
+- {
+- pChn->nPos = param;
+- }
+- break;
+-
+- // Arpeggio
+- case CMD_ARPEGGIO:
+- pChn->nCommand = CMD_ARPEGGIO;
+- if ((m_nTickCount) || (!pChn->nPeriod) || (!pChn->nNote)) break;
+- if ((!param) && (!(m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT)))) break;
+- if (param) pChn->nArpeggio = param;
+- break;
+-
+- // Retrig
+- case CMD_RETRIG:
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (!(param & 0xF0)) param |= pChn->nRetrigParam & 0xF0;
+- if (!(param & 0x0F)) param |= pChn->nRetrigParam & 0x0F;
+- param |= 0x100; // increment retrig count on first row
+- }
+- // various bits of retriggery commented out here & below, reverting to old method...
+- // -Storlek 04aug07
+- // if (pChn->nRowNote && !m_nTickCount) pChn->nRetrigCount = 0;
+- if (param) pChn->nRetrigParam = (BYTE)(param & 0xFF); else param = pChn->nRetrigParam;
+- // pChn->nCommand = CMD_RETRIG;
+- RetrigNote(nChn, param);
+- break;
+-
+- // Tremor
+- case CMD_TREMOR:
+- pChn->nCommand = CMD_TREMOR;
+- if (m_nTickCount) break;
+- if (param) pChn->nTremorParam = param;
+- break;
+-
+- // Set Global Volume
+- case CMD_GLOBALVOLUME:
+- if (m_nTickCount) break;
+- if (m_nType != MOD_TYPE_IT) param <<= 1;
+- if (param > 128) param = 128;
+- m_nGlobalVolume = param << 1;
+- break;
+-
+- // Global Volume Slide
+- case CMD_GLOBALVOLSLIDE:
+- GlobalVolSlide(param);
+- break;
+-
+- // Set 8-bit Panning
+- case CMD_PANNING8:
+- if (m_nTickCount) break;
+- if (!(m_dwSongFlags & SONG_SURROUNDPAN)) pChn->dwFlags &= ~CHN_SURROUND;
+- if (m_nType & (MOD_TYPE_IT|MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- pChn->nPan = param;
+- } else
+- if (param <= 0x80)
+- {
+- pChn->nPan = param << 1;
+- } else
+- if (param == 0xA4)
+- {
+- pChn->dwFlags |= CHN_SURROUND;
+- pChn->nPan = 0x80;
+- }
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- break;
+-
+- // Panning Slide
+- case CMD_PANNINGSLIDE:
+- PanningSlide(pChn, param);
+- break;
+-
+- // Tremolo
+- case CMD_TREMOLO:
+- Tremolo(pChn, param);
+- break;
+-
+- // Fine Vibrato
+- case CMD_FINEVIBRATO:
+- FineVibrato(pChn, param);
+- break;
+-
+- // MOD/XM Exx Extended Commands
+- case CMD_MODCMDEX:
+- ExtendedMODCommands(nChn, param);
+- break;
+-
+- // S3M/IT Sxx Extended Commands
+- case CMD_S3MCMDEX:
+- ExtendedS3MCommands(nChn, param);
+- break;
+-
+- // Key Off
+- case CMD_KEYOFF:
+- if (!m_nTickCount) KeyOff(nChn);
+- break;
+-
+- // Extra-fine porta up/down
+- case CMD_XFINEPORTAUPDOWN:
+- switch(param & 0xF0)
+- {
+- case 0x10: ExtraFinePortamentoUp(pChn, param & 0x0F); break;
+- case 0x20: ExtraFinePortamentoDown(pChn, param & 0x0F); break;
+- // Modplug XM Extensions
+- case 0x50:
+- case 0x60:
+- case 0x70:
+- case 0x90:
+- case 0xA0: ExtendedS3MCommands(nChn, param); break;
+- }
+- break;
+-
+- // Set Channel Global Volume
+- case CMD_CHANNELVOLUME:
+- if (m_nTickCount) break;
+- if (param <= 64)
+- {
+- pChn->nGlobalVol = param;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- for (UINT i=m_nChannels; i<MAX_CHANNELS; i++)
+- {
+- MODCHANNEL *c = &Chn[i];
+- if (c->nMasterChn == (nChn+1)) {
+- c->nGlobalVol = param;
+- c->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- }
+- }
+- break;
+-
+- // Channel volume slide
+- case CMD_CHANNELVOLSLIDE:
+- {
+- int saw_self = 0;
+-
+- for (UINT i=m_nChannels; i<MAX_CHANNELS; i++)
+- {
+- MODCHANNEL *c = &Chn[i];
+- if (c->nMasterChn == (nChn+1)) {
+- if (c == pChn) saw_self = 1;
+- ChannelVolSlide(c, param);
+- }
+- }
+- if (!saw_self) {
+- ChannelVolSlide(pChn, param);
+- }
+- }
+-
+- break;
+-
+- // Panbrello (IT)
+- case CMD_PANBRELLO:
+- Panbrello(pChn, param);
+- break;
+-
+- // Set Envelope Position
+- case CMD_SETENVPOSITION:
+- if (!m_nTickCount)
+- {
+- pChn->nVolEnvPosition = param;
+- pChn->nPanEnvPosition = param;
+- pChn->nPitchEnvPosition = param;
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && pChn->pHeader)
+- {
+- INSTRUMENTHEADER *penv = pChn->pHeader;
+- if ((pChn->dwFlags & CHN_PANENV) && (penv->PanEnv.nNodes) && ((int)param > penv->PanEnv.Ticks[penv->PanEnv.nNodes-1]))
+- {
+- pChn->dwFlags &= ~CHN_PANENV;
+- }
+- }
+- }
+- break;
+-
+- // Position Jump
+- case CMD_POSITIONJUMP:
+- nPosJump = param;
+- break;
+-
+- // Pattern Break
+- case CMD_PATTERNBREAK:
+- nBreakRow = param;
+- break;
+-
+- // Midi Controller
+- case CMD_MIDI:
+- if (m_nTickCount) break;
+- if (param < 0x80)
+- {
+- ProcessMidiMacro(nChn, &m_MidiCfg.szMidiSFXExt[pChn->nActiveMacro << 5], param);
+- } else
+- {
+- ProcessMidiMacro(nChn, &m_MidiCfg.szMidiZXXExt[(param & 0x7F) << 5], 0);
+- }
+- break;
+- }
+- }
+-
+- // Navigation Effects
+- if (!m_nTickCount)
+- {
+- // Pattern Loop
+- if (nPatLoopRow >= 0)
+- {
+- m_nNextPattern = m_nCurrentPattern;
+- m_nNextRow = nPatLoopRow;
+- if (m_nPatternDelay) m_nNextRow++;
+- } else
+- // Pattern Break / Position Jump only if no loop running
+- if ((nBreakRow >= 0) || (nPosJump >= 0))
+- {
+- BOOL bNoLoop = FALSE;
+- if (nPosJump < 0) nPosJump = m_nCurrentPattern+1;
+- if (nBreakRow < 0) nBreakRow = 0;
+- // Modplug Tracker & ModPlugin allow backward jumps
+- #ifndef MODPLUG_FASTSOUNDLIB
+- if ((nPosJump < (int)m_nCurrentPattern)
+- || ((nPosJump == (int)m_nCurrentPattern) && (nBreakRow <= (int)m_nRow)))
+- {
+- if (!IsValidBackwardJump(m_nCurrentPattern, m_nRow, nPosJump, nBreakRow))
+- {
+- if (m_nRepeatCount)
+- {
+- if (m_nRepeatCount > 0) m_nRepeatCount--;
+- } else
+- {
+- #ifdef MODPLUG_TRACKER
+- if (gdwSoundSetup & SNDMIX_NOBACKWARDJUMPS)
+- #endif
+- // Backward jump disabled
+- bNoLoop = TRUE;
+- //reset repeat count incase there are multiple loops.
+- //(i.e. Unreal tracks)
+- m_nRepeatCount = m_nInitialRepeatCount;
+- }
+- }
+- }
+- #endif // MODPLUG_FASTSOUNDLIB
+- if (((!bNoLoop) && (nPosJump < MAX_ORDERS))
+- && ((nPosJump != (int)m_nCurrentPattern) || (nBreakRow != (int)m_nRow)))
+- {
+- if (nPosJump != (int)m_nCurrentPattern)
+- {
+- for (UINT i=0; i<m_nChannels; i++) Chn[i].nPatternLoopCount = 0;
+- }
+- m_nNextPattern = nPosJump;
+- m_nNextRow = (UINT)nBreakRow;
+- }
+- }
+- }
+- return TRUE;
+-}
+-
+-
+-////////////////////////////////////////////////////////////
+-// Channels effects
+-
+-void CSoundFile::PortamentoUp(MODCHANNEL *pChn, UINT param)
+-//---------------------------------------------------------
+-{
+- if (param) pChn->nOldPortaUpDown = param; else param = pChn->nOldPortaUpDown;
+- if (m_dwSongFlags & SONG_ITCOMPATMODE) pChn->nPortamentoSlide=param*4;
+- else pChn->nPortamentoDest=0;
+- if ((m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM)) && ((param & 0xF0) >= 0xE0))
+- {
+- if (param & 0x0F)
+- {
+- if ((param & 0xF0) == 0xF0)
+- {
+- FinePortamentoUp(pChn, param & 0x0F);
+- } else
+- if ((param & 0xF0) == 0xE0)
+- {
+- ExtraFinePortamentoUp(pChn, param & 0x0F);
+- }
+- }
+- return;
+- }
+- // Regular Slide
+- if (!(m_dwSongFlags & SONG_FIRSTTICK))
+- {
+- DoFreqSlide(pChn, -(int)(param * 4));
+- }
+-}
+-
+-
+-void CSoundFile::PortamentoDown(MODCHANNEL *pChn, UINT param)
+-//-----------------------------------------------------------
+-{
+- if (param) pChn->nOldPortaUpDown = param; else param = pChn->nOldPortaUpDown;
+- if (m_dwSongFlags & SONG_ITCOMPATMODE) pChn->nPortamentoSlide=param*4;
+- else pChn->nPortamentoDest=0;
+- if ((m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM)) && ((param & 0xF0) >= 0xE0))
+- {
+- if (param & 0x0F)
+- {
+- if ((param & 0xF0) == 0xF0)
+- {
+- FinePortamentoDown(pChn, param & 0x0F);
+- } else
+- if ((param & 0xF0) == 0xE0)
+- {
+- ExtraFinePortamentoDown(pChn, param & 0x0F);
+- }
+- }
+- return;
+- }
+- if (!(m_dwSongFlags & SONG_FIRSTTICK)) DoFreqSlide(pChn, (int)(param << 2));
+-}
+-
+-
+-void CSoundFile::FinePortamentoUp(MODCHANNEL *pChn, UINT param)
+-//-------------------------------------------------------------
+-{
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (param) pChn->nOldFinePortaUpDown = param; else param = pChn->nOldFinePortaUpDown;
+- }
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- if ((pChn->nPeriod) && (param))
+- {
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- pChn->nPeriod = _muldivr(pChn->nPeriod, LinearSlideDownTable[param & 0x0F], 65536);
+- } else
+- {
+- pChn->nPeriod -= (int)(param * 4);
+- }
+- if (pChn->nPeriod < 1) pChn->nPeriod = 1;
+- }
+- }
+-}
+-
+-
+-void CSoundFile::FinePortamentoDown(MODCHANNEL *pChn, UINT param)
+-//---------------------------------------------------------------
+-{
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (param) pChn->nOldFinePortaUpDown = param; else param = pChn->nOldFinePortaUpDown;
+- }
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- if ((pChn->nPeriod) && (param))
+- {
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- pChn->nPeriod = _muldivr(pChn->nPeriod, LinearSlideUpTable[param & 0x0F], 65536);
+- } else
+- {
+- pChn->nPeriod += (int)(param * 4);
+- }
+- if (pChn->nPeriod > 0xFFFF) pChn->nPeriod = 0xFFFF;
+- }
+- }
+-}
+-
+-
+-void CSoundFile::ExtraFinePortamentoUp(MODCHANNEL *pChn, UINT param)
+-//------------------------------------------------------------------
+-{
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (param) pChn->nOldFinePortaUpDown = param; else param = pChn->nOldFinePortaUpDown;
+- }
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- if ((pChn->nPeriod) && (param))
+- {
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- pChn->nPeriod = _muldivr(pChn->nPeriod, FineLinearSlideDownTable[param & 0x0F], 65536);
+- } else
+- {
+- pChn->nPeriod -= (int)(param);
+- }
+- if (pChn->nPeriod < 1) pChn->nPeriod = 1;
+- }
+- }
+-}
+-
+-
+-void CSoundFile::ExtraFinePortamentoDown(MODCHANNEL *pChn, UINT param)
+-//--------------------------------------------------------------------
+-{
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (param) pChn->nOldFinePortaUpDown = param; else param = pChn->nOldFinePortaUpDown;
+- }
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- if ((pChn->nPeriod) && (param))
+- {
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- pChn->nPeriod = _muldivr(pChn->nPeriod, FineLinearSlideUpTable[param & 0x0F], 65536);
+- } else
+- {
+- pChn->nPeriod += (int)(param);
+- }
+- if (pChn->nPeriod > 0xFFFF) pChn->nPeriod = 0xFFFF;
+- }
+- }
+-}
+-
+-
+-// Portamento Slide
+-void CSoundFile::TonePortamento(MODCHANNEL *pChn, UINT param)
+-//-----------------------------------------------------------
+-{
+- if (param) pChn->nPortamentoSlide = param * 4;
+- pChn->dwFlags |= CHN_PORTAMENTO;
+- if ((pChn->nPeriod) && (pChn->nPortamentoDest) && (!(m_dwSongFlags & SONG_FIRSTTICK)))
+- {
+- if (pChn->nPeriod < pChn->nPortamentoDest)
+- {
+- LONG delta = (int)pChn->nPortamentoSlide;
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- UINT n = pChn->nPortamentoSlide >> 2;
+- if (n > 255) n = 255;
+- delta = _muldivr(pChn->nPeriod, LinearSlideUpTable[n], 65536) - pChn->nPeriod;
+- if (delta < 1) delta = 1;
+- }
+- pChn->nPeriod += delta;
+- if (pChn->nPeriod > pChn->nPortamentoDest) pChn->nPeriod = pChn->nPortamentoDest;
+- } else
+- if (pChn->nPeriod > pChn->nPortamentoDest)
+- {
+- LONG delta = - (int)pChn->nPortamentoSlide;
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- UINT n = pChn->nPortamentoSlide >> 2;
+- if (n > 255) n = 255;
+- delta = _muldivr(pChn->nPeriod, LinearSlideDownTable[n], 65536) - pChn->nPeriod;
+- if (delta > -1) delta = -1;
+- }
+- pChn->nPeriod += delta;
+- if (pChn->nPeriod < pChn->nPortamentoDest) pChn->nPeriod = pChn->nPortamentoDest;
+- }
+- }
+-}
+-
+-
+-void CSoundFile::Vibrato(MODCHANNEL *p, UINT param)
+-//-------------------------------------------------
+-{
+- if (param & 0x0F) p->nVibratoDepth = (param & 0x0F) * 4;
+- if (param & 0xF0) p->nVibratoSpeed = (param >> 4) & 0x0F;
+- p->dwFlags |= CHN_VIBRATO;
+-}
+-
+-
+-void CSoundFile::FineVibrato(MODCHANNEL *p, UINT param)
+-//-----------------------------------------------------
+-{
+- if (param & 0x0F) p->nVibratoDepth = param & 0x0F;
+- if (param & 0xF0) p->nVibratoSpeed = (param >> 4) & 0x0F;
+- p->dwFlags |= CHN_VIBRATO;
+-}
+-
+-
+-void CSoundFile::Panbrello(MODCHANNEL *p, UINT param)
+-//---------------------------------------------------
+-{
+- if (param & 0x0F) p->nPanbrelloDepth = param & 0x0F;
+- if (param & 0xF0) p->nPanbrelloSpeed = (param >> 4) & 0x0F;
+- p->dwFlags |= CHN_PANBRELLO;
+-}
+-
+-
+-void CSoundFile::VolumeSlide(MODCHANNEL *pChn, UINT param)
+-//--------------------------------------------------------
+-{
+- if (param) pChn->nOldVolumeSlide = param; else param = pChn->nOldVolumeSlide;
+- LONG newvolume = pChn->nVolume;
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM|MOD_TYPE_AMF))
+- {
+- if ((param & 0x0F) == 0x0F)
+- {
+- if (param & 0xF0)
+- {
+- FineVolumeUp(pChn, (param >> 4));
+- return;
+- } else
+- {
+- if ((m_dwSongFlags & SONG_FIRSTTICK) && (!(m_dwSongFlags & SONG_FASTVOLSLIDES)))
+- {
+- newvolume -= 0x0F * 4;
+- }
+- }
+- } else
+- if ((param & 0xF0) == 0xF0)
+- {
+- if (param & 0x0F)
+- {
+- FineVolumeDown(pChn, (param & 0x0F));
+- return;
+- } else
+- {
+- if ((m_dwSongFlags & SONG_FIRSTTICK) && (!(m_dwSongFlags & SONG_FASTVOLSLIDES)))
+- {
+- newvolume += 0x0F * 4;
+- }
+- }
+- }
+- }
+- if ((!(m_dwSongFlags & SONG_FIRSTTICK)) || (m_dwSongFlags & SONG_FASTVOLSLIDES))
+- {
+- if (param & 0x0F) newvolume -= (int)((param & 0x0F) * 4);
+- else newvolume += (int)((param & 0xF0) >> 2);
+- if (m_nType & MOD_TYPE_MOD) pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- if (newvolume < 0) newvolume = 0;
+- if (newvolume > 256) newvolume = 256;
+- pChn->nVolume = newvolume;
+-}
+-
+-
+-void CSoundFile::PanningSlide(MODCHANNEL *pChn, UINT param)
+-//---------------------------------------------------------
+-{
+- LONG nPanSlide = 0;
+- if (param) pChn->nOldPanSlide = param; else param = pChn->nOldPanSlide;
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM))
+- {
+- if (((param & 0x0F) == 0x0F) && (param & 0xF0))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- param = (param & 0xF0) >> 2;
+- nPanSlide = - (int)param;
+- }
+- } else
+- if (((param & 0xF0) == 0xF0) && (param & 0x0F))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- nPanSlide = (param & 0x0F) << 2;
+- }
+- } else
+- {
+- if (!(m_dwSongFlags & SONG_FIRSTTICK))
+- {
+- if (param & 0x0F) nPanSlide = (int)((param & 0x0F) << 2);
+- else nPanSlide = -(int)((param & 0xF0) >> 2);
+- }
+- }
+- } else
+- {
+- if (!(m_dwSongFlags & SONG_FIRSTTICK))
+- {
+- if (param & 0x0F) nPanSlide = -(int)((param & 0x0F) << 2);
+- else nPanSlide = (int)((param & 0xF0) >> 2);
+- }
+- }
+- if (nPanSlide)
+- {
+- nPanSlide += pChn->nPan;
+- if (nPanSlide < 0) nPanSlide = 0;
+- if (nPanSlide > 256) nPanSlide = 256;
+- pChn->nPan = nPanSlide;
+- }
+- pChn->dwFlags &= ~CHN_SURROUND;
+-}
+-
+-
+-void CSoundFile::FineVolumeUp(MODCHANNEL *pChn, UINT param)
+-//---------------------------------------------------------
+-{
+- if (param) pChn->nOldFineVolUpDown = param; else param = pChn->nOldFineVolUpDown;
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- pChn->nVolume += param * 4;
+- if (pChn->nVolume > 256) pChn->nVolume = 256;
+- if (m_nType & MOD_TYPE_MOD) pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+-}
+-
+-
+-void CSoundFile::FineVolumeDown(MODCHANNEL *pChn, UINT param)
+-//-----------------------------------------------------------
+-{
+- if (param) pChn->nOldFineVolUpDown = param; else param = pChn->nOldFineVolUpDown;
+- if (m_dwSongFlags & SONG_FIRSTTICK)
+- {
+- pChn->nVolume -= param * 4;
+- if (pChn->nVolume < 0) pChn->nVolume = 0;
+- if (m_nType & MOD_TYPE_MOD) pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+-}
+-
+-
+-void CSoundFile::Tremolo(MODCHANNEL *p, UINT param)
+-//-------------------------------------------------
+-{
+- if (param & 0x0F) p->nTremoloDepth = (param & 0x0F) << 2;
+- if (param & 0xF0) p->nTremoloSpeed = (param >> 4) & 0x0F;
+- p->dwFlags |= CHN_TREMOLO;
+-}
+-
+-
+-void CSoundFile::ChannelVolSlide(MODCHANNEL *pChn, UINT param)
+-//------------------------------------------------------------
+-{
+- LONG nChnSlide = 0;
+- if (param) pChn->nOldChnVolSlide = param; else param = pChn->nOldChnVolSlide;
+- if (((param & 0x0F) == 0x0F) && (param & 0xF0))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK) nChnSlide = param >> 4;
+- } else
+- if (((param & 0xF0) == 0xF0) && (param & 0x0F))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK) nChnSlide = - (int)(param & 0x0F);
+- } else
+- {
+- if (!(m_dwSongFlags & SONG_FIRSTTICK))
+- {
+- if (param & 0x0F) nChnSlide = -(int)(param & 0x0F);
+- else nChnSlide = (int)((param & 0xF0) >> 4);
+- }
+- }
+- if (nChnSlide)
+- {
+- nChnSlide += pChn->nGlobalVol;
+- if (nChnSlide < 0) nChnSlide = 0;
+- if (nChnSlide > 64) nChnSlide = 64;
+- pChn->nGlobalVol = nChnSlide;
+- }
+-}
+-
+-
+-void CSoundFile::ExtendedMODCommands(UINT nChn, UINT param)
+-//---------------------------------------------------------
+-{
+- MODCHANNEL *pChn = &Chn[nChn];
+- UINT command = param & 0xF0;
+- param &= 0x0F;
+- switch(command)
+- {
+- // E0x: Set Filter
+- // E1x: Fine Portamento Up
+- case 0x10: if ((param) || (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) FinePortamentoUp(pChn, param); break;
+- // E2x: Fine Portamento Down
+- case 0x20: if ((param) || (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) FinePortamentoDown(pChn, param); break;
+- // E3x: Set Glissando Control
+- case 0x30: pChn->dwFlags &= ~CHN_GLISSANDO; if (param) pChn->dwFlags |= CHN_GLISSANDO; break;
+- // E4x: Set Vibrato WaveForm
+- case 0x40: pChn->nVibratoType = param & 0x07; break;
+- // E5x: Set FineTune
+- case 0x50: if (m_nTickCount) break;
+- pChn->nC4Speed = S3MFineTuneTable[param];
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- pChn->nFineTune = param*2;
+- else
+- pChn->nFineTune = MOD2XMFineTune(param);
+- if (pChn->nPeriod) pChn->nPeriod = GetPeriodFromNote(pChn->nNote, pChn->nFineTune, pChn->nC4Speed);
+- break;
+- // E6x: Pattern Loop
+- // E7x: Set Tremolo WaveForm
+- case 0x70: pChn->nTremoloType = param & 0x07; break;
+- // E8x: Set 4-bit Panning
+- case 0x80: if (!m_nTickCount) { pChn->nPan = (param << 4) + 8; pChn->dwFlags |= CHN_FASTVOLRAMP; } break;
+- // E9x: Retrig
+- case 0x90: RetrigNote(nChn, param); break;
+- // EAx: Fine Volume Up
+- case 0xA0: if ((param) || (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) FineVolumeUp(pChn, param); break;
+- // EBx: Fine Volume Down
+- case 0xB0: if ((param) || (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) FineVolumeDown(pChn, param); break;
+- // ECx: Note Cut
+- case 0xC0: NoteCut(nChn, param); break;
+- // EDx: Note Delay
+- // EEx: Pattern Delay
+- // EFx: MOD: Invert Loop, XM: Set Active Midi Macro
+- case 0xF0: pChn->nActiveMacro = param; break;
+- }
+-}
+-
+-
+-void CSoundFile::ExtendedS3MCommands(UINT nChn, UINT param)
+-//---------------------------------------------------------
+-{
+- MODCHANNEL *pChn = &Chn[nChn];
+- UINT command = param & 0xF0;
+- param &= 0x0F;
+- switch(command)
+- {
+- // S0x: Set Filter
+- // S1x: Set Glissando Control
+- case 0x10: pChn->dwFlags &= ~CHN_GLISSANDO; if (param) pChn->dwFlags |= CHN_GLISSANDO; break;
+- // S2x: Set FineTune
+- case 0x20: if (m_nTickCount) break;
+- pChn->nC4Speed = S3MFineTuneTable[param & 0x0F];
+- pChn->nFineTune = MOD2XMFineTune(param);
+- if (pChn->nPeriod) pChn->nPeriod = GetPeriodFromNote(pChn->nNote, pChn->nFineTune, pChn->nC4Speed);
+- break;
+- // S3x: Set Vibrato WaveForm
+- case 0x30: pChn->nVibratoType = param & 0x07; break;
+- // S4x: Set Tremolo WaveForm
+- case 0x40: pChn->nTremoloType = param & 0x07; break;
+- // S5x: Set Panbrello WaveForm
+- case 0x50: pChn->nPanbrelloType = param & 0x07; break;
+- // S6x: Pattern Delay for x frames
+- case 0x60: m_nFrameDelay = param; break;
+- // S7x: Envelope Control
+- case 0x70: if (m_nTickCount) break;
+- switch(param)
+- {
+- case 0:
+- case 1:
+- case 2:
+- {
+- MODCHANNEL *bkp = &Chn[m_nChannels];
+- for (UINT i=m_nChannels; i<MAX_CHANNELS; i++, bkp++)
+- {
+- if (bkp->nMasterChn == nChn+1)
+- {
+- if (param == 1) KeyOff(i); else
+- if (param == 2) bkp->dwFlags |= CHN_NOTEFADE; else
+- { bkp->dwFlags |= CHN_NOTEFADE; bkp->nFadeOutVol = 0; }
+- }
+- }
+- }
+- break;
+- case 3: pChn->nNNA = NNA_NOTECUT; break;
+- case 4: pChn->nNNA = NNA_CONTINUE; break;
+- case 5: pChn->nNNA = NNA_NOTEOFF; break;
+- case 6: pChn->nNNA = NNA_NOTEFADE; break;
+- case 7: pChn->dwFlags &= ~CHN_VOLENV; break;
+- case 8: pChn->dwFlags |= CHN_VOLENV; break;
+- case 9: pChn->dwFlags &= ~CHN_PANENV; break;
+- case 10: pChn->dwFlags |= CHN_PANENV; break;
+- case 11: pChn->dwFlags &= ~CHN_PITCHENV; break;
+- case 12: pChn->dwFlags |= CHN_PITCHENV; break;
+- }
+- break;
+- // S8x: Set 4-bit Panning
+- case 0x80:
+- pChn->dwFlags &= ~CHN_SURROUND;
+- if (!m_nTickCount) {
+- pChn->nPan = (param << 4) + 8;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- break;
+- // S9x: Set Surround
+- case 0x90: ExtendedChannelEffect(pChn, param & 0x0F); break;
+- // SAx: Set 64k Offset
+- case 0xA0: if (!m_nTickCount)
+- {
+- if (m_nType & MOD_TYPE_S3M) {
+- pChn->nPan = ((param ^ 8) << 4) + 8;
+- pChn->dwFlags &= ~CHN_SURROUND;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- } else {
+- pChn->nOldHiOffset = param;
+- if ((pChn->nRowNote) && (pChn->nRowNote < 0x80))
+- {
+- DWORD pos = param << 16;
+- if (pos < pChn->nLength) pChn->nPos = pos;
+- }
+- }
+- }
+- break;
+- // SBx: Pattern Loop
+- // SCx: Note Cut
+- case 0xC0: NoteCut(nChn, param); break;
+- // SDx: Note Delay
+- // case 0xD0: break;
+- // SEx: Pattern Delay for x rows
+- // SFx: S3M: Funk Repeat, IT: Set Active Midi Macro
+- case 0xF0: pChn->nActiveMacro = param; break;
+- }
+-}
+-
+-
+-void CSoundFile::ExtendedChannelEffect(MODCHANNEL *pChn, UINT param)
+-//------------------------------------------------------------------
+-{
+- // S9x and X9x commands (S3M/XM/IT only)
+- if (m_nTickCount) return;
+- switch(param & 0x0F)
+- {
+- // S91: Surround On
+- case 0x01: pChn->dwFlags |= CHN_SURROUND; pChn->nPan = 128; break;
+- ////////////////////////////////////////////////////////////
+- // Modplug Extensions
+- // S90: Surround Off
+- case 0x00: pChn->dwFlags &= ~CHN_SURROUND; break;
+- // S98: Reverb Off
+- case 0x08:
+- pChn->dwFlags &= ~CHN_REVERB;
+- pChn->dwFlags |= CHN_NOREVERB;
+- break;
+- // S99: Reverb On
+- case 0x09:
+- pChn->dwFlags &= ~CHN_NOREVERB;
+- pChn->dwFlags |= CHN_REVERB;
+- break;
+- // S9A: 2-Channels surround mode
+- case 0x0A:
+- m_dwSongFlags &= ~SONG_SURROUNDPAN;
+- break;
+- // S9B: 4-Channels surround mode
+- case 0x0B:
+- m_dwSongFlags |= SONG_SURROUNDPAN;
+- break;
+- // S9C: IT Filter Mode
+- case 0x0C:
+- m_dwSongFlags &= ~SONG_MPTFILTERMODE;
+- break;
+- // S9D: MPT Filter Mode
+- case 0x0D:
+- m_dwSongFlags |= SONG_MPTFILTERMODE;
+- break;
+- // S9E: Go forward
+- case 0x0E:
+- pChn->dwFlags &= ~(CHN_PINGPONGFLAG);
+- break;
+- // S9F: Go backward (set position at the end for non-looping samples)
+- case 0x0F:
+- if ((!(pChn->dwFlags & CHN_LOOP)) && (!pChn->nPos) && (pChn->nLength))
+- {
+- pChn->nPos = pChn->nLength - 1;
+- pChn->nPosLo = 0xFFFF;
+- }
+- pChn->dwFlags |= CHN_PINGPONGFLAG;
+- break;
+- }
+-}
+-
+-// this is all brisby
+-void CSoundFile::MidiSend(unsigned char *data, unsigned int len, UINT nChn, int fake)
+-{
+- MODCHANNEL *pChn = &Chn[nChn];
+- int oldcutoff;
+-
+- if (len > 2 && data[0] == 0xF0 && data[1] == 0xF0) {
+- /* impulse tracker filter control (mfg. 0xF0) */
+- if (len == 5) {
+- switch (data[2]) {
+- case 0x00: /* set cutoff */
+- oldcutoff = pChn->nCutOff;
+- if (data[3] < 0x80) pChn->nCutOff = data[3];
+-#ifndef NO_FILTER
+- oldcutoff -= pChn->nCutOff;
+-
+- if (oldcutoff < 0) oldcutoff = -oldcutoff;
+- if ((pChn->nVolume > 0) || (oldcutoff < 0x10)
+- || (!(pChn->dwFlags & CHN_FILTER))
+- || (!(pChn->nLeftVol|pChn->nRightVol)))
+- SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER)
+- ? FALSE : TRUE);
+-#endif // NO_FILTER
+- break;
+- case 0x01: /* set resonance */
+- if (data[3] < 0x80) pChn->nResonance = data[3];
+-#ifndef NO_FILTER
+- SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+-#endif // NO_FILTER
+- break;
+- };
+- }
+- }
+-
+- if (!fake && _midi_out_raw) {
+- /* okay, this is kind of how it works.
+- we pass m_nBufferCount as here because while
+- 1000 * ((8((buffer_size/2) - m_nBufferCount)) / sample_rate)
+- is the number of msec we need to delay by, libmodplug simply doesn't know
+- what the buffer size is at this point so m_nBufferCount simply has no
+- frame of reference.
+-
+- fortunately, schism does and can complete this (tags: _schism_midi_out_raw )
+-
+- */
+- _midi_out_raw(data, len, m_nBufferCount);
+- }
+-}
+-
+-static int _was_complete_midi(unsigned char *q, unsigned int len, int nextc)
+-{
+- if (len == 0) return 0;
+- if (*q == 0xF0) return (q[len-1] == 0xF7 ? 1 : 0);
+- return ((nextc & 0x80) ? 1 : 0);
+-}
+-
+-void CSoundFile::ProcessMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param,
+- UINT note, UINT velocity, UINT use_instr)
+-//---------------------------------------------------------------------------
+-{
+-/* this was all wrong. -mrsb */
+- MODCHANNEL *pChn = &Chn[nChn];
+- INSTRUMENTHEADER *penv = (m_dwSongFlags & SONG_INSTRUMENTMODE)
+- ? Headers[use_instr
+- ?use_instr
+- :pChn->nLastInstr]
+- : NULL;
+- unsigned char outbuffer[64];
+- unsigned char cx;
+- int mc, fake = 0;
+- int saw_c;
+- int i, j, x;
+-
+- saw_c = 0;
+- if (!penv || penv->nMidiChannel == 0) {
+- /* okay, there _IS_ no real midi channel. forget this for now... */
+- mc = 15;
+- fake = 1;
+-
+- } else if (penv->nMidiChannel > 16) {
+- mc = (nChn-1) % 16;
+- } else {
+- mc = (penv->nMidiChannel-1);
+- }
+-
+- for (i = j = x = 0, cx =0; i <= 32 && pszMidiMacro[i]; i++) {
+- int c, cw;
+- if (pszMidiMacro[i] >= '0' && pszMidiMacro[i] <= '9') {
+- c = pszMidiMacro[i] - '0';
+- cw = 1;
+- } else if (pszMidiMacro[i] >= 'A' && pszMidiMacro[i] <= 'F') {
+- c = (pszMidiMacro[i] - 'A') + 10;
+- cw = 1;
+- } else if (pszMidiMacro[i] == 'c') {
+- c = mc;
+- cw = 1;
+- saw_c = 1;
+- } else if (pszMidiMacro[i] == 'n') {
+- c = (note-1);
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'v') {
+- c = velocity;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'u') {
+- c = (pChn->nVolume >> 1);
+- if (c > 127) c = 127;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'x') {
+- c = pChn->nPan;
+- if (c > 127) c = 127;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'y') {
+- c = pChn->nRealPan;
+- if (c > 127) c = 127;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'a') {
+- if (!penv)
+- c = 0;
+- else
+- c = (penv->wMidiBank >> 7) & 127;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'b') {
+- if (!penv)
+- c = 0;
+- else
+- c = penv->wMidiBank & 127;
+- cw = 2;
+- } else if (pszMidiMacro[i] == 'z' || pszMidiMacro[i] == 'p') {
+- c = param & 0x7F;
+- cw = 2;
+- } else {
+- continue;
+- }
+- if (j == 0 && cw == 1) {
+- cx = c;
+- j = 1;
+- continue;
+- } else if (j == 1 && cw == 1) {
+- cx = (cx << 4) | c;
+- j = 0;
+- } else if (j == 0) {
+- cx = c;
+- } else if (j == 1) {
+- outbuffer[x] = cx;
+- x++;
+-
+- cx = c;
+- j = 0;
+- }
+- // start of midi message
+- if (_was_complete_midi(outbuffer,x,cx)) {
+- MidiSend(outbuffer, x, nChn,saw_c && fake);
+- x = 0;
+- }
+- outbuffer[x] = cx;
+- x++;
+- }
+- if (j == 1) {
+- outbuffer[x] = cx;
+- x++;
+- }
+- if (x) {
+- // terminate sysex
+- if (!_was_complete_midi(outbuffer,x,0xFF)) {
+- if (*outbuffer == 0xF0) {
+- outbuffer[x] = 0xF7;
+- x++;
+- }
+- }
+- MidiSend(outbuffer, x, nChn,saw_c && fake);
+- }
+-}
+-
+-
+-void CSoundFile::RetrigNote(UINT nChn, UINT param)
+-//------------------------------------------------
+-{
+- // Retrig: bit 8 is set if it's the new XM retrig
+- MODCHANNEL *pChn = &Chn[nChn];
+- UINT nRetrigSpeed = param & 0x0F;
+- UINT nRetrigCount = pChn->nRetrigCount;
+- BOOL bDoRetrig = FALSE;
+-
+- if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))
+- {
+- if (!nRetrigSpeed) nRetrigSpeed = 1;
+- if (m_nMusicSpeed < nRetrigSpeed) {
+- if (nRetrigCount >= nRetrigSpeed) {
+- bDoRetrig = TRUE;
+- nRetrigCount = 0;
+- } else {
+- nRetrigCount++;
+- }
+- } else {
+- if ((nRetrigCount) && (!(nRetrigCount % nRetrigSpeed))) bDoRetrig = TRUE;
+- nRetrigCount++;
+- }
+- } else {
+- UINT realspeed = nRetrigSpeed;
+- if ((param & 0x100) && (pChn->nRowVolCmd == VOLCMD_VOLUME) && (pChn->nRowParam & 0xF0)) realspeed++;
+- if ((m_nTickCount) || (param & 0x100))
+- {
+- if (!realspeed) realspeed = 1;
+- if ((!(param & 0x100)) && (m_nMusicSpeed) && (!(m_nTickCount % realspeed))) bDoRetrig = TRUE;
+- nRetrigCount++;
+- } else if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) nRetrigCount = 0;
+- if (nRetrigCount >= realspeed)
+- {
+- if ((m_nTickCount) || ((param & 0x100) && (!pChn->nRowNote))) bDoRetrig = TRUE;
+- }
+- }
+- if (bDoRetrig)
+- {
+- UINT dv = (param >> 4) & 0x0F;
+- if (dv)
+- {
+- int vol = pChn->nVolume;
+- if (retrigTable1[dv])
+- vol = (vol * retrigTable1[dv]) >> 4;
+- else
+- vol += ((int)retrigTable2[dv]) << 2;
+- if (vol < 0) vol = 0;
+- if (vol > 256) vol = 256;
+- pChn->nVolume = vol;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- UINT nNote = pChn->nNewNote;
+- LONG nOldPeriod = pChn->nPeriod;
+- if ((nNote) && (nNote <= 120) && (pChn->nLength)) CheckNNA(nChn, 0, nNote, TRUE);
+- BOOL bResetEnv = FALSE;
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if ((pChn->nRowInstr) && (param < 0x100)) { InstrumentChange(pChn, pChn->nRowInstr, FALSE, FALSE); bResetEnv = TRUE; }
+- if (param < 0x100) bResetEnv = TRUE;
+- }
+- NoteChange(nChn, nNote, FALSE, bResetEnv);
+- if ((m_nType & MOD_TYPE_IT) && (!pChn->nRowNote) && (nOldPeriod)) pChn->nPeriod = nOldPeriod;
+- if (!(m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT))) nRetrigCount = 0;
+- }
+- pChn->nRetrigCount = (BYTE)nRetrigCount;
+-}
+-
+-
+-void CSoundFile::DoFreqSlide(MODCHANNEL *pChn, LONG nFreqSlide)
+-//-------------------------------------------------------------
+-{
+- // IT Linear slides
+- if (!pChn->nPeriod) return;
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))))
+- {
+- if (nFreqSlide < 0)
+- {
+- UINT n = (- nFreqSlide) >> 2;
+- if (n > 255) n = 255;
+- pChn->nPeriod = _muldivr(pChn->nPeriod, LinearSlideDownTable[n], 65536);
+- } else
+- {
+- UINT n = (nFreqSlide) >> 2;
+-
+- if (n > 255) n = 255;
+- pChn->nPeriod = _muldivr(pChn->nPeriod, LinearSlideUpTable[n], 65536);
+- }
+- } else
+- {
+- pChn->nPeriod += nFreqSlide;
+- }
+- if (pChn->nPeriod < 1)
+- {
+- pChn->nPeriod = 1;
+- if (m_nType & MOD_TYPE_IT)
+- {
+- pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nFadeOutVol = 0;
+- }
+- }
+-}
+-
+-
+-void CSoundFile::NoteCut(UINT nChn, UINT nTick)
+-//---------------------------------------------
+-{
+- if (m_nTickCount == nTick)
+- {
+- MODCHANNEL *pChn = &Chn[nChn];
+- // if (m_dwSongFlags & SONG_INSTRUMENTMODE) KeyOff(pChn); ?
+- pChn->nVolume = 0;
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- pChn->nLength = 0;
+- }
+-}
+-
+-
+-void CSoundFile::KeyOff(UINT nChn)
+-//--------------------------------
+-{
+- MODCHANNEL *pChn = &Chn[nChn];
+- BOOL bKeyOn = (pChn->dwFlags & CHN_KEYOFF) ? FALSE : TRUE;
+- pChn->dwFlags |= CHN_KEYOFF;
+- //if ((!pChn->pHeader) || (!(pChn->dwFlags & CHN_VOLENV)))
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && (pChn->pHeader) && (!(pChn->dwFlags & CHN_VOLENV)))
+- {
+- pChn->dwFlags |= CHN_NOTEFADE;
+- }
+- if (!pChn->nLength) return;
+- if ((pChn->dwFlags & CHN_SUSTAINLOOP) && (pChn->pInstrument) && (bKeyOn))
+- {
+- MODINSTRUMENT *psmp = pChn->pInstrument;
+- if (psmp->uFlags & CHN_LOOP)
+- {
+- if (psmp->uFlags & CHN_PINGPONGLOOP)
+- pChn->dwFlags |= CHN_PINGPONGLOOP;
+- else
+- pChn->dwFlags &= ~(CHN_PINGPONGLOOP|CHN_PINGPONGFLAG);
+- pChn->dwFlags |= CHN_LOOP;
+- pChn->nLength = psmp->nLength;
+- pChn->nLoopStart = psmp->nLoopStart;
+- pChn->nLoopEnd = psmp->nLoopEnd;
+- if (pChn->nLength > pChn->nLoopEnd) pChn->nLength = pChn->nLoopEnd;
+- } else
+- {
+- pChn->dwFlags &= ~(CHN_LOOP|CHN_PINGPONGLOOP|CHN_PINGPONGFLAG);
+- pChn->nLength = psmp->nLength;
+- }
+- }
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && pChn->pHeader)
+- {
+- INSTRUMENTHEADER *penv = pChn->pHeader;
+- if (((penv->dwFlags & ENV_VOLLOOP) || (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))) && (penv->nFadeOut))
+- pChn->dwFlags |= CHN_NOTEFADE;
+- }
+-}
+-
+-
+-//////////////////////////////////////////////////////////
+-// CSoundFile: Global Effects
+-
+-
+-void CSoundFile::SetSpeed(UINT param)
+-//-----------------------------------
+-{
+- if (param)
+- m_nMusicSpeed = param;
+-}
+-
+-
+-void CSoundFile::SetTempo(UINT param)
+-//-----------------------------------
+-{
+- if (param < 0x20)
+- {
+-#if 0 // argh... this is completely wrong
+- // Tempo Slide
+- if ((param & 0xF0) == 0x10)
+- {
+- m_nMusicTempo += (param & 0x0F) * 2;
+- if (m_nMusicTempo > 255) m_nMusicTempo = 255;
+- } else
+- {
+- m_nMusicTempo -= (param & 0x0F) * 2;
+- if ((LONG)m_nMusicTempo < 32) m_nMusicTempo = 32;
+- }
+-#endif
+- } else
+- {
+- m_nMusicTempo = param;
+- }
+-}
+-
+-
+-int CSoundFile::PatternLoop(MODCHANNEL *pChn, UINT param)
+-//-------------------------------------------------------
+-{
+- if (param)
+- {
+- if (pChn->nPatternLoopCount)
+- {
+- pChn->nPatternLoopCount--;
+- if (!pChn->nPatternLoopCount) {
+- // this should get rid of that nasty infinite loop for cases like
+- // ... .. .. SB0
+- // ... .. .. SB1
+- // ... .. .. SB1
+- // it still doesn't work right in a few strange cases, but oh well :P
+- pChn->nPatternLoop = m_nRow + 1;
+- return -1;
+- }
+- } else
+- {
+- // hmm. the pattern loop shouldn't care about
+- // other channels at all... i'm not really
+- // sure what this code is doing :/
+-#if 0
+- MODCHANNEL *p = Chn;
+- for (UINT i=0; i<m_nChannels; i++, p++) if (p != pChn)
+- {
+- // Loop already done
+- if (p->nPatternLoopCount) return -1;
+- }
+-#endif
+- pChn->nPatternLoopCount = param;
+- }
+- return pChn->nPatternLoop;
+- } else
+- {
+- pChn->nPatternLoop = m_nRow;
+- }
+- return -1;
+-}
+-
+-
+-void CSoundFile::GlobalVolSlide(UINT param)
+-//-----------------------------------------
+-{
+- LONG nGlbSlide = 0;
+- if (param) m_nOldGlbVolSlide = param; else param = m_nOldGlbVolSlide;
+- if (((param & 0x0F) == 0x0F) && (param & 0xF0))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK) nGlbSlide = (param >> 4) * 2;
+- } else
+- if (((param & 0xF0) == 0xF0) && (param & 0x0F))
+- {
+- if (m_dwSongFlags & SONG_FIRSTTICK) nGlbSlide = - (int)((param & 0x0F) * 2);
+- } else
+- {
+- if (!(m_dwSongFlags & SONG_FIRSTTICK))
+- {
+- if (param & 0xF0) nGlbSlide = (int)((param & 0xF0) >> 4) * 2;
+- else nGlbSlide = -(int)((param & 0x0F) * 2);
+- }
+- }
+- if (nGlbSlide)
+- {
+- if (m_nType != MOD_TYPE_IT) nGlbSlide *= 2;
+- nGlbSlide += m_nGlobalVolume;
+- if (nGlbSlide < 0) nGlbSlide = 0;
+- if (nGlbSlide > 256) nGlbSlide = 256;
+- m_nGlobalVolume = nGlbSlide;
+- }
+-}
+-
+-
+-DWORD CSoundFile::IsSongFinished(UINT nStartOrder, UINT nStartRow) const
+-//----------------------------------------------------------------------
+-{
+- UINT nOrd;
+-
+- for (nOrd=nStartOrder; nOrd<MAX_ORDERS; nOrd++)
+- {
+- UINT nPat = Order[nOrd];
+- if (nPat != 0xFE)
+- {
+- MODCOMMAND *p;
+-
+- if (nPat >= MAX_PATTERNS) break;
+- p = Patterns[nPat];
+- if (p)
+- {
+- UINT len = PatternSize[nPat] * m_nChannels;
+- UINT pos = (nOrd == nStartOrder) ? nStartRow : 0;
+- pos *= m_nChannels;
+- while (pos < len)
+- {
+- UINT cmd;
+- if ((p[pos].note) || (p[pos].volcmd)) return 0;
+- cmd = p[pos].command;
+- if (cmd == CMD_MODCMDEX)
+- {
+- UINT cmdex = p[pos].param & 0xF0;
+- if ((!cmdex) || (cmdex == 0x60) || (cmdex == 0xE0) || (cmdex == 0xF0)) cmd = 0;
+- }
+- if ((cmd) && (cmd != CMD_SPEED) && (cmd != CMD_TEMPO)) return 0;
+- pos++;
+- }
+- }
+- }
+- }
+- return (nOrd < MAX_ORDERS) ? nOrd : MAX_ORDERS-1;
+-}
+-
+-
+-BOOL CSoundFile::IsValidBackwardJump(UINT nStartOrder, UINT nStartRow, UINT nJumpOrder, UINT nJumpRow) const
+-//----------------------------------------------------------------------------------------------------------
+-{
+- while ((nJumpOrder < MAX_PATTERNS) && (Order[nJumpOrder] == 0xFE)) nJumpOrder++;
+- if ((nStartOrder >= MAX_PATTERNS) || (nJumpOrder >= MAX_PATTERNS)) return FALSE;
+- // Treat only case with jumps in the same pattern
+- if (nJumpOrder > nStartOrder) return TRUE;
+- if ((nJumpOrder < nStartOrder) || (nJumpRow >= PatternSize[nStartOrder])
+- || (!Patterns[nStartOrder]) || (nStartRow >= 256) || (nJumpRow >= 256)) return FALSE;
+- // See if the pattern is being played backward
+- BYTE row_hist[256];
+- memset(row_hist, 0, sizeof(row_hist));
+- UINT nRows = PatternSize[nStartOrder], row = nJumpRow;
+- if (nRows > 256) nRows = 256;
+- row_hist[nStartRow] = TRUE;
+- while ((row < 256) && (!row_hist[row]))
+- {
+- if (row >= nRows) return TRUE;
+- row_hist[row] = TRUE;
+- MODCOMMAND *p = Patterns[nStartOrder] + row * m_nChannels;
+- row++;
+- int breakrow = -1, posjump = 0;
+- for (UINT i=0; i<m_nChannels; i++, p++)
+- {
+- if (p->command == CMD_POSITIONJUMP)
+- {
+- if (p->param < nStartOrder) return FALSE;
+- if (p->param > nStartOrder) return TRUE;
+- posjump = TRUE;
+- } else
+- if (p->command == CMD_PATTERNBREAK)
+- {
+- breakrow = p->param;
+- }
+- }
+- if (breakrow >= 0)
+- {
+- if (!posjump) return TRUE;
+- row = breakrow;
+- }
+- if (row >= nRows) return TRUE;
+- }
+- return FALSE;
+-}
+-
+-
+-//////////////////////////////////////////////////////
+-// Note/Period/Frequency functions
+-
+-UINT CSoundFile::GetNoteFromPeriod(UINT period) const
+-//---------------------------------------------------
+-{
+- if (!period) return 0;
+- if (m_nType & (MOD_TYPE_MED|MOD_TYPE_MOD|MOD_TYPE_MTM|MOD_TYPE_669|MOD_TYPE_OKT|MOD_TYPE_AMF0))
+- {
+- period >>= 2;
+- for (UINT i=0; i<6*12; i++)
+- {
+- if (period >= ProTrackerPeriodTable[i])
+- {
+- if ((period != ProTrackerPeriodTable[i]) && (i))
+- {
+- UINT p1 = ProTrackerPeriodTable[i-1];
+- UINT p2 = ProTrackerPeriodTable[i];
+- if (p1 - period < (period - p2)) return i+36;
+- }
+- return i+1+36;
+- }
+- }
+- return 6*12+36;
+- } else
+- {
+- for (UINT i=1; i<120; i++)
+- {
+- LONG n = GetPeriodFromNote(i, 0, 0);
+- if ((n > 0) && (n <= (LONG)period)) return i;
+- }
+- return 120;
+- }
+-}
+-
+-// this last param was nC4Speed
+-UINT CSoundFile::GetLinearPeriodFromNote(UINT note, int nFineTune, UINT) const
+-{
+- if ((!note) || (note > 0xF0)) return 0;
+- if (m_nType & (MOD_TYPE_IT|MOD_TYPE_S3M|MOD_TYPE_STM|MOD_TYPE_MDL|MOD_TYPE_ULT|MOD_TYPE_WAV
+- |MOD_TYPE_FAR|MOD_TYPE_DMF|MOD_TYPE_PTM|MOD_TYPE_AMS|MOD_TYPE_DBM|MOD_TYPE_AMF|MOD_TYPE_PSM))
+- {
+- note--;
+- return (FreqS3MTable[note % 12] << 5) >> (note / 12);
+- } else
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (note < 13) note = 13;
+- note -= 13;
+- LONG l = ((120 - note) << 6) - (nFineTune / 2);
+- if (l < 1) l = 1;
+- return (UINT)l;
+- } else
+- {
+- note--;
+- nFineTune = XM2MODFineTune(nFineTune);
+- if ((nFineTune) || (note < 36) || (note >= 36+6*12))
+- return (ProTrackerTunedPeriods[nFineTune*12 + note % 12] << 5) >> (note / 12);
+- else
+- return (ProTrackerPeriodTable[note-36] << 2);
+- }
+-}
+-
+-
+-UINT CSoundFile::GetPeriodFromNote(UINT note, int nFineTune, UINT nC4Speed) const
+-//-------------------------------------------------------------------------------
+-{
+- if ((!note) || (note > 0xF0)) return 0;
+- if (m_nType & (MOD_TYPE_IT|MOD_TYPE_S3M|MOD_TYPE_STM|MOD_TYPE_MDL|MOD_TYPE_ULT|MOD_TYPE_WAV
+- |MOD_TYPE_FAR|MOD_TYPE_DMF|MOD_TYPE_PTM|MOD_TYPE_AMS|MOD_TYPE_DBM|MOD_TYPE_AMF|MOD_TYPE_PSM))
+- {
+- note--;
+- if (m_dwSongFlags & SONG_LINEARSLIDES)
+- {
+- return (FreqS3MTable[note % 12] << 5) >> (note / 12);
+- } else
+- {
+- if (!nC4Speed) nC4Speed = 8363;
+- return _muldiv(8363, (FreqS3MTable[note % 12] << 5), nC4Speed << (note / 12));
+- }
+- } else
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (note < 13) note = 13;
+- note -= 13;
+- if (m_dwSongFlags & SONG_LINEARSLIDES)
+- {
+- LONG l = ((120 - note) << 6) - (nFineTune / 2);
+- if (l < 1) l = 1;
+- return (UINT)l;
+- } else
+- {
+- int finetune = nFineTune;
+- UINT rnote = (note % 12) << 3;
+- UINT roct = note / 12;
+- int rfine = finetune / 16;
+- int i = rnote + rfine + 8;
+- if (i < 0) i = 0;
+- if (i >= 104) i = 103;
+- UINT per1 = XMPeriodTable[i];
+- if ( finetune < 0 )
+- {
+- rfine--;
+- finetune = -finetune;
+- } else rfine++;
+- i = rnote+rfine+8;
+- if (i < 0) i = 0;
+- if (i >= 104) i = 103;
+- UINT per2 = XMPeriodTable[i];
+- rfine = finetune & 0x0F;
+- per1 *= 16-rfine;
+- per2 *= rfine;
+- return ((per1 + per2) << 1) >> roct;
+- }
+- } else
+- {
+- note--;
+- nFineTune = XM2MODFineTune(nFineTune);
+- if ((nFineTune) || (note < 36) || (note >= 36+6*12))
+- return (ProTrackerTunedPeriods[nFineTune*12 + note % 12] << 5) >> (note / 12);
+- else
+- return (ProTrackerPeriodTable[note-36] << 2);
+- }
+-}
+-
+-
+-UINT CSoundFile::GetFreqFromPeriod(UINT period, UINT nC4Speed, int nPeriodFrac) const
+-//-----------------------------------------------------------------------------------
+-{
+- if (!period) return 0;
+- if (m_nType & (MOD_TYPE_MED|MOD_TYPE_MOD|MOD_TYPE_MTM|MOD_TYPE_669|MOD_TYPE_OKT|MOD_TYPE_AMF0))
+- {
+- return (3546895L*4) / period;
+- } else
+- if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2))
+- {
+- if (m_dwSongFlags & SONG_LINEARSLIDES)
+- return XMLinearTable[period % 768] >> (period / 768);
+- else
+- return 8363 * 1712L / period;
+- } else
+- {
+- if (m_dwSongFlags & SONG_LINEARSLIDES)
+- {
+- if (!nC4Speed) nC4Speed = 8363;
+- return _muldiv(nC4Speed, 1712L << 8, (period << 8)+nPeriodFrac);
+- } else
+- {
+- return _muldiv(8363, 1712L << 8, (period << 8)+nPeriodFrac);
+- }
+- }
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/sndmix.cxx audacious-plugins-2.5.4/src/modplug/sndmix.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/sndmix.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/sndmix.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,1246 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+-*/
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-
+-// Volume ramp length, in 1/10 ms
+-#define VOLUMERAMPLEN 146 // 1.46ms = 64 samples at 44.1kHz
+-
+-// VU-Meter
+-#define VUMETER_DECAY 16
+-
+-// SNDMIX: These are global flags for playback control
+-LONG CSoundFile::m_nStreamVolume = 0x8000;
+-UINT CSoundFile::m_nMaxMixChannels = 256;
+-// Mixing Configuration (SetWaveConfig)
+-DWORD CSoundFile::gdwSysInfo = 0;
+-DWORD CSoundFile::gnChannels = 1;
+-DWORD CSoundFile::gdwSoundSetup = SNDMIX_NOBACKWARDJUMPS; // Do not allow song to loop infinitely
+-DWORD CSoundFile::gdwMixingFreq = 44100;
+-DWORD CSoundFile::gnBitsPerSample = 16;
+-// Mixing data initialized in
+-UINT CSoundFile::gnAGC = AGC_UNITY;
+-UINT CSoundFile::gnVolumeRampSamples = 64;
+-UINT CSoundFile::gnVULeft = 0;
+-UINT CSoundFile::gnVURight = 0;
+-UINT CSoundFile::gnCPUUsage = 0;
+-LPSNDMIXHOOKPROC CSoundFile::gpSndMixHook = NULL;
+-PMIXPLUGINCREATEPROC CSoundFile::gpMixPluginCreateProc = NULL;
+-LONG gnDryROfsVol = 0;
+-LONG gnDryLOfsVol = 0;
+-LONG gnRvbROfsVol = 0;
+-LONG gnRvbLOfsVol = 0;
+-int gbInitPlugins = 0;
+-
+-typedef DWORD (MPPASMCALL * LPCONVERTPROC)(LPVOID, int *, DWORD, LPLONG, LPLONG);
+-
+-extern DWORD MPPASMCALL Convert32To8(LPVOID lpBuffer, int *, DWORD nSamples, LONG mins[2], LONG maxs[2]);
+-extern DWORD MPPASMCALL Convert32To16(LPVOID lpBuffer, int *, DWORD nSamples, LONG mins[2], LONG maxs[2]);
+-extern DWORD MPPASMCALL Convert32To24(LPVOID lpBuffer, int *, DWORD nSamples, LONG mins[2], LONG maxs[2]);
+-extern DWORD MPPASMCALL Convert32To32(LPVOID lpBuffer, int *, DWORD nSamples, LONG mins[2], LONG maxs[2]);
+-extern UINT MPPASMCALL AGC(int *pBuffer, UINT nSamples, UINT nAGC);
+-extern VOID MPPASMCALL Dither(int *pBuffer, UINT nSamples, UINT nBits);
+-extern VOID MPPASMCALL InterleaveFrontRear(int *pFrontBuf, int *pRearBuf, DWORD nSamples);
+-extern VOID MPPASMCALL StereoFill(int *pBuffer, UINT nSamples, LPLONG lpROfs, LPLONG lpLOfs);
+-extern VOID MPPASMCALL MonoFromStereo(int *pMixBuf, UINT nSamples);
+-
+-extern short int ModSinusTable[64];
+-extern short int ModRampDownTable[64];
+-extern short int ModSquareTable[64];
+-extern short int ModRandomTable[64];
+-extern DWORD LinearSlideUpTable[256];
+-extern DWORD LinearSlideDownTable[256];
+-extern DWORD FineLinearSlideUpTable[16];
+-extern DWORD FineLinearSlideDownTable[16];
+-extern signed char ft2VibratoTable[256]; // -64 .. +64
+-extern int MixSoundBuffer[MIXBUFFERSIZE*4];
+-extern int MixRearBuffer[MIXBUFFERSIZE*2];
+-UINT gnReverbSend;
+-
+-
+-// Log tables for pre-amp
+-// We don't want the tracker to get too loud
+-const UINT PreAmpTable[16] =
+-{
+- 0x60, 0x60, 0x60, 0x70, // 0-7
+- 0x80, 0x88, 0x90, 0x98, // 8-15
+- 0xA0, 0xA4, 0xA8, 0xB0, // 16-23
+- 0xB4, 0xB8, 0xBC, 0xC0, // 24-31
+-};
+-
+-const UINT PreAmpAGCTable[16] =
+-{
+- 0x60, 0x60, 0x60, 0x60,
+- 0x68, 0x70, 0x78, 0x80,
+- 0x84, 0x88, 0x8C, 0x90,
+- 0x94, 0x98, 0x9C, 0xA0,
+-};
+-
+-
+-BOOL CSoundFile::InitPlayer(BOOL bReset)
+-//--------------------------------------
+-{
+- if (m_nMaxMixChannels > MAX_CHANNELS) m_nMaxMixChannels = MAX_CHANNELS;
+- if (gdwMixingFreq < 4000) gdwMixingFreq = 4000;
+- if (gdwMixingFreq > MAX_SAMPLE_RATE) gdwMixingFreq = MAX_SAMPLE_RATE;
+- gnVolumeRampSamples = (gdwMixingFreq * VOLUMERAMPLEN) / 100000;
+- if (gnVolumeRampSamples < 8) gnVolumeRampSamples = 8;
+- gnDryROfsVol = gnDryLOfsVol = 0;
+- gnRvbROfsVol = gnRvbLOfsVol = 0;
+- if (bReset)
+- {
+- gnVULeft = 0;
+- gnVURight = 0;
+- gnCPUUsage = 0;
+- }
+- gbInitPlugins = (bReset) ? 3 : 1;
+- InitializeDSP(bReset);
+- InitializeEQ(bReset);
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::FadeSong(UINT msec)
+-//----------------------------------
+-{
+- LONG nsamples = _muldiv(msec, gdwMixingFreq, 1000);
+- if (nsamples <= 0) return FALSE;
+- if (nsamples > 0x100000) nsamples = 0x100000;
+- m_nBufferCount = nsamples;
+- LONG nRampLength = m_nBufferCount;
+- // Ramp everything down
+- for (UINT noff=0; noff < m_nMixChannels; noff++)
+- {
+- MODCHANNEL *pramp = &Chn[ChnMix[noff]];
+- if (!pramp) continue;
+- pramp->nNewLeftVol = pramp->nNewRightVol = 0;
+- pramp->nRightRamp = (-pramp->nRightVol << VOLUMERAMPPRECISION) / nRampLength;
+- pramp->nLeftRamp = (-pramp->nLeftVol << VOLUMERAMPPRECISION) / nRampLength;
+- pramp->nRampRightVol = pramp->nRightVol << VOLUMERAMPPRECISION;
+- pramp->nRampLeftVol = pramp->nLeftVol << VOLUMERAMPPRECISION;
+- pramp->nRampLength = nRampLength;
+- pramp->dwFlags |= CHN_VOLUMERAMP;
+- }
+- m_dwSongFlags |= SONG_FADINGSONG;
+- return TRUE;
+-}
+-
+-
+-BOOL CSoundFile::GlobalFadeSong(UINT msec)
+-//----------------------------------------
+-{
+- if (m_dwSongFlags & SONG_GLOBALFADE) return FALSE;
+- m_nGlobalFadeMaxSamples = _muldiv(msec, gdwMixingFreq, 1000);
+- m_nGlobalFadeSamples = m_nGlobalFadeMaxSamples;
+- m_dwSongFlags |= SONG_GLOBALFADE;
+- return TRUE;
+-}
+-
+-
+-UINT CSoundFile::Read(LPVOID lpDestBuffer, UINT cbBuffer)
+-//-------------------------------------------------------
+-{
+- LPBYTE lpBuffer = (LPBYTE)lpDestBuffer;
+- LPCONVERTPROC pCvt = Convert32To8;
+- LONG vu_min[2];
+- LONG vu_max[2];
+- UINT lRead, lMax, lSampleSize, lCount, lSampleCount, nStat=0;
+-#if 0
+- UINT nMaxPlugins;
+-#endif
+-
+- vu_min[0] = vu_min[1] = 0x7FFFFFFF;
+- vu_max[0] = vu_max[1] = -0x7FFFFFFF;
+-
+-#if 0
+- {
+- nMaxPlugins = MAX_MIXPLUGINS;
+- while ((nMaxPlugins > 0) && (!m_MixPlugins[nMaxPlugins-1].pMixPlugin)) nMaxPlugins--;
+- }
+-#endif
+- m_nMixStat = 0;
+- lSampleSize = gnChannels;
+- if (gnBitsPerSample == 16) { lSampleSize *= 2; pCvt = Convert32To16; }
+- else if (gnBitsPerSample == 24) { lSampleSize *= 3; pCvt = Convert32To24; }
+- else if (gnBitsPerSample == 32) { lSampleSize *= 4; pCvt = Convert32To32; }
+- lMax = cbBuffer / lSampleSize;
+- if ((!lMax) || (!lpBuffer) || (!m_nChannels)) return 0;
+- lRead = lMax;
+- if (m_dwSongFlags & SONG_ENDREACHED) goto MixDone;
+- while (lRead > 0)
+- {
+- // Update Channel Data
+- UINT lTotalSampleCount;
+- if (!m_nBufferCount)
+- {
+- if (!(gdwSoundSetup & SNDMIX_DIRECTTODISK))
+- m_nBufferCount = lRead;
+- if (!ReadNote()) {
+- m_dwSongFlags |= SONG_ENDREACHED;
+- if (lRead == lMax) goto MixDone;
+- if (!(gdwSoundSetup & SNDMIX_DIRECTTODISK))
+- m_nBufferCount = lRead;
+- }
+- if (!m_nBufferCount) goto MixDone;
+- }
+- lCount = m_nBufferCount;
+- if (lCount > MIXBUFFERSIZE) lCount = MIXBUFFERSIZE;
+- if (lCount > lRead) lCount = lRead;
+- if (!lCount) break;
+- lSampleCount = lCount;
+-#ifndef MODPLUG_NO_REVERB
+- gnReverbSend = 0;
+-#endif
+-
+- // Resetting sound buffer
+- StereoFill(MixSoundBuffer, lSampleCount, &gnDryROfsVol, &gnDryLOfsVol);
+- if (gnChannels >= 2)
+- {
+- lSampleCount *= 2;
+- m_nMixStat += CreateStereoMix(lCount);
+-#if 0
+- if (nMaxPlugins) ProcessPlugins(lCount);
+-#endif
+- ProcessStereoDSP(lCount);
+- } else
+- {
+- m_nMixStat += CreateStereoMix(lCount);
+-#if 0
+- if (nMaxPlugins) ProcessPlugins(lCount);
+-#endif
+- MonoFromStereo(MixSoundBuffer, lCount);
+- ProcessMonoDSP(lCount);
+- }
+-
+- if (gdwSoundSetup & SNDMIX_EQ)
+- {
+- if (gnChannels >= 2)
+- EQStereo(MixSoundBuffer, lCount);
+- else
+- EQMono(MixSoundBuffer, lCount);
+- }
+-
+-
+- nStat++;
+-#ifndef NO_AGC
+- // Automatic Gain Control
+- if (gdwSoundSetup & SNDMIX_AGC) ProcessAGC(lSampleCount);
+-#endif
+- lTotalSampleCount = lSampleCount;
+- // Multichannel
+- if (gnChannels > 2)
+- {
+- InterleaveFrontRear(MixSoundBuffer, MixRearBuffer, lSampleCount);
+- lTotalSampleCount *= 2;
+- }
+- // Hook Function
+- if (gpSndMixHook)
+- {
+- gpSndMixHook(MixSoundBuffer, lTotalSampleCount, gnChannels);
+- }
+- // Perform clipping + VU-Meter
+- lpBuffer += pCvt(lpBuffer, MixSoundBuffer, lTotalSampleCount, vu_min, vu_max);
+- // Buffer ready
+- lRead -= lCount;
+- m_nBufferCount -= lCount;
+- }
+-MixDone:
+- if (lRead) memset(lpBuffer, (gnBitsPerSample == 8) ? 0x80 : 0, lRead * lSampleSize);
+- // VU-Meter
+- vu_min[0] >>= 18;
+- vu_min[1] >>= 18;
+- vu_max[0] >>= 18;
+- vu_max[1] >>= 18;
+- if (vu_max[0] < vu_min[0]) vu_max[0] = vu_min[0];
+- if (vu_max[1] < vu_min[1]) vu_max[1] = vu_min[1];
+- if ((gnVULeft = (UINT)(vu_max[0] - vu_min[0])) > 0xFF)
+- gnVULeft = 0xFF;
+- if ((gnVURight = (UINT)(vu_max[1] - vu_min[1])) > 0xFF)
+- gnVURight = 0xFF;
+- if (nStat) { m_nMixStat += nStat-1; m_nMixStat /= nStat; }
+- return lMax - lRead;
+-}
+-
+-
+-
+-/////////////////////////////////////////////////////////////////////////////
+-// Handles navigation/effects
+-
+-BOOL CSoundFile::ProcessRow()
+-//---------------------------
+-{
+- if (++m_nTickCount >= m_nMusicSpeed * (m_nPatternDelay+1) + m_nFrameDelay)
+- {
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+- m_nTickCount = 0;
+- m_nRow = m_nNextRow;
+- // Reset Pattern Loop Effect
+- if (m_nCurrentPattern != m_nNextPattern) m_nCurrentPattern = m_nNextPattern;
+- // Check if pattern is valid
+- if (!(m_dwSongFlags & SONG_PATTERNLOOP))
+- {
+- m_nPattern = (m_nCurrentPattern < MAX_ORDERS) ? Order[m_nCurrentPattern] : 0xFF;
+- if ((m_nPattern < MAX_PATTERNS) && (!Patterns[m_nPattern])) m_nPattern = 0xFE;
+- while (m_nPattern >= MAX_PATTERNS)
+- {
+- // End of song ?
+- if ((m_nPattern == 0xFF) || (m_nCurrentPattern >= MAX_ORDERS))
+- {
+- //if (!m_nRepeatCount)
+- return FALSE; //never repeat entire song
+- if (!m_nRestartPos)
+- {
+- m_nMusicSpeed = m_nDefaultSpeed;
+- m_nMusicTempo = m_nDefaultTempo;
+- m_nGlobalVolume = m_nDefaultGlobalVolume;
+- for (UINT i=0; i<MAX_CHANNELS; i++)
+- {
+- Chn[i].dwFlags |= CHN_NOTEFADE | CHN_KEYOFF;
+- Chn[i].nFadeOutVol = 0;
+- if (i < m_nChannels)
+- {
+- Chn[i].nGlobalVol = ChnSettings[i].nVolume;
+- Chn[i].nVolume = ChnSettings[i].nVolume;
+- Chn[i].nPan = ChnSettings[i].nPan;
+- Chn[i].nPanSwing = Chn[i].nVolSwing = 0;
+- Chn[i].nOldVolParam = 0;
+- Chn[i].nOldOffset = 0;
+- Chn[i].nOldHiOffset = 0;
+- Chn[i].nPortamentoDest = 0;
+- if (!Chn[i].nLength)
+- {
+- Chn[i].dwFlags = ChnSettings[i].dwFlags;
+- Chn[i].nLoopStart = 0;
+- Chn[i].nLoopEnd = 0;
+- Chn[i].pHeader = NULL;
+- Chn[i].pSample = NULL;
+- Chn[i].pInstrument = NULL;
+- }
+- }
+- }
+- }
+-// if (m_nRepeatCount > 0) m_nRepeatCount--;
+- m_nCurrentPattern = m_nRestartPos;
+- m_nRow = 0;
+- if ((Order[m_nCurrentPattern] >= MAX_PATTERNS) || (!Patterns[Order[m_nCurrentPattern]])) return FALSE;
+- } else
+- {
+- m_nCurrentPattern++;
+- }
+- m_nPattern = (m_nCurrentPattern < MAX_ORDERS) ? Order[m_nCurrentPattern] : 0xFF;
+- if ((m_nPattern < MAX_PATTERNS) && (!Patterns[m_nPattern])) m_nPattern = 0xFE;
+- }
+- m_nNextPattern = m_nCurrentPattern;
+- }
+- // Weird stuff?
+- if ((m_nPattern >= MAX_PATTERNS) || (!Patterns[m_nPattern])) return FALSE;
+- // Should never happen
+- if (m_nRow >= PatternSize[m_nPattern]) m_nRow = 0;
+- m_nNextRow = m_nRow + 1;
+- if (m_nNextRow >= PatternSize[m_nPattern])
+- {
+- if (!(m_dwSongFlags & SONG_PATTERNLOOP)) m_nNextPattern = m_nCurrentPattern + 1;
+- m_nNextRow = 0;
+- }
+- // Reset channel values
+- MODCHANNEL *pChn = Chn;
+- MODCOMMAND *m = Patterns[m_nPattern] + m_nRow * m_nChannels;
+- for (UINT nChn=0; nChn<m_nChannels; pChn++, nChn++, m++)
+- {
+- pChn->nRowNote = m->note;
+- pChn->nRowInstr = m->instr;
+- pChn->nRowVolCmd = m->volcmd;
+- pChn->nRowVolume = m->vol;
+- pChn->nRowCommand = m->command;
+- pChn->nRowParam = m->param;
+-
+- pChn->nLeftVol = pChn->nNewLeftVol;
+- pChn->nRightVol = pChn->nNewRightVol;
+- pChn->dwFlags &= ~(CHN_PORTAMENTO | CHN_VIBRATO | CHN_TREMOLO | CHN_PANBRELLO);
+- pChn->nCommand = 0;
+- }
+- }
+- // Should we process tick0 effects?
+- if (!m_nMusicSpeed) m_nMusicSpeed = 1;
+- m_dwSongFlags |= SONG_FIRSTTICK;
+- if (m_nTickCount)
+- {
+- m_dwSongFlags &= ~SONG_FIRSTTICK;
+- if ((!(m_nType & MOD_TYPE_XM)) && (m_nTickCount < m_nMusicSpeed * (1 + m_nPatternDelay)))
+- {
+- if (!(m_nTickCount % m_nMusicSpeed)) m_dwSongFlags |= SONG_FIRSTTICK;
+- }
+-
+- }
+- // Update Effects
+- return ProcessEffects();
+-}
+-
+-
+-////////////////////////////////////////////////////////////////////////////////////////////
+-// Handles envelopes & mixer setup
+-
+-BOOL CSoundFile::ReadNote()
+-//-------------------------
+-{
+- // Checking end of row ?
+- if (m_dwSongFlags & SONG_PAUSED)
+- {
+- /*m_nTickCount = 0;*/
+- if (!m_nMusicSpeed) m_nMusicSpeed = 6;
+- if (!m_nMusicTempo) m_nMusicTempo = 125;
+- m_nPatternDelay = 0;
+- m_nFrameDelay = 0;
+-
+- m_dwSongFlags |= SONG_FIRSTTICK;
+- if (m_nTickCount) {
+- m_dwSongFlags &= ~SONG_FIRSTTICK;
+- }
+-
+- ProcessEffects();
+- m_nTickCount++;
+- if (m_nTickCount >= m_nMusicSpeed) {
+- m_nTickCount = 0;
+- }
+- if (!ProcessEffects()) return FALSE;
+- } else
+- {
+- if (!ProcessRow()) return FALSE;
+- }
+-
+- { /* handle realtime closures */
+- MODCHANNEL *pChn = Chn;
+- for (UINT nChn=0; nChn<m_nChannels; pChn++, nChn++) {
+- /* reset end of "row" */
+- if (pChn->nRealtime && pChn->nRowNote && (pChn->nTickStart % m_nMusicSpeed) == (m_nTickCount % m_nMusicSpeed)) {
+- pChn->nRealtime = 0;
+- pChn->nRowNote = 0;
+- pChn->nRowInstr = 0;
+- //pChn->nMaster
+- pChn->nRowVolCmd = 0;
+- pChn->nRowVolume = 0;
+- pChn->nRowCommand = 0;
+- pChn->nRowParam = 0;
+- pChn->nTickStart = 0;
+- }
+- }
+- };
+-
+- ////////////////////////////////////////////////////////////////////////////////////
+- m_nTotalCount++;
+- if (!m_nMusicTempo) return FALSE;
+- m_nBufferCount = (gdwMixingFreq * 5 * m_nTempoFactor) / (m_nMusicTempo << 8);
+-#ifdef MODPLUG_TRACKER
+- if (m_dwSongFlags & SONG_PAUSED)
+- {
+- m_nBufferCount = gdwMixingFreq / 64; // 1/64 seconds
+- }
+-#endif
+-
+- // Master Volume + Pre-Amplification / Attenuation setup
+- DWORD nMasterVol;
+- {
+- int nchn32 = 0;
+- MODCHANNEL *pChn = Chn;
+- for (UINT nChn=0; nChn<m_nChannels; nChn++, pChn++) {
+- nchn32++;
+- }
+- if (nchn32 < 1) nchn32 = 1;
+- if (nchn32 > 31) nchn32 = 31;
+-
+- int realmastervol = m_nMasterVolume;
+- if (realmastervol > 0x80)
+- {
+- realmastervol = 0x80 + ((realmastervol - 0x80) * (nchn32+4)) / 16;
+- }
+-
+- DWORD mastervol = (realmastervol * (m_nSongPreAmp)) >> 6;
+-// if (mastervol > 0x200) mastervol = 0x200;
+- if ((m_dwSongFlags & SONG_GLOBALFADE) && (m_nGlobalFadeMaxSamples))
+- {
+- mastervol = _muldiv(mastervol, m_nGlobalFadeSamples, m_nGlobalFadeMaxSamples);
+- }
+-
+- UINT attenuation = (gdwSoundSetup & SNDMIX_AGC) ? PreAmpAGCTable[nchn32>>1] : PreAmpTable[nchn32>>1];
+- if (attenuation < 1) attenuation = 1;
+-
+- nMasterVol = (mastervol << 7) / attenuation;
+- if (nMasterVol > 0x180) nMasterVol = 0x180;
+- }
+- ////////////////////////////////////////////////////////////////////////////////////
+- // Update channels data
+- if (CSoundFile::gdwSoundSetup & SNDMIX_NOMIXING) return TRUE;
+- m_nMixChannels = 0;
+- MODCHANNEL *pChn = Chn;
+- for (UINT nChn=0; nChn<MAX_CHANNELS; nChn++,pChn++)
+- {
+- if ((pChn->dwFlags & CHN_NOTEFADE) && (!(pChn->nFadeOutVol|pChn->nRightVol|pChn->nLeftVol)))
+- {
+- pChn->nLength = 0;
+- pChn->nROfs = pChn->nLOfs = 0;
+- }
+- // Check for unused channel
+- if ((nChn >= m_nChannels) && (!pChn->nLength))
+- {
+- pChn->nLeftVU = pChn->nRightVU = 0;
+- continue;
+- }
+- // Reset channel data
+- pChn->nInc = 0;
+- pChn->nRealVolume = 0;
+- pChn->nRealPan = pChn->nPan + pChn->nPanSwing;
+- if (pChn->nRealPan < 0) pChn->nRealPan = 0;
+- if (pChn->nRealPan > 256) pChn->nRealPan = 256;
+- pChn->nRampLength = 0;
+- // Calc Frequency
+- if ((pChn->nPeriod) && (pChn->nLength))
+- {
+- int vol = pChn->nVolume + pChn->nVolSwing;
+-
+- if (vol < 0) vol = 0;
+- if (vol > 256) vol = 256;
+- // Tremolo
+- if (pChn->dwFlags & CHN_TREMOLO)
+- {
+- UINT trempos = pChn->nTremoloPos & 0x3F;
+- if (vol > 0)
+- {
+- int tremattn = (m_nType & MOD_TYPE_XM) ? 5 : 6;
+- switch (pChn->nTremoloType & 0x03)
+- {
+- case 1:
+- vol += (ModRampDownTable[trempos] * (int)pChn->nTremoloDepth) >> tremattn;
+- break;
+- case 2:
+- vol += (ModSquareTable[trempos] * (int)pChn->nTremoloDepth) >> tremattn;
+- break;
+- case 3:
+- vol += (ModRandomTable[trempos] * (int)pChn->nTremoloDepth) >> tremattn;
+- break;
+- default:
+- vol += (ModSinusTable[trempos] * (int)pChn->nTremoloDepth) >> tremattn;
+- }
+- }
+- if ((m_nTickCount) || ((m_nType & (MOD_TYPE_STM|MOD_TYPE_S3M|MOD_TYPE_IT)) && (!(m_dwSongFlags & SONG_ITOLDEFFECTS))))
+- {
+- pChn->nTremoloPos = (trempos + pChn->nTremoloSpeed) & 0x3F;
+- }
+- }
+- // Tremor
+- if (pChn->nCommand == CMD_TREMOR)
+- {
+- UINT n = (pChn->nTremorParam >> 4) + (pChn->nTremorParam & 0x0F);
+- UINT ontime = pChn->nTremorParam >> 4;
+- if ((!(m_nType & MOD_TYPE_IT)) || (m_dwSongFlags & SONG_ITOLDEFFECTS)) { n += 2; ontime++; }
+- UINT tremcount = (UINT)pChn->nTremorCount;
+- if (tremcount >= n) tremcount = 0;
+- if ((m_nTickCount) || (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT)))
+- {
+- if (tremcount >= ontime) vol = 0;
+- pChn->nTremorCount = (BYTE)(tremcount + 1);
+- }
+- pChn->dwFlags |= CHN_FASTVOLRAMP;
+- }
+- // Clip volume
+- if (vol < 0) vol = 0;
+- if (vol > 0x100) vol = 0x100;
+- vol <<= 6;
+- // Process Envelopes
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && pChn->pHeader)
+- {
+- INSTRUMENTHEADER *penv = pChn->pHeader;
+- // Volume Envelope
+- if ((pChn->dwFlags & CHN_VOLENV) && (penv->VolEnv.nNodes))
+- {
+- int envpos = pChn->nVolEnvPosition;
+- UINT pt = penv->VolEnv.nNodes - 1;
+- for (UINT i=0; i<(UINT)(penv->VolEnv.nNodes-1); i++)
+- {
+- if (envpos <= penv->VolEnv.Ticks[i])
+- {
+- pt = i;
+- break;
+- }
+- }
+- int x2 = penv->VolEnv.Ticks[pt];
+- int x1, envvol;
+- if (envpos >= x2)
+- {
+- envvol = penv->VolEnv.Values[pt] << 2;
+- x1 = x2;
+- } else
+- if (pt)
+- {
+- envvol = penv->VolEnv.Values[pt-1] << 2;
+- x1 = penv->VolEnv.Ticks[pt-1];
+- } else
+- {
+- envvol = 0;
+- x1 = 0;
+- }
+- if (envpos > x2) envpos = x2;
+- if ((x2 > x1) && (envpos > x1))
+- {
+- envvol += ((envpos - x1) * (((int)penv->VolEnv.Values[pt]<<2) - envvol)) / (x2 - x1);
+- }
+- if (envvol < 0) envvol = 0;
+- if (envvol > 256) envvol = 256;
+- vol = (vol * envvol) >> 8;
+- }
+- // Panning Envelope
+- if ((pChn->dwFlags & CHN_PANENV) && (penv->PanEnv.nNodes))
+- {
+- int envpos = pChn->nPanEnvPosition;
+- UINT pt = penv->PanEnv.nNodes - 1;
+- for (UINT i=0; i<(UINT)(penv->PanEnv.nNodes-1); i++)
+- {
+- if (envpos <= penv->PanEnv.Ticks[i])
+- {
+- pt = i;
+- break;
+- }
+- }
+- int x2 = penv->PanEnv.Ticks[pt], y2 = penv->PanEnv.Values[pt];
+- int x1, envpan;
+- if (envpos >= x2)
+- {
+- envpan = y2;
+- x1 = x2;
+- } else
+- if (pt)
+- {
+- envpan = penv->PanEnv.Values[pt-1];
+- x1 = penv->PanEnv.Ticks[pt-1];
+- } else
+- {
+- envpan = 128;
+- x1 = 0;
+- }
+- if ((x2 > x1) && (envpos > x1))
+- {
+- envpan += ((envpos - x1) * (y2 - envpan)) / (x2 - x1);
+- }
+- if (envpan < 0) envpan = 0;
+- if (envpan > 64) envpan = 64;
+- int pan = pChn->nPan;
+- if (pan >= 128)
+- {
+- pan += ((envpan - 32) * (256 - pan)) / 32;
+- } else
+- {
+- pan += ((envpan - 32) * (pan)) / 32;
+- }
+- if (pan < 0) pan = 0;
+- if (pan > 256) pan = 256;
+- pChn->nRealPan = pan;
+- }
+- // FadeOut volume
+- if (pChn->dwFlags & CHN_NOTEFADE)
+- {
+- UINT fadeout = penv->nFadeOut;
+- if (fadeout)
+- {
+- pChn->nFadeOutVol -= fadeout << 1;
+- if (pChn->nFadeOutVol <= 0) pChn->nFadeOutVol = 0;
+- vol = (vol * pChn->nFadeOutVol) >> 16;
+- } else
+- if (!pChn->nFadeOutVol)
+- {
+- vol = 0;
+- }
+- }
+- // Pitch/Pan separation
+- if ((penv->nPPS) && (pChn->nRealPan) && (pChn->nNote))
+- {
+- int pandelta = (int)pChn->nRealPan + (int)((int)(pChn->nNote - penv->nPPC - 1) * (int)penv->nPPS) / (int)8;
+- if (pandelta < 0) pandelta = 0;
+- if (pandelta > 256) pandelta = 256;
+- pChn->nRealPan = pandelta;
+- }
+- } else
+- {
+- // No Envelope: key off => note cut
+- if (pChn->dwFlags & CHN_NOTEFADE) // 1.41-: CHN_KEYOFF|CHN_NOTEFADE
+- {
+- pChn->nFadeOutVol = 0;
+- vol = 0;
+- }
+- }
+- // vol is 14-bits
+- if (vol)
+- {
+- // IMPORTANT: pChn->nRealVolume is 14 bits !!!
+- // -> _muldiv( 14+8, 6+6, 18); => RealVolume: 14-bit result (22+12-20)
+- pChn->nRealVolume = _muldiv(vol * m_nGlobalVolume, pChn->nGlobalVol * pChn->nInsVol, 1 << 20);
+- }
+- if (pChn->nPeriod < m_nMinPeriod) pChn->nPeriod = m_nMinPeriod;
+- int period = pChn->nPeriod;
+- if ((pChn->dwFlags & (CHN_GLISSANDO|CHN_PORTAMENTO)) == (CHN_GLISSANDO|CHN_PORTAMENTO))
+- {
+- period = GetPeriodFromNote(GetNoteFromPeriod(period), pChn->nFineTune, pChn->nC4Speed);
+- }
+-
+- // Arpeggio ?
+- if (pChn->nCommand == CMD_ARPEGGIO)
+- {
+- switch(m_nTickCount % 3)
+- {
+-#if 0
+- case 1: period = GetPeriodFromNote(pChn->nNote + (pChn->nArpeggio >> 4), pChn->nFineTune, pChn->nC4Speed); break;
+- case 2: period = GetPeriodFromNote(pChn->nNote + (pChn->nArpeggio & 0x0F), pChn->nFineTune, pChn->nC4Speed); break;
+-#else
+- case 1: period = GetLinearPeriodFromNote(GetNoteFromPeriod(period) + (pChn->nArpeggio >> 4), pChn->nFineTune, pChn->nC4Speed); break;
+- case 2: period = GetLinearPeriodFromNote(GetNoteFromPeriod(period) + (pChn->nArpeggio & 0x0F), pChn->nFineTune, pChn->nC4Speed); break;
+-#endif
+- }
+- }
+-
+- if (m_dwSongFlags & SONG_AMIGALIMITS)
+- {
+- if (period < 113*4) period = 113*4;
+- if (period > 856*4) period = 856*4;
+- }
+-
+- // Pitch/Filter Envelope
+- int envpitch = 0;
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && (pChn->pHeader)
+- && (pChn->dwFlags & CHN_PITCHENV) && (pChn->pHeader->PitchEnv.nNodes))
+- {
+- INSTRUMENTHEADER *penv = pChn->pHeader;
+- int envpos = pChn->nPitchEnvPosition;
+- UINT pt = penv->PitchEnv.nNodes - 1;
+- for (UINT i=0; i<(UINT)(penv->PitchEnv.nNodes-1); i++)
+- {
+- if (envpos <= penv->PitchEnv.Ticks[i])
+- {
+- pt = i;
+- break;
+- }
+- }
+- int x2 = penv->PitchEnv.Ticks[pt];
+- int x1;
+- if (envpos >= x2)
+- {
+- envpitch = (((int)penv->PitchEnv.Values[pt]) - 32) * 8;
+- x1 = x2;
+- } else
+- if (pt)
+- {
+- envpitch = (((int)penv->PitchEnv.Values[pt-1]) - 32) * 8;
+- x1 = penv->PitchEnv.Ticks[pt-1];
+- } else
+- {
+- envpitch = 0;
+- x1 = 0;
+- }
+- if (envpos > x2) envpos = x2;
+- if ((x2 > x1) && (envpos > x1))
+- {
+- int envpitchdest = (((int)penv->PitchEnv.Values[pt]) - 32) * 8;
+- envpitch += ((envpos - x1) * (envpitchdest - envpitch)) / (x2 - x1);
+- }
+- if (envpitch < -256) envpitch = -256;
+- if (envpitch > 256) envpitch = 256;
+- // Pitch Envelope
+- if (!(penv->dwFlags & ENV_FILTER))
+- {
+- int l = envpitch;
+- if (l < 0)
+- {
+- l = -l;
+- if (l > 255) l = 255;
+- period = _muldiv(period, LinearSlideUpTable[l], 0x10000);
+- } else
+- {
+- if (l > 255) l = 255;
+- period = _muldiv(period, LinearSlideDownTable[l], 0x10000);
+- }
+- }
+- }
+-
+- // Vibrato
+- if (pChn->dwFlags & CHN_VIBRATO)
+- {
+- UINT vibpos = pChn->nVibratoPos;
+- LONG vdelta;
+- switch (pChn->nVibratoType & 0x03)
+- {
+- case 1:
+- vdelta = ModRampDownTable[vibpos];
+- break;
+- case 2:
+- vdelta = ModSquareTable[vibpos];
+- break;
+- case 3:
+- vdelta = ModRandomTable[vibpos];
+- break;
+- default:
+- vdelta = ModSinusTable[vibpos];
+- }
+- UINT vdepth = ((m_nType != MOD_TYPE_IT) || (m_dwSongFlags & SONG_ITOLDEFFECTS)) ? 6 : 7;
+- vdelta = (vdelta * (int)pChn->nVibratoDepth) >> vdepth;
+- if ((m_dwSongFlags & SONG_LINEARSLIDES) && (m_nType & MOD_TYPE_IT))
+- {
+- LONG l = vdelta;
+- if (l < 0)
+- {
+- l = -l;
+- vdelta = _muldiv(period, LinearSlideDownTable[l >> 2], 0x10000) - period;
+- if (l & 0x03) vdelta += _muldiv(period, FineLinearSlideDownTable[l & 0x03], 0x10000) - period;
+-
+- } else
+- {
+- vdelta = _muldiv(period, LinearSlideUpTable[l >> 2], 0x10000) - period;
+- if (l & 0x03) vdelta += _muldiv(period, FineLinearSlideUpTable[l & 0x03], 0x10000) - period;
+-
+- }
+- }
+- period += vdelta;
+- if ((m_nTickCount) || ((m_nType & MOD_TYPE_IT) && (!(m_dwSongFlags & SONG_ITOLDEFFECTS))))
+- {
+- pChn->nVibratoPos = (vibpos + pChn->nVibratoSpeed) & 0x3F;
+- }
+- }
+- // Panbrello
+- if (pChn->dwFlags & CHN_PANBRELLO)
+- {
+- UINT panpos = ((pChn->nPanbrelloPos+0x10) >> 2) & 0x3F;
+- LONG pdelta;
+- switch (pChn->nPanbrelloType & 0x03)
+- {
+- case 1:
+- pdelta = ModRampDownTable[panpos];
+- break;
+- case 2:
+- pdelta = ModSquareTable[panpos];
+- break;
+- case 3:
+- pdelta = ModRandomTable[panpos];
+- break;
+- default:
+- pdelta = ModSinusTable[panpos];
+- }
+- pChn->nPanbrelloPos += pChn->nPanbrelloSpeed;
+- pdelta = ((pdelta * (int)pChn->nPanbrelloDepth) + 2) >> 3;
+- pdelta += pChn->nRealPan;
+- if (pdelta < 0) pdelta = 0;
+- if (pdelta > 256) pdelta = 256;
+- pChn->nRealPan = pdelta;
+- }
+- int nPeriodFrac = 0;
+- // Instrument Auto-Vibrato
+- if ((pChn->pInstrument) && (pChn->pInstrument->nVibDepth))
+- {
+- MODINSTRUMENT *pins = pChn->pInstrument;
+- /* this isn't correct, but its better... */
+-
+- if (pins->nVibSweep == 0) {
+- pChn->nAutoVibDepth = pins->nVibDepth << 8;
+- } else {
+- pChn->nAutoVibDepth += pins->nVibSweep;
+- if ((pChn->nAutoVibDepth >> 8) > (int)pins->nVibDepth)
+- pChn->nAutoVibDepth = pins->nVibDepth << 8;
+- }
+-#if 0
+- if (pins->nVibSweep == 0)
+- {
+- pChn->nAutoVibDepth = pins->nVibDepth << 8;
+- } else
+- {
+- if (m_nType & MOD_TYPE_IT)
+- {
+- pChn->nAutoVibDepth += pins->nVibSweep;
+- } else
+- if (!(pChn->dwFlags & CHN_KEYOFF))
+- {
+- pChn->nAutoVibDepth += (pins->nVibDepth << 8) / pins->nVibSweep;
+- }
+- if ((pChn->nAutoVibDepth >> 8) > pins->nVibDepth)
+- pChn->nAutoVibDepth = pins->nVibDepth << 8;
+- }
+-#endif
+- pChn->nAutoVibPos += ((int)pins->nVibRate);
+- int val;
+- switch(pins->nVibType)
+- {
+- case 4: // Random
+- val = ModRandomTable[pChn->nAutoVibPos & 0x3F];
+- pChn->nAutoVibPos++;
+- break;
+- case 3: // Ramp Down
+- val = ((0x40 - (pChn->nAutoVibPos >> 1)) & 0x7F) - 0x40;
+- break;
+- case 2: // Ramp Up
+- val = ((0x40 + (pChn->nAutoVibPos >> 1)) & 0x7f) - 0x40;
+- break;
+- case 1: // Square
+- val = (pChn->nAutoVibPos & 128) ? +64 : -64;
+- break;
+- default: // Sine
+- val = ft2VibratoTable[pChn->nAutoVibPos & 255];
+- }
+- int n = ((val * pChn->nAutoVibDepth) >> 8);
+- // is this right? -mrsb
+- if (!(m_dwSongFlags & SONG_ITOLDEFFECTS))
+- n >>= 1;
+-
+- if (m_nType & MOD_TYPE_IT)
+- {
+- int df1, df2;
+- if (n < 0)
+- {
+- n = -n;
+- UINT n1 = n >> 8;
+- df1 = LinearSlideUpTable[n1];
+- df2 = LinearSlideUpTable[n1+1];
+- } else
+- {
+- UINT n1 = n >> 8;
+- df1 = LinearSlideDownTable[n1];
+- df2 = LinearSlideDownTable[n1+1];
+- }
+- n >>= 2;
+- period = _muldiv(period, df1 + ((df2-df1)*(n&0x3F)>>6), 256);
+- nPeriodFrac = period & 0xFF;
+- period >>= 8;
+- } else
+- {
+- period += (n >> 6);
+- }
+- }
+- // Final Period
+- if (period <= m_nMinPeriod)
+- {
+- if (m_nType & MOD_TYPE_S3M) pChn->nLength = 0;
+- period = m_nMinPeriod;
+- }
+- if (period > m_nMaxPeriod)
+- {
+- if ((m_nType & MOD_TYPE_IT) || (period >= 0x100000))
+- {
+- pChn->nFadeOutVol = 0;
+- pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nRealVolume = 0;
+- }
+- period = m_nMaxPeriod;
+- nPeriodFrac = 0;
+- }
+- UINT freq = GetFreqFromPeriod(period, pChn->nC4Speed, nPeriodFrac);
+-
+- // Filter Envelope: controls cutoff frequency
+- if (pChn && pChn->pHeader && pChn->pHeader->dwFlags & ENV_FILTER)
+- {
+-#ifndef NO_FILTER
+- SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE, envpitch);
+-#endif // NO_FILTER
+- }
+-
+-#if 0
+- if ((m_nType & MOD_TYPE_IT) && (freq < 256))
+- {
+- pChn->nFadeOutVol = 0;
+- pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nRealVolume = 0;
+- }
+-#endif
+- pChn->sample_freq = freq;
+-
+- UINT ninc = _muldiv(freq, 0x10000, gdwMixingFreq);
+- if ((ninc >= 0xFFB0) && (ninc <= 0x10090)) ninc = 0x10000;
+- if (m_nFreqFactor != 128) ninc = (ninc * m_nFreqFactor) >> 7;
+- if (ninc > 0xFF0000) ninc = 0xFF0000;
+- pChn->nInc = (ninc+1) & ~3;
+- }
+-
+- // Increment envelope position
+- if ((m_dwSongFlags & SONG_INSTRUMENTMODE) && pChn->pHeader)
+- {
+- INSTRUMENTHEADER *penv = pChn->pHeader;
+- // Volume Envelope
+- if (pChn->dwFlags & CHN_VOLENV)
+- {
+- // Increase position
+- pChn->nVolEnvPosition++;
+- // Volume Loop ?
+- if (penv->dwFlags & ENV_VOLLOOP)
+- {
+- int volloopend = penv->VolEnv.Ticks[penv->VolEnv.nLoopEnd];
+- if (m_nType != MOD_TYPE_XM) volloopend++;
+- if (pChn->nVolEnvPosition == volloopend)
+- {
+- pChn->nVolEnvPosition = penv->VolEnv.Ticks[penv->VolEnv.nLoopStart];
+- if ((penv->VolEnv.nLoopEnd == penv->VolEnv.nLoopStart) && (!penv->VolEnv.Values[penv->VolEnv.nLoopStart])
+- && ((!(m_nType & MOD_TYPE_XM)) || (penv->VolEnv.nLoopEnd+1 == penv->VolEnv.nNodes)))
+- {
+- pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nFadeOutVol = 0;
+- }
+- }
+- }
+- // Volume Sustain ?
+- if ((penv->dwFlags & ENV_VOLSUSTAIN) && (!(pChn->dwFlags & CHN_KEYOFF)))
+- {
+- if (pChn->nVolEnvPosition == (int)penv->VolEnv.Ticks[penv->VolEnv.nSustainEnd]+1)
+- pChn->nVolEnvPosition = penv->VolEnv.Ticks[penv->VolEnv.nSustainStart];
+- } else
+- // End of Envelope ?
+- if (pChn->nVolEnvPosition > penv->VolEnv.Ticks[penv->VolEnv.nNodes - 1])
+- {
+- if ((m_nType & MOD_TYPE_IT) || (pChn->dwFlags & CHN_KEYOFF)) pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nVolEnvPosition = penv->VolEnv.Ticks[penv->VolEnv.nNodes - 1];
+- if ((!penv->VolEnv.Values[penv->VolEnv.nNodes-1]) && ((nChn >= m_nChannels) || (m_nType & MOD_TYPE_IT)))
+- {
+- pChn->dwFlags |= CHN_NOTEFADE;
+- pChn->nFadeOutVol = 0;
+-
+- pChn->nRealVolume = 0;
+- }
+- }
+- }
+- // Panning Envelope
+- if (pChn->dwFlags & CHN_PANENV)
+- {
+- pChn->nPanEnvPosition++;
+- if (penv->dwFlags & ENV_PANLOOP)
+- {
+- int panloopend = penv->PanEnv.Ticks[penv->PanEnv.nLoopEnd];
+- if (m_nType != MOD_TYPE_XM) panloopend++;
+- if (pChn->nPanEnvPosition == panloopend)
+- pChn->nPanEnvPosition = penv->PanEnv.Ticks[penv->PanEnv.nLoopStart];
+- }
+- // Panning Sustain ?
+- if ((penv->dwFlags & ENV_PANSUSTAIN) && (pChn->nPanEnvPosition == (int)penv->PanEnv.Ticks[penv->PanEnv.nSustainEnd]+1)
+- && (!(pChn->dwFlags & CHN_KEYOFF)))
+- {
+- // Panning sustained
+- pChn->nPanEnvPosition = penv->PanEnv.Ticks[penv->PanEnv.nSustainStart];
+- } else
+- {
+- if (pChn->nPanEnvPosition > penv->PanEnv.Ticks[penv->PanEnv.nNodes - 1])
+- pChn->nPanEnvPosition = penv->PanEnv.Ticks[penv->PanEnv.nNodes - 1];
+- }
+- }
+- // Pitch Envelope
+- if (pChn->dwFlags & CHN_PITCHENV)
+- {
+- // Increase position
+- pChn->nPitchEnvPosition++;
+- // Pitch Loop ?
+- if (penv->dwFlags & ENV_PITCHLOOP)
+- {
+- if (pChn->nPitchEnvPosition >= penv->PitchEnv.Ticks[penv->PitchEnv.nLoopEnd])
+- pChn->nPitchEnvPosition = penv->PitchEnv.Ticks[penv->PitchEnv.nLoopStart];
+- }
+- // Pitch Sustain ?
+- if ((penv->dwFlags & ENV_PITCHSUSTAIN) && (!(pChn->dwFlags & CHN_KEYOFF)))
+- {
+- if (pChn->nPitchEnvPosition == (int)penv->PitchEnv.Ticks[penv->PitchEnv.nSustainEnd]+1)
+- pChn->nPitchEnvPosition = penv->PitchEnv.Ticks[penv->PitchEnv.nSustainStart];
+- } else
+- {
+- if (pChn->nPitchEnvPosition > penv->PitchEnv.Ticks[penv->PitchEnv.nNodes - 1])
+- pChn->nPitchEnvPosition = penv->PitchEnv.Ticks[penv->PitchEnv.nNodes - 1];
+- }
+- }
+- }
+-#if 0
+- // Limit CPU -> > 80% -> don't ramp
+- if ((gnCPUUsage >= 80) && (!pChn->nRealVolume))
+- {
+- pChn->nLeftVol = pChn->nRightVol = 0;
+- }
+-#endif // MODPLUG_PLAYER
+- // Volume ramping
+- pChn->dwFlags &= ~CHN_VOLUMERAMP;
+- if ((pChn->nRealVolume) || (pChn->nLeftVol) || (pChn->nRightVol))
+- pChn->dwFlags |= CHN_VOLUMERAMP;
+- // Decrease VU-Meter
+- if (pChn->nVUMeter > VUMETER_DECAY) pChn->nVUMeter -= VUMETER_DECAY; else pChn->nVUMeter = 0;
+- if (pChn->nLeftVU > VUMETER_DECAY) pChn->nLeftVU -= VUMETER_DECAY; else pChn->nLeftVU = 0;
+- if (pChn->nRightVU > VUMETER_DECAY) pChn->nRightVU -= VUMETER_DECAY; else pChn->nRightVU = 0;
+- // Check for too big nInc
+- if (((pChn->nInc >> 16) + 1) >= (LONG)(pChn->nLoopEnd - pChn->nLoopStart)) pChn->dwFlags &= ~CHN_LOOP;
+- pChn->nNewRightVol = pChn->nNewLeftVol = 0;
+- pChn->pCurrentSample = ((pChn->pSample) && (pChn->nLength) && (pChn->nInc)) ? pChn->pSample : NULL;
+- if (pChn->pCurrentSample)
+- {
+- // Update VU-Meter (nRealVolume is 14-bit)
+- UINT vutmp = pChn->nRealVolume >> (14 - 8);
+- if (vutmp > 0xFF) vutmp = 0xFF;
+- if (pChn->nVUMeter >= 0x100) pChn->nVUMeter = vutmp;
+- vutmp >>= 1;
+- if (pChn->nVUMeter < vutmp) pChn->nVUMeter = vutmp;
+- UINT vul = (pChn->nRealVolume * pChn->nRealPan) >> 14;
+- if (vul > 127) vul = 127;
+- if (pChn->nLeftVU > 127) pChn->nLeftVU = (BYTE)vul;
+- vul >>= 1;
+- if (pChn->nLeftVU < vul) pChn->nLeftVU = (BYTE)vul;
+- UINT vur = (pChn->nRealVolume * (256-pChn->nRealPan)) >> 14;
+- if (vur > 127) vur = 127;
+- if (pChn->nRightVU > 127) pChn->nRightVU = (BYTE)vur;
+- vur >>= 1;
+- if (pChn->nRightVU < vur) pChn->nRightVU = (BYTE)vur;
+-#ifdef MODPLUG_TRACKER
+- UINT kChnMasterVol = (pChn->dwFlags & CHN_EXTRALOUD) ? 0x100 : nMasterVol;
+-#else
+-#define kChnMasterVol nMasterVol
+-#endif // MODPLUG_TRACKER
+- // Adjusting volumes
+- if (gnChannels >= 2)
+- {
+- int pan = ((int)pChn->nRealPan) - 128;
+- pan *= (int)m_nStereoSeparation;
+- pan /= 128;
+- pan += 128;
+-
+- if (pan < 0) pan = 0;
+- if (pan > 256) pan = 256;
+- if (gdwSoundSetup & SNDMIX_REVERSESTEREO) pan = 256 - pan;
+- if (m_dwSongFlags & SONG_NOSTEREO) pan = 128;
+- LONG realvol = (pChn->nRealVolume * kChnMasterVol) >> (8-1);
+- if (gdwSoundSetup & SNDMIX_SOFTPANNING)
+- {
+- if (pan < 128)
+- {
+- pChn->nNewLeftVol = (realvol * pan) >> 8;
+- pChn->nNewRightVol = (realvol * 128) >> 8;
+- } else
+- {
+- pChn->nNewLeftVol = (realvol * 128) >> 8;
+- pChn->nNewRightVol = (realvol * (256 - pan)) >> 8;
+- }
+- } else
+- {
+- pChn->nNewLeftVol = (realvol * pan) >> 8;
+- pChn->nNewRightVol = (realvol * (256 - pan)) >> 8;
+- }
+- } else
+- {
+- pChn->nNewRightVol = (pChn->nRealVolume * kChnMasterVol) >> 8;
+- pChn->nNewLeftVol = pChn->nNewRightVol;
+- }
+- // Clipping volumes
+- if (pChn->nNewRightVol > 0xFFFF) pChn->nNewRightVol = 0xFFFF;
+- if (pChn->nNewLeftVol > 0xFFFF) pChn->nNewLeftVol = 0xFFFF;
+- // Check IDO
+- if (gdwSoundSetup & SNDMIX_NORESAMPLING)
+- {
+- pChn->dwFlags &= ~(CHN_HQSRC);
+- pChn->dwFlags |= CHN_NOIDO;
+- } else
+- {
+- pChn->dwFlags &= ~(CHN_NOIDO|CHN_HQSRC);
+- if( pChn->nInc == 0x10000 )
+- { pChn->dwFlags |= CHN_NOIDO;
+- }
+- else
+- { if( ((gdwSoundSetup & SNDMIX_HQRESAMPLER) == 0) && ((gdwSoundSetup & SNDMIX_ULTRAHQSRCMODE) == 0) )
+- { if (pChn->nInc >= 0xFF00) pChn->dwFlags |= CHN_NOIDO;
+- }
+- }
+- }
+- pChn->nNewRightVol >>= MIXING_ATTENUATION;
+- pChn->nNewLeftVol >>= MIXING_ATTENUATION;
+- pChn->nRightRamp = pChn->nLeftRamp = 0;
+- // Dolby Pro-Logic Surround
+- if ((pChn->dwFlags & CHN_SURROUND) && (gnChannels <= 2) && (gdwSoundSetup & SNDMIX_NOSURROUND) == 0)
+- pChn->nNewLeftVol = -pChn->nNewLeftVol;
+- // Checking Ping-Pong Loops
+- if (pChn->dwFlags & CHN_PINGPONGFLAG) pChn->nInc = -pChn->nInc;
+- // Setting up volume ramp
+- if (!(gdwSoundSetup & SNDMIX_NORAMPING)
+- && (pChn->dwFlags & CHN_VOLUMERAMP)
+- && ((pChn->nRightVol != pChn->nNewRightVol)
+- || (pChn->nLeftVol != pChn->nNewLeftVol)))
+- {
+- LONG nRampLength = gnVolumeRampSamples;
+- LONG nRightDelta = ((pChn->nNewRightVol - pChn->nRightVol) << VOLUMERAMPPRECISION);
+- LONG nLeftDelta = ((pChn->nNewLeftVol - pChn->nLeftVol) << VOLUMERAMPPRECISION);
+-#if 0
+- if ((gdwSoundSetup & SNDMIX_DIRECTTODISK)
+- || ((gdwSysInfo & (SYSMIX_ENABLEMMX|SYSMIX_FASTCPU))
+- && (gdwSoundSetup & SNDMIX_HQRESAMPLER) && (gnCPUUsage <= 20)))
+-#else
+- if (gdwSoundSetup & SNDMIX_HQRESAMPLER)
+-#endif
+- {
+- if ((pChn->nRightVol|pChn->nLeftVol) && (pChn->nNewRightVol|pChn->nNewLeftVol) && (!(pChn->dwFlags & CHN_FASTVOLRAMP)))
+- {
+- nRampLength = m_nBufferCount;
+- if (nRampLength > (1 << (VOLUMERAMPPRECISION-1))) nRampLength = (1 << (VOLUMERAMPPRECISION-1));
+- if (nRampLength < (LONG)gnVolumeRampSamples) nRampLength = gnVolumeRampSamples;
+- }
+- }
+- pChn->nRightRamp = nRightDelta / nRampLength;
+- pChn->nLeftRamp = nLeftDelta / nRampLength;
+- pChn->nRightVol = pChn->nNewRightVol - ((pChn->nRightRamp * nRampLength) >> VOLUMERAMPPRECISION);
+- pChn->nLeftVol = pChn->nNewLeftVol - ((pChn->nLeftRamp * nRampLength) >> VOLUMERAMPPRECISION);
+- if (pChn->nRightRamp|pChn->nLeftRamp)
+- {
+- pChn->nRampLength = nRampLength;
+- } else
+- {
+- pChn->dwFlags &= ~CHN_VOLUMERAMP;
+- pChn->nRightVol = pChn->nNewRightVol;
+- pChn->nLeftVol = pChn->nNewLeftVol;
+- }
+- } else
+- {
+- pChn->dwFlags &= ~CHN_VOLUMERAMP;
+- pChn->nRightVol = pChn->nNewRightVol;
+- pChn->nLeftVol = pChn->nNewLeftVol;
+- }
+- pChn->nRampRightVol = pChn->nRightVol << VOLUMERAMPPRECISION;
+- pChn->nRampLeftVol = pChn->nLeftVol << VOLUMERAMPPRECISION;
+- // Adding the channel in the channel list
+- if (!(pChn->dwFlags & CHN_MUTE)) {
+- ChnMix[m_nMixChannels++] = nChn;
+- if (m_nMixChannels >= MAX_CHANNELS) break;
+- }
+- } else
+- {
+- // Note change but no sample
+- if (pChn->nLeftVU > 128) pChn->nLeftVU = 0;
+- if (pChn->nRightVU > 128) pChn->nRightVU = 0;
+- if (pChn->nVUMeter > 0xFF) pChn->nVUMeter = 0;
+- pChn->nLeftVol = pChn->nRightVol = 0;
+- pChn->nLength = 0;
+- }
+- }
+- // Checking Max Mix Channels reached: ordering by volume
+- if ((m_nMixChannels >= m_nMaxMixChannels) && (!(gdwSoundSetup & SNDMIX_DIRECTTODISK)))
+- {
+- for (UINT i=0; i<m_nMixChannels; i++)
+- {
+- UINT j=i;
+- while ((j+1<m_nMixChannels) && (Chn[ChnMix[j]].nRealVolume < Chn[ChnMix[j+1]].nRealVolume))
+- {
+- UINT n = ChnMix[j];
+- ChnMix[j] = ChnMix[j+1];
+- ChnMix[j+1] = n;
+- j++;
+- }
+- }
+- }
+- if (m_dwSongFlags & SONG_GLOBALFADE)
+- {
+- if (!m_nGlobalFadeSamples)
+- {
+- m_dwSongFlags |= SONG_ENDREACHED;
+- return FALSE;
+- }
+- if (m_nGlobalFadeSamples > m_nBufferCount)
+- m_nGlobalFadeSamples -= m_nBufferCount;
+- else
+- m_nGlobalFadeSamples = 0;
+- }
+- return TRUE;
+-}
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/stdafx.h audacious-plugins-2.5.4/src/modplug/stdafx.h
+--- audacious-plugins-2.5.4-orig/src/modplug/stdafx.h 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/stdafx.h 1970-01-01 01:00:00.000000000 +0100
+@@ -1,94 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Rani Assaf <rani at magic.metawire.com>,
+- * Olivier Lapicque <olivierl at jps.net>,
+- * Adam Goode <adam at evdebs.org> (endian and char fixes for PPC)
+-*/
+-
+-#ifndef _STDAFX_H_
+-#define _STDAFX_H_
+-
+-#ifdef MSC_VER
+-
+-#pragma warning (disable:4201)
+-#pragma warning (disable:4514)
+-#include <windows.h>
+-#include <windowsx.h>
+-#include <mmsystem.h>
+-#include <stdio.h>
+-
+-inline void ProcessPlugins(int n) {}
+-
+-#else
+-
+-#include <stdlib.h>
+-#include <stdio.h>
+-#include <string.h>
+-
+-typedef signed char CHAR;
+-typedef unsigned char UCHAR;
+-typedef unsigned char* PUCHAR;
+-typedef unsigned short USHORT;
+-typedef unsigned int ULONG;
+-typedef unsigned int UINT;
+-typedef unsigned int DWORD;
+-typedef int LONG;
+-typedef unsigned short WORD;
+-typedef unsigned char BYTE;
+-typedef unsigned char * LPBYTE;
+-#ifdef __cplusplus
+-typedef bool BOOL;
+-#endif
+-typedef char * LPSTR;
+-typedef void * LPVOID;
+-typedef int * LPLONG;
+-typedef unsigned int * LPDWORD;
+-typedef unsigned short * LPWORD;
+-typedef const char * LPCSTR;
+-typedef long long LONGLONG;
+-typedef void * PVOID;
+-typedef void VOID;
+-
+-
+-#define NO_AGC
+-#define LPCTSTR LPCSTR
+-#define lstrcpyn strncpy
+-#define lstrcpy strcpy
+-#define lstrcmp strcmp
+-#define WAVE_FORMAT_PCM 1
+-//#define ENABLE_EQ
+-
+-#define GHND 0
+-
+-#ifdef __cplusplus
+-inline signed char * GlobalAllocPtr(unsigned int, size_t size)
+-{
+- signed char * p = (signed char *) malloc(size);
+-
+- if (p != NULL) memset(p, 0, size);
+- return p;
+-}
+-
+-inline void ProcessPlugins(int) {}
+-
+-#define GlobalFreePtr(p) free((void *)(p))
+-
+-#define strnicmp(a,b,c) strncasecmp(a,b,c)
+-#define wsprintf sprintf
+-#endif
+-
+-#ifndef FALSE
+-#define FALSE false
+-#endif
+-
+-#ifndef TRUE
+-#define TRUE true
+-#endif
+-
+-#endif // MSC_VER
+-
+-#endif
+-
+-
+-
+diff -Nur audacious-plugins-2.5.4-orig/src/modplug/tables.cxx audacious-plugins-2.5.4/src/modplug/tables.cxx
+--- audacious-plugins-2.5.4-orig/src/modplug/tables.cxx 2011-07-15 01:00:39.000000000 +0200
++++ audacious-plugins-2.5.4/src/modplug/tables.cxx 1970-01-01 01:00:00.000000000 +0100
+@@ -1,373 +0,0 @@
+-/*
+- * This source code is public domain.
+- *
+- * Authors: Olivier Lapicque <olivierl at jps.net>
+- */
+-
+-#include "stdafx.h"
+-#include "sndfile.h"
+-
+-BYTE ImpulseTrackerPortaVolCmd[16] =
+-{
+- 0x00, 0x01, 0x04, 0x08, 0x10, 0x20, 0x40, 0x60,
+- 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+-};
+-
+-// Period table for Protracker octaves 0-5:
+-WORD ProTrackerPeriodTable[6*12] =
+-{
+- 1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907,
+- 856,808,762,720,678,640,604,570,538,508,480,453,
+- 428,404,381,360,339,320,302,285,269,254,240,226,
+- 214,202,190,180,170,160,151,143,135,127,120,113,
+- 107,101,95,90,85,80,75,71,67,63,60,56,
+- 53,50,47,45,42,40,37,35,33,31,30,28
+-};
+-
+-
+-WORD ProTrackerTunedPeriods[16*12] =
+-{
+- 1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907,
+- 1700,1604,1514,1430,1348,1274,1202,1134,1070,1010,954,900,
+- 1688,1592,1504,1418,1340,1264,1194,1126,1064,1004,948,894,
+- 1676,1582,1492,1408,1330,1256,1184,1118,1056,996,940,888,
+- 1664,1570,1482,1398,1320,1246,1176,1110,1048,990,934,882,
+- 1652,1558,1472,1388,1310,1238,1168,1102,1040,982,926,874,
+- 1640,1548,1460,1378,1302,1228,1160,1094,1032,974,920,868,
+- 1628,1536,1450,1368,1292,1220,1150,1086,1026,968,914,862,
+- 1814,1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,
+- 1800,1700,1604,1514,1430,1350,1272,1202,1134,1070,1010,954,
+- 1788,1688,1592,1504,1418,1340,1264,1194,1126,1064,1004,948,
+- 1774,1676,1582,1492,1408,1330,1256,1184,1118,1056,996,940,
+- 1762,1664,1570,1482,1398,1320,1246,1176,1110,1048,988,934,
+- 1750,1652,1558,1472,1388,1310,1238,1168,1102,1040,982,926,
+- 1736,1640,1548,1460,1378,1302,1228,1160,1094,1032,974,920,
+- 1724,1628,1536,1450,1368,1292,1220,1150,1086,1026,968,914
+-};
+-
+-
+-// S3M C-4 periods
+-WORD FreqS3MTable[16] =
+-{
+- 1712,1616,1524,1440,1356,1280,
+- 1208,1140,1076,1016,960,907,
+- 0,0,0,0
+-};
+-
+-
+-// S3M FineTune frequencies
+-WORD S3MFineTuneTable[16] =
+-{
+- 7895,7941,7985,8046,8107,8169,8232,8280,
+- 8363,8413,8463,8529,8581,8651,8723,8757, // 8363*2^((i-8)/(12*8))
+-};
+-
+-
+-// Sinus table
+-short int ModSinusTable[64] =
+-{
+- 0,12,25,37,49,60,71,81,90,98,106,112,117,122,125,126,
+- 127,126,125,122,117,112,106,98,90,81,71,60,49,37,25,12,
+- 0,-12,-25,-37,-49,-60,-71,-81,-90,-98,-106,-112,-117,-122,-125,-126,
+- -127,-126,-125,-122,-117,-112,-106,-98,-90,-81,-71,-60,-49,-37,-25,-12
+-};
+-
+-// Triangle wave table (ramp down)
+-short int ModRampDownTable[64] =
+-{
+- 0,-4,-8,-12,-16,-20,-24,-28,-32,-36,-40,-44,-48,-52,-56,-60,
+- -64,-68,-72,-76,-80,-84,-88,-92,-96,-100,-104,-108,-112,-116,-120,-124,
+- 127,123,119,115,111,107,103,99,95,91,87,83,79,75,71,67,
+- 63,59,55,51,47,43,39,35,31,27,23,19,15,11,7,3
+-};
+-
+-// Square wave table
+-short int ModSquareTable[64] =
+-{
+- 127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,
+- 127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,
+- -127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,
+- -127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127,-127
+-};
+-
+-// Random wave table
+-short int ModRandomTable[64] =
+-{
+- 98,-127,-43,88,102,41,-65,-94,125,20,-71,-86,-70,-32,-16,-96,
+- 17,72,107,-5,116,-69,-62,-40,10,-61,65,109,-18,-38,-13,-76,
+- -23,88,21,-94,8,106,21,-112,6,109,20,-88,-30,9,-127,118,
+- 42,-34,89,-4,-51,-72,21,-29,112,123,84,-101,-92,98,-54,-95
+-};
+-
+-
+-// volume fade tables for Retrig Note:
+-signed char retrigTable1[16] =
+-{ 0, 0, 0, 0, 0, 0, 10, 8, 0, 0, 0, 0, 0, 0, 24, 32 };
+-
+-signed char retrigTable2[16] =
+-{ 0, -1, -2, -4, -8, -16, 0, 0, 0, 1, 2, 4, 8, 16, 0, 0 };
+-
+-
+-
+-
+-WORD XMPeriodTable[104] =
+-{
+- 907,900,894,887,881,875,868,862,856,850,844,838,832,826,820,814,
+- 808,802,796,791,785,779,774,768,762,757,752,746,741,736,730,725,
+- 720,715,709,704,699,694,689,684,678,675,670,665,660,655,651,646,
+- 640,636,632,628,623,619,614,610,604,601,597,592,588,584,580,575,
+- 570,567,563,559,555,551,547,543,538,535,532,528,524,520,516,513,
+- 508,505,502,498,494,491,487,484,480,477,474,470,467,463,460,457,
+- 453,450,447,443,440,437,434,431
+-};
+-
+-
+-UINT XMLinearTable[768] =
+-{
+- 535232,534749,534266,533784,533303,532822,532341,531861,
+- 531381,530902,530423,529944,529466,528988,528511,528034,
+- 527558,527082,526607,526131,525657,525183,524709,524236,
+- 523763,523290,522818,522346,521875,521404,520934,520464,
+- 519994,519525,519057,518588,518121,517653,517186,516720,
+- 516253,515788,515322,514858,514393,513929,513465,513002,
+- 512539,512077,511615,511154,510692,510232,509771,509312,
+- 508852,508393,507934,507476,507018,506561,506104,505647,
+- 505191,504735,504280,503825,503371,502917,502463,502010,
+- 501557,501104,500652,500201,499749,499298,498848,498398,
+- 497948,497499,497050,496602,496154,495706,495259,494812,
+- 494366,493920,493474,493029,492585,492140,491696,491253,
+- 490809,490367,489924,489482,489041,488600,488159,487718,
+- 487278,486839,486400,485961,485522,485084,484647,484210,
+- 483773,483336,482900,482465,482029,481595,481160,480726,
+- 480292,479859,479426,478994,478562,478130,477699,477268,
+- 476837,476407,475977,475548,475119,474690,474262,473834,
+- 473407,472979,472553,472126,471701,471275,470850,470425,
+- 470001,469577,469153,468730,468307,467884,467462,467041,
+- 466619,466198,465778,465358,464938,464518,464099,463681,
+- 463262,462844,462427,462010,461593,461177,460760,460345,
+- 459930,459515,459100,458686,458272,457859,457446,457033,
+- 456621,456209,455797,455386,454975,454565,454155,453745,
+- 453336,452927,452518,452110,451702,451294,450887,450481,
+- 450074,449668,449262,448857,448452,448048,447644,447240,
+- 446836,446433,446030,445628,445226,444824,444423,444022,
+- 443622,443221,442821,442422,442023,441624,441226,440828,
+- 440430,440033,439636,439239,438843,438447,438051,437656,
+- 437261,436867,436473,436079,435686,435293,434900,434508,
+- 434116,433724,433333,432942,432551,432161,431771,431382,
+- 430992,430604,430215,429827,429439,429052,428665,428278,
+- 427892,427506,427120,426735,426350,425965,425581,425197,
+- 424813,424430,424047,423665,423283,422901,422519,422138,
+- 421757,421377,420997,420617,420237,419858,419479,419101,
+- 418723,418345,417968,417591,417214,416838,416462,416086,
+- 415711,415336,414961,414586,414212,413839,413465,413092,
+- 412720,412347,411975,411604,411232,410862,410491,410121,
+- 409751,409381,409012,408643,408274,407906,407538,407170,
+- 406803,406436,406069,405703,405337,404971,404606,404241,
+- 403876,403512,403148,402784,402421,402058,401695,401333,
+- 400970,400609,400247,399886,399525,399165,398805,398445,
+- 398086,397727,397368,397009,396651,396293,395936,395579,
+- 395222,394865,394509,394153,393798,393442,393087,392733,
+- 392378,392024,391671,391317,390964,390612,390259,389907,
+- 389556,389204,388853,388502,388152,387802,387452,387102,
+- 386753,386404,386056,385707,385359,385012,384664,384317,
+- 383971,383624,383278,382932,382587,382242,381897,381552,
+- 381208,380864,380521,380177,379834,379492,379149,378807,
+-
+- 378466,378124,377783,377442,377102,376762,376422,376082,
+- 375743,375404,375065,374727,374389,374051,373714,373377,
+- 373040,372703,372367,372031,371695,371360,371025,370690,
+- 370356,370022,369688,369355,369021,368688,368356,368023,
+- 367691,367360,367028,366697,366366,366036,365706,365376,
+- 365046,364717,364388,364059,363731,363403,363075,362747,
+- 362420,362093,361766,361440,361114,360788,360463,360137,
+- 359813,359488,359164,358840,358516,358193,357869,357547,
+- 357224,356902,356580,356258,355937,355616,355295,354974,
+- 354654,354334,354014,353695,353376,353057,352739,352420,
+- 352103,351785,351468,351150,350834,350517,350201,349885,
+- 349569,349254,348939,348624,348310,347995,347682,347368,
+- 347055,346741,346429,346116,345804,345492,345180,344869,
+- 344558,344247,343936,343626,343316,343006,342697,342388,
+- 342079,341770,341462,341154,340846,340539,340231,339924,
+- 339618,339311,339005,338700,338394,338089,337784,337479,
+- 337175,336870,336566,336263,335959,335656,335354,335051,
+- 334749,334447,334145,333844,333542,333242,332941,332641,
+- 332341,332041,331741,331442,331143,330844,330546,330247,
+- 329950,329652,329355,329057,328761,328464,328168,327872,
+- 327576,327280,326985,326690,326395,326101,325807,325513,
+- 325219,324926,324633,324340,324047,323755,323463,323171,
+- 322879,322588,322297,322006,321716,321426,321136,320846,
+- 320557,320267,319978,319690,319401,319113,318825,318538,
+- 318250,317963,317676,317390,317103,316817,316532,316246,
+- 315961,315676,315391,315106,314822,314538,314254,313971,
+- 313688,313405,313122,312839,312557,312275,311994,311712,
+- 311431,311150,310869,310589,310309,310029,309749,309470,
+- 309190,308911,308633,308354,308076,307798,307521,307243,
+- 306966,306689,306412,306136,305860,305584,305308,305033,
+- 304758,304483,304208,303934,303659,303385,303112,302838,
+- 302565,302292,302019,301747,301475,301203,300931,300660,
+- 300388,300117,299847,299576,299306,299036,298766,298497,
+- 298227,297958,297689,297421,297153,296884,296617,296349,
+- 296082,295815,295548,295281,295015,294749,294483,294217,
+- 293952,293686,293421,293157,292892,292628,292364,292100,
+- 291837,291574,291311,291048,290785,290523,290261,289999,
+- 289737,289476,289215,288954,288693,288433,288173,287913,
+- 287653,287393,287134,286875,286616,286358,286099,285841,
+- 285583,285326,285068,284811,284554,284298,284041,283785,
+- 283529,283273,283017,282762,282507,282252,281998,281743,
+- 281489,281235,280981,280728,280475,280222,279969,279716,
+- 279464,279212,278960,278708,278457,278206,277955,277704,
+- 277453,277203,276953,276703,276453,276204,275955,275706,
+- 275457,275209,274960,274712,274465,274217,273970,273722,
+- 273476,273229,272982,272736,272490,272244,271999,271753,
+- 271508,271263,271018,270774,270530,270286,270042,269798,
+- 269555,269312,269069,268826,268583,268341,268099,267857
+-};
+-
+-
+-signed char ft2VibratoTable[256] =
+-{
+- 0,-2,-3,-5,-6,-8,-9,-11,-12,-14,-16,-17,-19,-20,-22,-23,
+- -24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,
+- -43,-44,-45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,
+- -56,-57,-58,-59,-59,-60,-60,-61,-61,-62,-62,-62,-63,-63,
+- -63,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-63,-63,
+- -63,-62,-62,-62,-61,-61,-60,-60,-59,-59,-58,-57,-56,-56,
+- -55,-54,-53,-52,-51,-50,-49,-48,-47,-46,-45,-44,-43,-42,
+- -41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26,-24,-23,
+- -22,-20,-19,-17,-16,-14,-12,-11,-9,-8,-6,-5,-3,-2,0,
+- 2,3,5,6,8,9,11,12,14,16,17,19,20,22,23,24,26,27,29,30,
+- 32,33,34,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,
+- 52,53,54,55,56,56,57,58,59,59,60,60,61,61,62,62,62,63,
+- 63,63,64,64,64,64,64,64,64,64,64,64,64,63,63,63,62,62,
+- 62,61,61,60,60,59,59,58,57,56,56,55,54,53,52,51,50,49,
+- 48,47,46,45,44,43,42,41,39,38,37,36,34,33,32,30,29,27,
+- 26,24,23,22,20,19,17,16,14,12,11,9,8,6,5,3,2
+-};
+-
+-
+-
+-DWORD FineLinearSlideUpTable[16] =
+-{
+- 65536, 65595, 65654, 65714, 65773, 65832, 65892, 65951,
+- 66011, 66071, 66130, 66190, 66250, 66309, 66369, 66429
+-};
+-
+-
+-DWORD FineLinearSlideDownTable[16] =
+-{
+- 65535, 65477, 65418, 65359, 65300, 65241, 65182, 65123,
+- 65065, 65006, 64947, 64888, 64830, 64772, 64713, 64645
+-};
+-
+-
+-DWORD LinearSlideUpTable[256] =
+-{
+- 65536, 65773, 66010, 66249, 66489, 66729, 66971, 67213,
+- 67456, 67700, 67945, 68190, 68437, 68685, 68933, 69182,
+- 69432, 69684, 69936, 70189, 70442, 70697, 70953, 71209,
+- 71467, 71725, 71985, 72245, 72507, 72769, 73032, 73296,
+- 73561, 73827, 74094, 74362, 74631, 74901, 75172, 75444,
+- 75717, 75991, 76265, 76541, 76818, 77096, 77375, 77655,
+- 77935, 78217, 78500, 78784, 79069, 79355, 79642, 79930,
+- 80219, 80509, 80800, 81093, 81386, 81680, 81976, 82272,
+- 82570, 82868, 83168, 83469, 83771, 84074, 84378, 84683,
+- 84989, 85297, 85605, 85915, 86225, 86537, 86850, 87164,
+- 87480, 87796, 88113, 88432, 88752, 89073, 89395, 89718,
+- 90043, 90369, 90695, 91023, 91353, 91683, 92015, 92347,
+- 92681, 93017, 93353, 93691, 94029, 94370, 94711, 95053,
+- 95397, 95742, 96088, 96436, 96785, 97135, 97486, 97839,
+- 98193, 98548, 98904, 99262, 99621, 99981, 100343, 100706,
+- 101070, 101435, 101802, 102170, 102540, 102911, 103283, 103657,
+- 104031, 104408, 104785, 105164, 105545, 105926, 106309, 106694,
+- 107080, 107467, 107856, 108246, 108637, 109030, 109425, 109820,
+- 110217, 110616, 111016, 111418, 111821, 112225, 112631, 113038,
+- 113447, 113857, 114269, 114682, 115097, 115514, 115931, 116351,
+- 116771, 117194, 117618, 118043, 118470, 118898, 119328, 119760,
+- 120193, 120628, 121064, 121502, 121941, 122382, 122825, 123269,
+- 123715, 124162, 124611, 125062, 125514, 125968, 126424, 126881,
+- 127340, 127801, 128263, 128727, 129192, 129660, 130129, 130599,
+- 131072, 131546, 132021, 132499, 132978, 133459, 133942, 134426,
+- 134912, 135400, 135890, 136381, 136875, 137370, 137866, 138365,
+- 138865, 139368, 139872, 140378, 140885, 141395, 141906, 142419,
+- 142935, 143451, 143970, 144491, 145014, 145538, 146064, 146593,
+- 147123, 147655, 148189, 148725, 149263, 149803, 150344, 150888,
+- 151434, 151982, 152531, 153083, 153637, 154192, 154750, 155310,
+- 155871, 156435, 157001, 157569, 158138, 158710, 159284, 159860,
+- 160439, 161019, 161601, 162186, 162772, 163361, 163952, 164545,
+-};
+-
+-
+-DWORD LinearSlideDownTable[256] =
+-{
+- 65536, 65299, 65064, 64830, 64596, 64363, 64131, 63900,
+- 63670, 63440, 63212, 62984, 62757, 62531, 62305, 62081,
+- 61857, 61634, 61412, 61191, 60970, 60751, 60532, 60314,
+- 60096, 59880, 59664, 59449, 59235, 59021, 58809, 58597,
+- 58385, 58175, 57965, 57757, 57548, 57341, 57134, 56928,
+- 56723, 56519, 56315, 56112, 55910, 55709, 55508, 55308,
+- 55108, 54910, 54712, 54515, 54318, 54123, 53928, 53733,
+-
+- 53540, 53347, 53154, 52963, 52772, 52582, 52392, 52204,
+- 52015, 51828, 51641, 51455, 51270, 51085, 50901, 50717,
+- 50535, 50353, 50171, 49990, 49810, 49631, 49452, 49274,
+- 49096, 48919, 48743, 48567, 48392, 48218, 48044, 47871,
+- 47698, 47526, 47355, 47185, 47014, 46845, 46676, 46508,
+- 46340, 46173, 46007, 45841, 45676, 45511, 45347, 45184,
+- 45021, 44859, 44697, 44536, 44376, 44216, 44056, 43898,
+- 43740, 43582, 43425, 43268, 43112, 42957, 42802, 42648,
+- 42494, 42341, 42189, 42037, 41885, 41734, 41584, 41434,
+- 41285, 41136, 40988, 40840, 40693, 40546, 40400, 40254,
+- 40109, 39965, 39821, 39677, 39534, 39392, 39250, 39108,
+- 38967, 38827, 38687, 38548, 38409, 38270, 38132, 37995,
+- 37858, 37722, 37586, 37450, 37315, 37181, 37047, 36913,
+- 36780, 36648, 36516, 36384, 36253, 36122, 35992, 35862,
+- 35733, 35604, 35476, 35348, 35221, 35094, 34968, 34842,
+- 34716, 34591, 34466, 34342, 34218, 34095, 33972, 33850,
+- 33728, 33606, 33485, 33364, 33244, 33124, 33005, 32886,
+- 32768, 32649, 32532, 32415, 32298, 32181, 32065, 31950,
+- 31835, 31720, 31606, 31492, 31378, 31265, 31152, 31040,
+- 30928, 30817, 30706, 30595, 30485, 30375, 30266, 30157,
+- 30048, 29940, 29832, 29724, 29617, 29510, 29404, 29298,
+- 29192, 29087, 28982, 28878, 28774, 28670, 28567, 28464,
+- 28361, 28259, 28157, 28056, 27955, 27854, 27754, 27654,
+- 27554, 27455, 27356, 27257, 27159, 27061, 26964, 26866,
+- 26770, 26673, 26577, 26481, 26386, 26291, 26196, 26102,
+-};
+-
+-
+-int SpectrumSinusTable[256*2] =
+-{
+- 0, 1, 1, 2, 3, 3, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11,
+- 12, 13, 14, 14, 15, 16, 17, 17, 18, 19, 20, 20, 21, 22, 22, 23,
+- 24, 25, 25, 26, 27, 28, 28, 29, 30, 30, 31, 32, 32, 33, 34, 34,
+- 35, 36, 36, 37, 38, 38, 39, 39, 40, 41, 41, 42, 42, 43, 44, 44,
+- 45, 45, 46, 46, 47, 47, 48, 48, 49, 49, 50, 50, 51, 51, 52, 52,
+- 53, 53, 53, 54, 54, 55, 55, 55, 56, 56, 57, 57, 57, 58, 58, 58,
+- 59, 59, 59, 59, 60, 60, 60, 60, 61, 61, 61, 61, 61, 62, 62, 62,
+- 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+- 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 62, 62,
+- 62, 62, 62, 62, 61, 61, 61, 61, 61, 60, 60, 60, 60, 59, 59, 59,
+- 59, 58, 58, 58, 57, 57, 57, 56, 56, 55, 55, 55, 54, 54, 53, 53,
+- 53, 52, 52, 51, 51, 50, 50, 49, 49, 48, 48, 47, 47, 46, 46, 45,
+- 45, 44, 44, 43, 42, 42, 41, 41, 40, 39, 39, 38, 38, 37, 36, 36,
+- 35, 34, 34, 33, 32, 32, 31, 30, 30, 29, 28, 28, 27, 26, 25, 25,
+- 24, 23, 22, 22, 21, 20, 20, 19, 18, 17, 17, 16, 15, 14, 14, 13,
+- 12, 11, 10, 10, 9, 8, 7, 7, 6, 5, 4, 3, 3, 2, 1, 0,
+- 0, -1, -1, -2, -3, -3, -4, -5, -6, -7, -7, -8, -9, -10, -10, -11,
+- -12, -13, -14, -14, -15, -16, -17, -17, -18, -19, -20, -20, -21, -22, -22, -23,
+- -24, -25, -25, -26, -27, -28, -28, -29, -30, -30, -31, -32, -32, -33, -34, -34,
+- -35, -36, -36, -37, -38, -38, -39, -39, -40, -41, -41, -42, -42, -43, -44, -44,
+- -45, -45, -46, -46, -47, -47, -48, -48, -49, -49, -50, -50, -51, -51, -52, -52,
+- -53, -53, -53, -54, -54, -55, -55, -55, -56, -56, -57, -57, -57, -58, -58, -58,
+- -59, -59, -59, -59, -60, -60, -60, -60, -61, -61, -61, -61, -61, -62, -62, -62,
+- -62, -62, -62, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63,
+- -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -62, -62,
+- -62, -62, -62, -62, -61, -61, -61, -61, -61, -60, -60, -60, -60, -59, -59, -59,
+- -59, -58, -58, -58, -57, -57, -57, -56, -56, -55, -55, -55, -54, -54, -53, -53,
+- -53, -52, -52, -51, -51, -50, -50, -49, -49, -48, -48, -47, -47, -46, -46, -45,
+- -45, -44, -44, -43, -42, -42, -41, -41, -40, -39, -39, -38, -38, -37, -36, -36,
+- -35, -34, -34, -33, -32, -32, -31, -30, -30, -29, -28, -28, -27, -26, -25, -25,
+- -24, -23, -22, -22, -21, -20, -20, -19, -18, -17, -17, -16, -15, -14, -14, -13,
+- -12, -11, -10, -10, -9, -8, -7, -7, -6, -5, -4, -3, -3, -2, -1, 0,
+-};
+-
diff --git a/audacious-plugins.spec b/audacious-plugins.spec
index a29523f..ed16ee3 100644
--- a/audacious-plugins.spec
+++ b/audacious-plugins.spec
@@ -10,7 +10,7 @@ Requires: audacious >= %{aud_ver}
Name: audacious-plugins
Version: 2.5.4
-Release: 1%{?dist}
+Release: 2%{?dist}
Summary: Plugins for the Audacious audio player
Group: Applications/Multimedia
URL: http://audacious-media-player.org/
@@ -33,9 +33,13 @@ Patch1: audacious-plugins-2.4-libdir.patch
Patch4: audacious-plugins-2.5.4-streambrowser.patch
#
Patch5: audacious-plugins-2.5.3-moodbar.patch
+#
+Patch6: audacious-plugins-2.5.4-libmodplug-system.patch
+
+BuildRequires: autoconf
BuildRequires: audacious-devel >= %{aud_ver}
-BuildRequires: gettext
+BuildRequires: gettext-devel
BuildRequires: desktop-file-utils
BuildRequires: jack-audio-connection-kit-devel
BuildRequires: libsamplerate-devel
@@ -159,6 +163,8 @@ providers may build it with libsidplay 2 instead.
%patch1 -p1 -b .libdir
%patch4 -p1 -b .streambrowser
%patch5 -p1 -b .moodbar
+%patch6 -p1 -b .libmodplug-system
+autoreconf -I m4
for i in src/ladspa/ladspa.c
do
@@ -273,6 +279,9 @@ update-desktop-database &> /dev/null || :
%changelog
+* Thu Sep 8 2011 Michael Schwendt <mschwendt at fedoraproject.org> - 2.5.4-2
+- Patch to use system's libmodplug (BR libmodplug-devel).
+
* Fri Jul 15 2011 Michael Schwendt <mschwendt at fedoraproject.org> - 2.5.4-1
- Update to 2.5.4 (merged patches, minor fixes, 8k diff).
More information about the scm-commits
mailing list