gosu 0.15.2 → 1.0.0.pre1

data/dependencies/SDL_sound/libmodplug/modplug.h

@@ -0,0 +1,90 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Kenton Varda <temporal@gauge3d.org> (C interface wrapper)
+ */
+
+#ifndef MODPLUG_H__INCLUDED
+#define MODPLUG_H__INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MODPLUG_EXPORT
+
+struct _ModPlugFile;
+typedef struct _ModPlugFile ModPlugFile;
+
+enum _ModPlug_Flags
+{
+	MODPLUG_ENABLE_OVERSAMPLING     = 1 << 0,  /* Enable oversampling (*highly* recommended) */
+	MODPLUG_ENABLE_NOISE_REDUCTION  = 1 << 1,  /* Enable noise reduction */
+	MODPLUG_ENABLE_REVERB           = 1 << 2,  /* Enable reverb */
+	MODPLUG_ENABLE_MEGABASS         = 1 << 3,  /* Enable megabass */
+	MODPLUG_ENABLE_SURROUND         = 1 << 4   /* Enable surround sound. */
+};
+
+enum _ModPlug_ResamplingMode
+{
+	MODPLUG_RESAMPLE_NEAREST = 0,  /* No interpolation (very fast, extremely bad sound quality) */
+	MODPLUG_RESAMPLE_LINEAR  = 1,  /* Linear interpolation (fast, good quality) */
+	MODPLUG_RESAMPLE_SPLINE  = 2,  /* Cubic spline interpolation (high quality) */
+	MODPLUG_RESAMPLE_FIR     = 3   /* 8-tap fir filter (extremely high quality) */
+};
+
+typedef struct _ModPlug_Settings
+{
+	int mFlags;  /* One or more of the MODPLUG_ENABLE_* flags above, bitwise-OR'ed */
+	
+	/* Note that ModPlug always decodes sound at 44100kHz, 32 bit, stereo and then
+	 * down-mixes to the settings you choose. */
+	int mChannels;       /* Number of channels - 1 for mono or 2 for stereo */
+	int mBits;           /* Bits per sample - 8, 16, or 32 */
+	int mFrequency;      /* Sampling rate - 11025, 22050, or 44100 */
+	int mResamplingMode; /* One of MODPLUG_RESAMPLE_*, above */
+
+	int mStereoSeparation; /* Stereo separation, 1 - 256 */
+	int mMaxMixChannels; /* Maximum number of mixing channels (polyphony), 32 - 256 */
+	
+	int mReverbDepth;    /* Reverb level 0(quiet)-100(loud)      */
+	int mReverbDelay;    /* Reverb delay in ms, usually 40-200ms */
+	int mBassAmount;     /* XBass level 0(quiet)-100(loud)       */
+	int mBassRange;      /* XBass cutoff in Hz 10-100            */
+	int mSurroundDepth;  /* Surround level 0(quiet)-100(heavy)   */
+	int mSurroundDelay;  /* Surround delay in ms, usually 5-40ms */
+	int mLoopCount;      /* Number of times to loop.  Zero prevents looping.
+	                        -1 loops forever. */
+} ModPlug_Settings;
+
+int ModPlug_Init(void);
+void ModPlug_Quit(void);
+
+/* Load a mod file.  [data] should point to a block of memory containing the complete
+ * file, and [size] should be the size of that block.
+ * Return the loaded mod file on success, or NULL on failure. */
+MODPLUG_EXPORT ModPlugFile* ModPlug_Load(const void* data, int size, const ModPlug_Settings *settings);
+/* Unload a mod file. */
+MODPLUG_EXPORT void ModPlug_Unload(ModPlugFile* file);
+
+/* Read sample data into the buffer.  Returns the number of bytes read.  If the end
+ * of the mod has been reached, zero is returned. */
+MODPLUG_EXPORT int  ModPlug_Read(ModPlugFile* file, void* buffer, int size);
+
+/* Get the length of the mod, in milliseconds.  Note that this result is not always
+ * accurate, especially in the case of mods with loops. */
+MODPLUG_EXPORT int ModPlug_GetLength(ModPlugFile* file);
+
+/* Seek to a particular position in the song.  Note that seeking and MODs don't mix very
+ * well.  Some mods will be missing instruments for a short time after a seek, as ModPlug
+ * does not scan the sequence backwards to find out which instruments were supposed to be
+ * playing at that time.  (Doing so would be difficult and not very reliable.)  Also,
+ * note that seeking is not very exact in some mods -- especially those for which
+ * ModPlug_GetLength() does not report the full length. */
+MODPLUG_EXPORT void ModPlug_Seek(ModPlugFile* file, int millisecond);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/dependencies/SDL_sound/libmodplug/snd_dsp.c

@@ -0,0 +1,301 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Olivier Lapicque <olivierl@jps.net>
+*/
+
+#include "libmodplug.h"
+
+static UINT GetMaskFromSize(UINT len)
+//-----------------------------------
+{
+	UINT n = 2;
+	while (n <= len) n <<= 1;
+	return ((n >> 1) - 1);
+}
+
+
+void CSoundFile_InitializeDSP(CSoundFile *_this, BOOL bReset)
+//-----------------------------------------
+{
+	if (!_this->m_nReverbDelay) _this->m_nReverbDelay = 100;
+	if (!_this->m_nXBassRange) _this->m_nXBassRange = XBASS_DELAY;
+	if (!_this->m_nProLogicDelay) _this->m_nProLogicDelay = 20;
+	if (_this->m_nXBassDepth > 8) _this->m_nXBassDepth = 8;
+	if (_this->m_nXBassDepth < 2) _this->m_nXBassDepth = 2;
+	if (bReset)
+	{
+		// Noise Reduction
+		_this->nLeftNR = _this->nRightNR = 0;
+	}
+	// Pro-Logic Surround
+	_this->nSurroundPos = _this->nSurroundSize = 0;
+	_this->nDolbyLoFltPos = _this->nDolbyLoFltSum = _this->nDolbyLoDlyPos = 0;
+	_this->nDolbyHiFltPos = _this->nDolbyHiFltSum = 0;
+	if (_this->gdwSoundSetup & SNDMIX_SURROUND)
+	{
+		SDL_memset(_this->DolbyLoFilterBuffer, 0, sizeof(_this->DolbyLoFilterBuffer));
+		SDL_memset(_this->DolbyHiFilterBuffer, 0, sizeof(_this->DolbyHiFilterBuffer));
+		SDL_memset(_this->DolbyLoFilterDelay, 0, sizeof(_this->DolbyLoFilterDelay));
+		SDL_memset(_this->SurroundBuffer, 0, sizeof(_this->SurroundBuffer));
+		_this->nSurroundSize = (_this->gdwMixingFreq * _this->m_nProLogicDelay) / 1000;
+		if (_this->nSurroundSize > SURROUNDBUFFERSIZE) _this->nSurroundSize = SURROUNDBUFFERSIZE;
+		if (_this->m_nProLogicDepth < 8) _this->nDolbyDepth = (32 >> _this->m_nProLogicDepth) + 32;
+		else _this->nDolbyDepth = (_this->m_nProLogicDepth < 16) ? (8 + (_this->m_nProLogicDepth - 8) * 7) : 64;
+		_this->nDolbyDepth >>= 2;
+	}
+	// Reverb Setup
+#ifndef MODPLUG_NO_REVERB
+	if (_this->gdwSoundSetup & SNDMIX_REVERB)
+	{
+		UINT nrs = (_this->gdwMixingFreq * _this->m_nReverbDelay) / 1000;
+		UINT nfa = _this->m_nReverbDepth+1;
+		if (nrs > REVERBBUFFERSIZE) nrs = REVERBBUFFERSIZE;
+		if ((bReset) || (nrs != (UINT)_this->nReverbSize) || (nfa != (UINT)_this->nFilterAttn))
+		{
+			_this->nFilterAttn = nfa;
+			_this->nReverbSize = nrs;
+			_this->nReverbBufferPos = _this->nReverbBufferPos2 = _this->nReverbBufferPos3 = _this->nReverbBufferPos4 = 0;
+			_this->nReverbLoFltSum = _this->nReverbLoFltPos = _this->nReverbLoDlyPos = 0;
+			_this->gRvbLPSum = _this->gRvbLPPos = 0;
+			_this->nReverbSize2 = (_this->nReverbSize * 13) / 17;
+			if (_this->nReverbSize2 > REVERBBUFFERSIZE2) _this->nReverbSize2 = REVERBBUFFERSIZE2;
+			_this->nReverbSize3 = (_this->nReverbSize * 7) / 13;
+			if (_this->nReverbSize3 > REVERBBUFFERSIZE3) _this->nReverbSize3 = REVERBBUFFERSIZE3;
+			_this->nReverbSize4 = (_this->nReverbSize * 7) / 19;
+			if (_this->nReverbSize4 > REVERBBUFFERSIZE4) _this->nReverbSize4 = REVERBBUFFERSIZE4;
+			SDL_memset(_this->ReverbLoFilterBuffer, 0, sizeof(_this->ReverbLoFilterBuffer));
+			SDL_memset(_this->ReverbLoFilterDelay, 0, sizeof(_this->ReverbLoFilterDelay));
+			SDL_memset(_this->ReverbBuffer, 0, sizeof(_this->ReverbBuffer));
+			SDL_memset(_this->ReverbBuffer2, 0, sizeof(_this->ReverbBuffer2));
+			SDL_memset(_this->ReverbBuffer3, 0, sizeof(_this->ReverbBuffer3));
+			SDL_memset(_this->ReverbBuffer4, 0, sizeof(_this->ReverbBuffer4));
+			SDL_memset(_this->gRvbLowPass, 0, sizeof(_this->gRvbLowPass));
+		}
+	} else _this->nReverbSize = 0;
+#endif
+	BOOL bResetBass = FALSE;
+	// Bass Expansion Reset
+	if (_this->gdwSoundSetup & SNDMIX_MEGABASS)
+	{
+		UINT nXBassSamples = (_this->gdwMixingFreq * _this->m_nXBassRange) / 10000;
+		if (nXBassSamples > XBASSBUFFERSIZE) nXBassSamples = XBASSBUFFERSIZE;
+		UINT mask = GetMaskFromSize(nXBassSamples);
+		if ((bReset) || (mask != (UINT)_this->nXBassMask))
+		{
+			_this->nXBassMask = mask;
+			bResetBass = TRUE;
+		}
+	} else
+	{
+		_this->nXBassMask = 0;
+		bResetBass = TRUE;
+	}
+	if (bResetBass)
+	{
+		_this->nXBassSum = _this->nXBassBufferPos = _this->nXBassDlyPos = 0;
+		SDL_memset(_this->XBassBuffer, 0, sizeof(_this->XBassBuffer));
+		SDL_memset(_this->XBassDelay, 0, sizeof(_this->XBassDelay));
+	}
+}
+
+
+void CSoundFile_ProcessStereoDSP(CSoundFile *_this, int count)
+//------------------------------------------
+{
+#ifndef MODPLUG_NO_REVERB
+	// Reverb
+	if (_this->gdwSoundSetup & SNDMIX_REVERB)
+	{
+		int *pr = _this->MixSoundBuffer, *pin = _this->MixReverbBuffer, rvbcount = count;
+		do
+		{
+			int echo = _this->ReverbBuffer[_this->nReverbBufferPos] + _this->ReverbBuffer2[_this->nReverbBufferPos2]
+					+ _this->ReverbBuffer3[_this->nReverbBufferPos3] + _this->ReverbBuffer4[_this->nReverbBufferPos4];	// echo = reverb signal
+			// Delay line and remove Low Frequencies			// v = original signal
+			int echodly = _this->ReverbLoFilterDelay[_this->nReverbLoDlyPos];	// echodly = delayed signal
+			_this->ReverbLoFilterDelay[_this->nReverbLoDlyPos] = echo >> 1;
+			_this->nReverbLoDlyPos++;
+			_this->nReverbLoDlyPos &= 0x1F;
+			int n = _this->nReverbLoFltPos;
+			_this->nReverbLoFltSum -= _this->ReverbLoFilterBuffer[n];
+			int tmp = echo / 128;
+			_this->ReverbLoFilterBuffer[n] = tmp;
+			_this->nReverbLoFltSum += tmp;
+			echodly -= _this->nReverbLoFltSum;
+			_this->nReverbLoFltPos = (n + 1) & 0x3F;
+			// Reverb
+			int v = (pin[0]+pin[1]) >> _this->nFilterAttn;
+			pr[0] += pin[0] + echodly;
+			pr[1] += pin[1] + echodly;
+			v += echodly >> 2;
+			_this->ReverbBuffer3[_this->nReverbBufferPos3] = v;
+			_this->ReverbBuffer4[_this->nReverbBufferPos4] = v;
+			v += echodly >> 4;
+			v >>= 1;
+			_this->gRvbLPSum -= _this->gRvbLowPass[_this->gRvbLPPos];
+			_this->gRvbLPSum += v;
+			_this->gRvbLowPass[_this->gRvbLPPos] = v;
+			_this->gRvbLPPos++;
+			_this->gRvbLPPos &= 7;
+			const int vlp = _this->gRvbLPSum >> 2;
+			_this->ReverbBuffer[_this->nReverbBufferPos] = vlp;
+			_this->ReverbBuffer2[_this->nReverbBufferPos2] = vlp;
+			if (++_this->nReverbBufferPos >= _this->nReverbSize) _this->nReverbBufferPos = 0;
+			if (++_this->nReverbBufferPos2 >= _this->nReverbSize2) _this->nReverbBufferPos2 = 0;
+			if (++_this->nReverbBufferPos3 >= _this->nReverbSize3) _this->nReverbBufferPos3 = 0;
+			if (++_this->nReverbBufferPos4 >= _this->nReverbSize4) _this->nReverbBufferPos4 = 0;
+			pr += 2;
+			pin += 2;
+		} while (--rvbcount);
+	}
+#endif
+	// Dolby Pro-Logic Surround
+	if (_this->gdwSoundSetup & SNDMIX_SURROUND)
+	{
+		int *pr = _this->MixSoundBuffer, n = _this->nDolbyLoFltPos;
+		for (int r=count; r; r--)
+		{
+			int v = (pr[0]+pr[1]+DOLBYATTNROUNDUP) >> (nDolbyHiFltAttn+1);
+			v *= (int)_this->nDolbyDepth;
+			// Low-Pass Filter
+			_this->nDolbyHiFltSum -= _this->DolbyHiFilterBuffer[_this->nDolbyHiFltPos];
+			_this->DolbyHiFilterBuffer[_this->nDolbyHiFltPos] = v;
+			_this->nDolbyHiFltSum += v;
+			v = _this->nDolbyHiFltSum;
+			_this->nDolbyHiFltPos++;
+			_this->nDolbyHiFltPos &= nDolbyHiFltMask;
+			// Surround
+			int secho = _this->SurroundBuffer[_this->nSurroundPos];
+			_this->SurroundBuffer[_this->nSurroundPos] = v;
+			// Delay line and remove low frequencies
+			v = _this->DolbyLoFilterDelay[_this->nDolbyLoDlyPos];		// v = delayed signal
+			_this->DolbyLoFilterDelay[_this->nDolbyLoDlyPos] = secho;	// secho = signal
+			_this->nDolbyLoDlyPos++;
+			_this->nDolbyLoDlyPos &= 0x1F;
+			_this->nDolbyLoFltSum -= _this->DolbyLoFilterBuffer[n];
+			int tmp = secho / 64;
+			_this->DolbyLoFilterBuffer[n] = tmp;
+			_this->nDolbyLoFltSum += tmp;
+			v -= _this->nDolbyLoFltSum;
+			n++;
+			n &= 0x3F;
+			// Add echo
+			pr[0] += v;
+			pr[1] -= v;
+			if (++_this->nSurroundPos >= _this->nSurroundSize) _this->nSurroundPos = 0;
+			pr += 2;
+		}
+		_this->nDolbyLoFltPos = n;
+	}
+	// Bass Expansion
+	if (_this->gdwSoundSetup & SNDMIX_MEGABASS)
+	{
+		int *px = _this->MixSoundBuffer;
+		int xba = _this->m_nXBassDepth+1, xbamask = (1 << xba) - 1;
+		int n = _this->nXBassBufferPos;
+		for (int x=count; x; x--)
+		{
+			_this->nXBassSum -= _this->XBassBuffer[n];
+			int tmp0 = px[0] + px[1];
+			int tmp = (tmp0 + ((tmp0 >> 31) & xbamask)) >> xba;
+			_this->XBassBuffer[n] = tmp;
+			_this->nXBassSum += tmp;
+			int v = _this->XBassDelay[_this->nXBassDlyPos];
+			_this->XBassDelay[_this->nXBassDlyPos] = px[0];
+			px[0] = v + _this->nXBassSum;
+			v = _this->XBassDelay[_this->nXBassDlyPos+1];
+			_this->XBassDelay[_this->nXBassDlyPos+1] = px[1];
+			px[1] = v + _this->nXBassSum;
+			_this->nXBassDlyPos = (_this->nXBassDlyPos + 2) & _this->nXBassMask;
+			px += 2;
+			n++;
+			n &= _this->nXBassMask;
+		}
+		_this->nXBassBufferPos = n;
+	}
+	// Noise Reduction
+	if (_this->gdwSoundSetup & SNDMIX_NOISEREDUCTION)
+	{
+		int n1 = _this->nLeftNR, n2 = _this->nRightNR;
+		int *pnr = _this->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;
+		}
+		_this->nLeftNR = n1;
+		_this->nRightNR = n2;
+	}
+}
+
+
+/////////////////////////////////////////////////////////////////
+// Clean DSP Effects interface
+
+// [Reverb level 0(quiet)-100(loud)], [delay in ms, usually 40-200ms]
+BOOL CSoundFile_SetReverbParameters(CSoundFile *_this, UINT nDepth, UINT nDelay)
+//------------------------------------------------------------
+{
+	if (nDepth > 100) nDepth = 100;
+	UINT gain = nDepth / 20;
+	if (gain > 4) gain = 4;
+	_this->m_nReverbDepth = 4 - gain;
+	if (nDelay < 40) nDelay = 40;
+	if (nDelay > 250) nDelay = 250;
+	_this->m_nReverbDelay = nDelay;
+	return TRUE;
+}
+
+
+// [XBass level 0(quiet)-100(loud)], [cutoff in Hz 20-100]
+BOOL CSoundFile_SetXBassParameters(CSoundFile *_this, UINT nDepth, UINT nRange)
+//-----------------------------------------------------------
+{
+	if (nDepth > 100) nDepth = 100;
+	UINT gain = nDepth / 20;
+	if (gain > 4) gain = 4;
+	_this->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;
+	_this->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(CSoundFile *_this, UINT nDepth, UINT nDelay)
+//--------------------------------------------------------------
+{
+	UINT gain = (nDepth * 16) / 100;
+	if (gain > 16) gain = 16;
+	if (gain < 1) gain = 1;
+	_this->m_nProLogicDepth = gain;
+	if (nDelay < 4) nDelay = 4;
+	if (nDelay > 50) nDelay = 50;
+	_this->m_nProLogicDelay = nDelay;
+	return TRUE;
+}
+
+BOOL CSoundFile_SetWaveConfigEx(CSoundFile *_this, BOOL bSurround,BOOL bNoOverSampling,BOOL bReverb,BOOL hqido,BOOL bMegaBass,BOOL bNR,BOOL bEQ)
+//----------------------------------------------------------------------------------------------------------------------------
+{
+	DWORD d = _this->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;
+	_this->gdwSoundSetup = d;
+	CSoundFile_InitPlayer(_this, FALSE);
+	return TRUE;
+}
+

data/dependencies/SDL_sound/libmodplug/snd_flt.c

@@ -0,0 +1,63 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Olivier Lapicque <olivierl@jps.net>
+*/
+
+#include "libmodplug.h"
+
+// AWE32: cutoff = reg[0-255] * 31.25 + 100 -> [100Hz-8060Hz]
+// EMU10K1 docs: cutoff = reg[0-127]*62+100
+#define FILTER_PRECISION	8192
+
+#ifndef NO_FILTER
+
+DWORD CSoundFile_CutOffToFrequency(CSoundFile *_this, UINT nCutOff, int flt_modifier)
+//-----------------------------------------------------------------------
+{
+	float Fc;
+
+	if (_this->m_dwSongFlags & SONG_EXFILTERRANGE)
+		Fc = 110.0f * SDL_pow(2.0f, 0.25f + ((float)(nCutOff*(flt_modifier+256)))/(21.0f*512.0f));
+	else
+		Fc = 110.0f * SDL_pow(2.0f, 0.25f + ((float)(nCutOff*(flt_modifier+256)))/(24.0f*512.0f));
+	LONG freq = (LONG)Fc;
+	if (freq < 120) return 120;
+	if (freq > 10000) return 10000;
+	if (freq*2 > (LONG)_this->gdwMixingFreq) freq = _this->gdwMixingFreq>>1;
+	return (DWORD)freq;
+}
+
+
+// Simple 2-poles resonant filter
+void CSoundFile_SetupChannelFilter(CSoundFile *_this, MODCHANNEL *pChn, BOOL bReset, int flt_modifier)
+//----------------------------------------------------------------------------------------
+{
+	float fc = (float)CSoundFile_CutOffToFrequency(_this, pChn->nCutOff, flt_modifier);
+	float fs = (float)_this->gdwMixingFreq;
+	float fg, fb0, fb1;
+
+	fc *= (float)(2.0*3.14159265358/fs);
+	float dmpfac = SDL_pow(10.0f, -((24.0f / 128.0f)*(float)pChn->nResonance) / 20.0f);
+	float d = (1.0f-2.0f*dmpfac)* fc;
+	if (d>2.0) d = 2.0;
+	d = (2.0f*dmpfac - d)/fc;
+	float e = SDL_pow(1.0f/fc,2.0f);
+
+	fg=1/(1+d+e);
+	fb0=(d+e+e)/(1+d+e);
+	fb1=-e/(1+d+e);
+
+	pChn->nFilter_A0 = (int)(fg * FILTER_PRECISION);
+	pChn->nFilter_B0 = (int)(fb0 * FILTER_PRECISION);
+	pChn->nFilter_B1 = (int)(fb1 * FILTER_PRECISION);
+
+	if (bReset)
+	{
+		pChn->nFilter_Y1 = pChn->nFilter_Y2 = 0;
+		pChn->nFilter_Y3 = pChn->nFilter_Y4 = 0;
+	}
+	pChn->dwFlags |= CHN_FILTER;
+}
+
+#endif // NO_FILTER