diff src/modplug/snd_fx.cxx @ 136:6b5a52635b3b trunk

[svn] - like with so many other things, modplug is now maintained by us.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/modplug/snd_fx.cxx	Sun Oct 29 01:04:52 2006 -0700
@@ -0,0 +1,2391 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Olivier Lapicque <[e-mail]>
+*/
+
+#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
+				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 = Headers[instr];
+	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;
+	} else
+	if (m_nInstruments)
+	{
+		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)
+	{
+		if (penv)
+		{
+			pChn->nInsVol = (psmp->nGlobalVol * penv->nGlobalVol) >> 6;
+			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)
+//---------------------------------------------------------------------------
+{
+	if (note < 1) return;
+	MODCHANNEL * const pChn = &Chn[nChn];
+	MODINSTRUMENT *pins = pChn->pInstrument;
+	INSTRUMENTHEADER *penv = pChn->pHeader;
+	if ((penv) && (note <= 0x80))
+	{
+		UINT n = penv->Keyboard[note - 1];
+		if ((n) && (n < MAX_SAMPLES)) pins = &Ins[n];
+		note = penv->NoteMap[note-1];
+	}
+	// Key Off
+	if (note >= 0x80)	// 0xFE or invalid note => key off
+	{
+		// Key Off
+		KeyOff(nChn);
+		// Note Cut
+		if (note == 0xFE)
+		{
+			pChn->dwFlags |= (CHN_NOTEFADE|CHN_FASTVOLRAMP);
+			if ((!(m_nType & MOD_TYPE_IT)) || (m_nInstruments)) 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)
+					{
+						int d = ((LONG)penv->nVolSwing*(LONG)((rand() & 0xFF) - 0x7F)) / 128;
+						pChn->nVolSwing = (signed short)((d * pChn->nVolume + 1)/128);
+					}
+					// 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
+	}
+}
+
+
+UINT CSoundFile::GetNNAChannel(UINT nChn) const
+//---------------------------------------------
+{
+	const MODCHANNEL *pChn = &Chn[nChn];
+	// Check for empty channel
+	const MODCHANNEL *pi = &Chn[m_nChannels];
+	for (UINT i=m_nChannels; i<MAX_CHANNELS; i++, pi++) if (!pi->nLength) return i;
+	if (!pChn->nFadeOutVol) return 0;
+	// All channels are used: check for lowest volume
+	UINT result = 0;
+	DWORD vol = 64*65536;	// 25%
+	DWORD 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;
+		}
+	}
+	return result;
+}
+
+
+void CSoundFile::CheckNNA(UINT nChn, UINT instr, int note, BOOL bForceCut)
+//------------------------------------------------------------------------
+{
+	MODCHANNEL *pChn = &Chn[nChn];
+	INSTRUMENTHEADER *penv = pChn->pHeader, *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_nInstruments) || (bForceCut))
+	{
+		if ((m_dwSongFlags & SONG_CPUVERYHIGH)
+		 || (!pChn->nLength) || (pChn->dwFlags & CHN_MUTE)
+		 || ((!pChn->nLeftVol) && (!pChn->nRightVol))) return;
+		UINT n = GetNNAChannel(nChn);
+		if (!n) return;
+		MODCHANNEL *p = &Chn[n];
+		// Copy Channel
+		*p = *pChn;
+		p->dwFlags &= ~(CHN_VIBRATO|CHN_TREMOLO|CHN_PANBRELLO|CHN_MUTE|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 = Headers[instr];
+		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;
+	MODCHANNEL *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) && (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)
+		{
+			MODCHANNEL *p = &Chn[n];
+			// Copy Channel
+			*p = *pChn;
+			p->dwFlags &= ~(CHN_VIBRATO|CHN_TREMOLO|CHN_PANBRELLO|CHN_MUTE|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++)
+	{
+		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 = 0;
+
+		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_nInstruments)
+				{
+					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 ?
+			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;
+			}
+		}
+
+		// 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;
+			}
+			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);
+			}
+			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:
+			if ((m_nTickCount) || (!pChn->nPeriod) || (!pChn->nNote)) break;
+			if ((!param) && (!(m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT)))) break;
+			pChn->nCommand = CMD_ARPEGGIO;
+			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
+			}
+			if (param) pChn->nRetrigParam = (BYTE)(param & 0xFF); else param = pChn->nRetrigParam;
+			RetrigNote(nChn, param);
+			break;
+
+		// Tremor
+		case CMD_TREMOR:
+			if (m_nTickCount) break;
+			pChn->nCommand = CMD_TREMOR;
+			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;
+			}
+			break;
+
+		// Channel volume slide
+		case CMD_CHANNELVOLSLIDE:
+			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 (pChn->pHeader)
+				{
+					INSTRUMENTHEADER *penv = pChn->pHeader;
+					if ((pChn->dwFlags & CHN_PANENV) && (penv->nPanEnv) && (param > penv->PanPoints[penv->nPanEnv-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_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_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;
+	}
+}
+
+
+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:	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)
+				{
+					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)
+	{
+	// S90: Surround Off
+	case 0x00:	pChn->dwFlags &= ~CHN_SURROUND;	break;
+	// S91: Surround On
+	case 0x01:	pChn->dwFlags |= CHN_SURROUND; pChn->nPan = 128; break;
+	////////////////////////////////////////////////////////////
+	// Modplug Extensions
+	// 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;
+	}
+}
+
+
+void CSoundFile::ProcessMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param)
+//---------------------------------------------------------------------------
+{
+	MODCHANNEL *pChn = &Chn[nChn];
+	DWORD dwMacro = (*((LPDWORD)pszMidiMacro)) & 0x7F5F7F5F;
+	// Not Internal Device ?
+	if (dwMacro != 0x30463046)
+	{
+		UINT pos = 0, nNib = 0, nBytes = 0;
+		DWORD dwMidiCode = 0, dwByteCode = 0;
+		while (pos+6 <= 32)
+		{
+			CHAR cData = pszMidiMacro[pos++];
+			if (!cData) break;
+			if ((cData >= '0') && (cData <= '9')) { dwByteCode = (dwByteCode<<4) | (cData-'0'); nNib++; } else
+			if ((cData >= 'A') && (cData <= 'F')) { dwByteCode = (dwByteCode<<4) | (cData-'A'+10); nNib++; } else
+			if ((cData >= 'a') && (cData <= 'f')) { dwByteCode = (dwByteCode<<4) | (cData-'a'+10); nNib++; } else
+			if ((cData == 'z') || (cData == 'Z')) { dwByteCode = param & 0x7f; nNib = 2; } else
+			if ((cData == 'x') || (cData == 'X')) { dwByteCode = param & 0x70; nNib = 2; } else
+			if ((cData == 'y') || (cData == 'Y')) { dwByteCode = (param & 0x0f)<<3; nNib = 2; } else
+			if (nNib >= 2)
+			{
+				nNib = 0;
+				dwMidiCode |= dwByteCode << (nBytes*8);
+				dwByteCode = 0;
+				nBytes++;
+				if (nBytes >= 3)
+				{
+					UINT nMasterCh = (nChn < m_nChannels) ? nChn+1 : pChn->nMasterChn;
+					if ((nMasterCh) && (nMasterCh <= m_nChannels))
+					{
+						UINT nPlug = ChnSettings[nMasterCh-1].nMixPlugin;
+						if ((nPlug) && (nPlug <= MAX_MIXPLUGINS))
+						{
+							IMixPlugin *pPlugin = m_MixPlugins[nPlug-1].pMixPlugin;
+							if ((pPlugin) && (m_MixPlugins[nPlug-1].pMixState))
+							{
+								pPlugin->MidiSend(dwMidiCode);
+							}
+						}
+					}
+					nBytes = 0;
+					dwMidiCode = 0;
+				}
+			}
+
+		}
+		return;
+	}
+	// Internal device
+	pszMidiMacro += 4;
+	// Filter ?
+	if (pszMidiMacro[0] == '0')
+	{
+		CHAR cData1 = pszMidiMacro[2];
+		DWORD dwParam = 0;
+		if ((cData1 == 'z') || (cData1 == 'Z'))
+		{
+			dwParam = param;
+		} else
+		{
+			CHAR cData2 = pszMidiMacro[3];
+			if ((cData1 >= '0') && (cData1 <= '9')) dwParam += (cData1 - '0') << 4; else
+			if ((cData1 >= 'A') && (cData1 <= 'F')) dwParam += (cData1 - 'A' + 0x0A) << 4;
+			if ((cData2 >= '0') && (cData2 <= '9')) dwParam += (cData2 - '0'); else
+			if ((cData2 >= 'A') && (cData2 <= 'F')) dwParam += (cData2 - 'A' + 0x0A);
+		}
+		switch(pszMidiMacro[1])
+		{
+		// F0.F0.00.xx: Set CutOff
+		case '0':
+			{
+				int oldcutoff = pChn->nCutOff;
+				if (dwParam < 0x80) pChn->nCutOff = dwParam;
+#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;
+
+		// F0.F0.01.xx: Set Resonance
+		case '1':
+			if (dwParam < 0x80) pChn->nResonance = dwParam;
+#ifndef NO_FILTER
+			SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+#endif // NO_FILTER
+
+			break;
+		}
+
+	}
+}
+
+
+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 ((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_nInstruments) KeyOff(pChn); ?
+		pChn->nVolume = 0;
+		pChn->dwFlags |= CHN_FASTVOLRAMP;
+	}
+}
+
+
+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 ((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 (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)
+//-----------------------------------
+{
+	UINT max = (m_nType == MOD_TYPE_IT) ? 256 : 128;
+	// Modplug Tracker and Mod-Plugin don't do this check
+#ifndef MODPLUG_TRACKER
+#ifndef MODPLUG_FASTSOUNDLIB
+	// Big Hack!!!
+	if ((!param) || (param >= 0x80) || ((m_nType & (MOD_TYPE_MOD|MOD_TYPE_XM|MOD_TYPE_MT2)) && (param >= 0x1E)))
+	{
+		if (IsSongFinished(m_nCurrentPattern, m_nRow+1))
+		{
+			GlobalFadeSong(1000);
+		}
+	}
+#endif // MODPLUG_FASTSOUNDLIB
+#endif // MODPLUG_TRACKER
+	if ((m_nType & MOD_TYPE_S3M) && (param > 0x80)) param -= 0x80;
+	if ((param) && (param <= max)) m_nMusicSpeed = param;
+}
+
+
+void CSoundFile::SetTempo(UINT param)
+//-----------------------------------
+{
+	if (param < 0x20)
+	{
+		// 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;
+		}
+	} else
+	{
+		m_nMusicTempo = param;
+	}
+}
+
+
+int CSoundFile::PatternLoop(MODCHANNEL *pChn, UINT param)
+//-------------------------------------------------------
+{
+	if (param)
+	{
+		if (pChn->nPatternLoopCount)
+		{
+			pChn->nPatternLoopCount--;
+			if (!pChn->nPatternLoopCount) return -1;
+		} else
+		{
+			MODCHANNEL *p = Chn;
+			for (UINT i=0; i<m_nChannels; i++, p++) if (p != pChn)
+			{
+				// Loop already done
+				if (p->nPatternLoopCount) return -1;
+			}
+			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;
+	}
+}
+
+
+
+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);
+		}
+	}
+}
+
+