1 files changed, 984 insertions, 0 deletions

diff --git a/core/multimedia/opieplayer/modplug/sndfile.h b/core/multimedia/opieplayer/modplug/sndfile.h
new file mode 100644
index 0000000..8017116
--- a/dev/null
+++ b/core/multimedia/opieplayer/modplug/sndfile.h
@@ -0,0 +1,984 @@
+/*
+ * 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@jps.net>,
+ *          Adam Goode       <adam@evdebs.org> (endian and char fixes for PPC)
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef __SNDFILE_H
+#define __SNDFILE_H
+
+#ifndef LPCBYTE
+typedef const BYTE * LPCBYTE;
+#endif
+
+        #define MOD_AMIGAC2             0x1AB
+        #define MAX_SAMPLE_LENGTH16000000
+        #define MAX_SAMPLE_RATE         50000
+        #define MAX_ORDERS              256
+        #define MAX_PATTERNS    240
+        #define MAX_SAMPLES             240
+        #define MAX_INSTRUMENTS         MAX_SAMPLES
+#ifdef FASTSOUNDLIB
+        #define MAX_CHANNELS    80
+#else
+        #define MAX_CHANNELS    128
+#endif
+        #define MAX_BASECHANNELS64
+        #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_J2B    0x800000
+        #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_PINGPONGLOOP0x04
+        #define CHN_SUSTAINLOOP         0x08
+        #define CHN_PINGPONGSUSTAIN0x10
+        #define CHN_PANNING             0x20
+        #define CHN_STEREO              0x40
+        #define CHN_PINGPONGFLAG0x80
+        // 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
+
+
+        #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_PITCHSUSTAIN0x0080
+        #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 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_XFINEPORTAUPDOWN28
+        #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_PANSLIDERIGHT10
+        #define VOLCMD_TONEPORTAMENTO11
+        #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_PTM8DTO160x25
+// 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_CONTINUE1
+        #define NNA_NOTEOFF     2
+        #define NNA_NOTEFADE3
+
+// DCT types
+        #define DCT_NONE        0
+        #define DCT_NOTE        1
+        #define DCT_SAMPLE      2
+        #define DCT_INSTRUMENT3
+
+// DNA types
+        #define DNA_NOTECUT     0
+        #define DNA_NOTEOFF     1
+        #define DNA_NOTEFADE2
+
+// Mixer Hardware-Dependent features
+        #define SYSMIX_ENABLEMMX0x01
+        #define SYSMIX_WINDOWSNT0x02
+        #define SYSMIX_SLOWCPU  0x04
+        #define SYSMIX_FASTCPU  0x08
+
+// Module flags
+        #define SONG_EMBEDMIDICFG0x0001
+        #define SONG_FASTVOLSLIDES0x0002
+        #define SONG_ITOLDEFFECTS0x0004
+        #define SONG_ITCOMPATMODE0x0008
+        #define SONG_LINEARSLIDES0x0010
+        #define SONG_PATTERNLOOP0x0020
+        #define SONG_STEP               0x0040
+        #define SONG_PAUSED             0x0080
+        #define SONG_FADINGSONG         0x0100
+        #define SONG_ENDREACHED         0x0200
+        #define SONG_GLOBALFADE         0x0400
+        #define SONG_CPUVERYHIGH0x0800
+        #define SONG_FIRSTTICK  0x1000
+        #define SONG_MPTFILTERMODE0x2000
+        #define SONG_SURROUNDPAN0x4000
+        #define SONG_EXFILTERRANGE0x8000
+        #define SONG_AMIGALIMITS0x10000
+
+// Global Options (Renderer)
+        #define SNDMIX_REVERSESTEREO0x0001
+        #define SNDMIX_NOISEREDUCTION0x0002
+        #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_ULTRAHQSRCMODE0x0400
+// Misc Flags (can safely be turned on or off)
+        #define SNDMIX_DIRECTTODISK     0x10000
+        #define SNDMIX_ENABLEMMX        0x20000
+        #define SNDMIX_NOBACKWARDJUMPS0x40000
+        #define SNDMIX_MAXDEFAULTPAN    0x80000// Used by the MOD loader
+
+
+// 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;
+        WORD nPan;
+        WORD nVolume;
+        WORD nGlobalVol;
+        WORD uFlags;
+        signed char RelativeTone;
+        signed char nFineTune;
+        BYTE nVibType;
+        BYTE nVibSweep;
+        BYTE nVibDepth;
+        BYTE nVibRate;
+        CHAR name[22];
+} MODINSTRUMENT;
+
+
+// Instrument Struct
+typedef struct _INSTRUMENTHEADER
+{
+        UINT nFadeOut;
+        DWORD dwFlags;
+        WORD nGlobalVol;
+        WORD nPan;
+        WORD VolPoints[MAX_ENVPOINTS];
+        WORD PanPoints[MAX_ENVPOINTS];
+        WORD PitchPoints[MAX_ENVPOINTS];
+        BYTE VolEnv[MAX_ENVPOINTS];
+        BYTE PanEnv[MAX_ENVPOINTS];
+        BYTE PitchEnv[MAX_ENVPOINTS];
+        BYTE Keyboard[128];
+        BYTE NoteMap[128];
+
+        BYTE nVolEnv;
+        BYTE nPanEnv;
+        BYTE nPitchEnv;
+        BYTE nVolLoopStart;
+        BYTE nVolLoopEnd;
+        BYTE nVolSustainBegin;
+        BYTE nVolSustainEnd;
+        BYTE nPanLoopStart;
+        BYTE nPanLoopEnd;
+        BYTE nPanSustainBegin;
+        BYTE nPanSustainEnd;
+        BYTE nPitchLoopStart;
+        BYTE nPitchLoopEnd;
+        BYTE nPitchSustainBegin;
+        BYTE nPitchSustainEnd;
+        BYTE nNNA;
+        BYTE nDCT;
+        BYTE nDNA;
+        BYTE nPanSwing;
+        BYTE nVolSwing;
+        BYTE nIFC;
+        BYTE nIFR;
+        WORD wMidiBank;
+        BYTE nMidiProgram;
+        BYTE nMidiChannel;
+        BYTE nMidiDrumKey;
+        signed char nPPS;
+        unsigned char nPPC;
+        CHAR name[32];
+        CHAR filename[12];
+} 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
+                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;
+        LONG nFilter_Y1, nFilter_Y2, nFilter_Y3, nFilter_Y4;
+        LONG 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, nPortamentoDest;
+        INSTRUMENTHEADER *pHeader;
+        MODINSTRUMENT *pInstrument;
+        DWORD nVolEnvPosition, nPanEnvPosition, nPitchEnvPosition;
+        DWORD nMasterChn, nVUMeter;
+        LONG nGlobalVol, nInsVol;
+        LONG nFineTune, nTranspose;
+        LONG nPortamentoSlide, nAutoVibDepth;
+        UINT nAutoVibPos, nVibratoPos, nTremoloPos, nPanbrelloPos;
+        // 16-bit members
+        signed short nVolSwing, nPanSwing;
+        // 8-bit members
+        BYTE nNote, nNNA;
+        BYTE nNewNote, nNewIns, nCommand, nArpeggio;
+        BYTE nOldVolumeSlide, nOldFineVolUpDown;
+        BYTE nOldPortaUpDown, nOldFinePortaUpDown;
+        BYTE nOldPanSlide, nOldChnVolSlide;
+        BYTE nVibratoType, nVibratoSpeed, nVibratoDepth;
+        BYTE nTremoloType, nTremoloSpeed, nTremoloDepth;
+        BYTE nPanbrelloType, nPanbrelloSpeed, nPanbrelloDepth;
+        BYTE nOldCmdEx, nOldVolParam, nOldTempo;
+        BYTE nOldOffset, nOldHiOffset;
+        BYTE nCutOff, nResonance;
+        BYTE nRetrigCount, nRetrigParam;
+        BYTE nTremorCount, nTremorParam;
+        BYTE nPatternLoop, nPatternLoopCount;
+        BYTE nRowNote, nRowInstr;
+        BYTE nRowVolCmd, nRowVolume;
+        BYTE nRowCommand, nRowParam;
+        BYTE nLeftVU, nRightVU;
+        BYTE nActiveMacro, nPadding;
+} 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 int AddRef() = 0;
+        virtual int Release() = 0;
+        virtual void SaveAllParameters() = 0;
+        virtual void RestoreAllParameters() = 0;
+        virtual void Process(float *pOutL, float *pOutR, unsigned long nSamples) = 0;
+        virtual void Init(unsigned long 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;
+
+        typedefBOOL (__cdecl *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 (__cdecl * LPSNDMIXHOOKPROC)(int *, unsigned long, unsigned long); // 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_nStereoSeparation;
+        static UINT m_nMaxMixChannels;
+        static LONG m_nStreamVolume;
+        static DWORD gdwSysInfo, gdwSoundSetup, gdwMixingFreq, gnBitsPerSample, gnChannels;
+        static UINT gnAGC, gnVolumeRampSamples, gnVUMeter, gnCPUUsage;
+        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
+                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_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_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;
+        UINT m_nMaxOrderPosition;
+        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 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 ReadJ2B(LPCBYTE lpStream, DWORD dwMemLength);
+        BOOL ReadUMX(LPCBYTE lpStream, DWORD dwMemLength);
+        // Save Functions
+#ifndef MODPLUG_NO_FILESAVE
+        UINT WriteSample(FILE *f, MODINSTRUMENT *pins, UINT nFlags, UINT nMaxLen=0);
+        BOOL SaveXM(LPCSTR lpszFileName, UINT nPacking=0);
+        BOOL SaveS3M(LPCSTR lpszFileName, UINT nPacking=0);
+        BOOL SaveMod(LPCSTR lpszFileName, UINT nPacking=0);
+        BOOL SaveIT(LPCSTR lpszFileName, UINT nPacking=0);
+#endif // MODPLUG_NO_FILESAVE
+        // 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:
+        // 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);
+
+        //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) const;
+        void CheckNNA(UINT nChn, UINT instr, int note, BOOL bForceCut);
+        void NoteChange(UINT nChn, int note, BOOL bPorta=FALSE, BOOL bResetEnv=TRUE);
+        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 ProcessMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param=0);
+        void SetupChannelFilter(MODCHANNEL *pChn, BOOL bReset, int flt_modifier=256) 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 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);
+#ifndef NO_FILTER
+        DWORD CutOffToFrequency(UINT nCutOff, int flt_modifier=256) const; // [0-255] => [1-10KHz]
+#endif
+
+        // 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_ATTENUATION4
+        #define MIXING_CLIPMIN  (-0x08000000)
+        #define MIXING_CLIPMAX  (0x07FFFFFF)
+        #define VOLUMERAMPPRECISION12
+        #define FADESONGDELAY   100
+        #define EQ_BUFFERSIZE   (MIXBUFFERSIZE)
+        #define AGC_PRECISION   9
+        #define AGC_UNITY               (1 << AGC_PRECISION)
+
+// Calling conventions
+#ifdef WIN32
+        #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 ))
+
+int _muldiv(long a, long b, long c);
+int _muldivr(long a, long b, long 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
+
+
+// From libsdl
+#ifdef 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