gosu 0.15.0 → 1.0.0

data/dependencies/SDL_sound/libmodplug/load_mod.c

@@ -0,0 +1,269 @@
+/*
+ * This source code is public domain.
+ *
+ * Authors: Olivier Lapicque <olivierl@jps.net>,
+ *          Adam Goode       <adam@evdebs.org> (endian and char fixes for PPC)
+*/
+
+#include "libmodplug.h"
+#include "tables.h"
+
+//////////////////////////////////////////////////////////
+// ProTracker / NoiseTracker MOD/NST file support
+
+void CSoundFile_ConvertModCommand(CSoundFile *_this, MODCOMMAND *m)
+//-----------------------------------------------------
+{
+	UINT command = m->command, param = m->param;
+
+	switch(command)
+	{
+	case 0x00:	if (param) command = CMD_ARPEGGIO; break;
+	case 0x01:	command = CMD_PORTAMENTOUP; break;
+	case 0x02:	command = CMD_PORTAMENTODOWN; break;
+	case 0x03:	command = CMD_TONEPORTAMENTO; break;
+	case 0x04:	command = CMD_VIBRATO; break;
+	case 0x05:	command = CMD_TONEPORTAVOL; if (param & 0xF0) param &= 0xF0; break;
+	case 0x06:	command = CMD_VIBRATOVOL; if (param & 0xF0) param &= 0xF0; break;
+	case 0x07:	command = CMD_TREMOLO; break;
+	case 0x08:	command = CMD_PANNING8; break;
+	case 0x09:	command = CMD_OFFSET; break;
+	case 0x0A:	command = CMD_VOLUMESLIDE; if (param & 0xF0) param &= 0xF0; break;
+	case 0x0B:	command = CMD_POSITIONJUMP; break;
+	case 0x0C:	command = CMD_VOLUME; break;
+	case 0x0D:	command = CMD_PATTERNBREAK; param = ((param >> 4) * 10) + (param & 0x0F); break;
+	case 0x0E:	command = CMD_MODCMDEX; break;
+	case 0x0F:	command = (param <= (UINT)((_this->m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? 0x1F : 0x20)) ? CMD_SPEED : CMD_TEMPO;
+				if ((param == 0xFF) && (_this->m_nSamples == 15)) command = 0; break;
+	// Extension for XM extended effects
+	case 'G' - 55:	command = CMD_GLOBALVOLUME; break;
+	case 'H' - 55:	command = CMD_GLOBALVOLSLIDE; if (param & 0xF0) param &= 0xF0; break;
+	case 'K' - 55:	command = CMD_KEYOFF; break;
+	case 'L' - 55:	command = CMD_SETENVPOSITION; break;
+	case 'M' - 55:	command = CMD_CHANNELVOLUME; break;
+	case 'N' - 55:	command = CMD_CHANNELVOLSLIDE; break;
+	case 'P' - 55:	command = CMD_PANNINGSLIDE; if (param & 0xF0) param &= 0xF0; break;
+	case 'R' - 55:	command = CMD_RETRIG; break;
+	case 'T' - 55:	command = CMD_TREMOR; break;
+	case 'X' - 55:	command = CMD_XFINEPORTAUPDOWN;	break;
+	case 'Y' - 55:	command = CMD_PANBRELLO; break;
+	case 'Z' - 55:	command = CMD_MIDI;	break;
+	default:	command = 0;
+	}
+	m->command = command;
+	m->param = param;
+}
+
+
+#pragma pack(1)
+
+typedef struct _MODSAMPLE
+{
+	CHAR name[22];
+	WORD length;
+	BYTE finetune;
+	BYTE volume;
+	WORD loopstart;
+	WORD looplen;
+} MODSAMPLE, *PMODSAMPLE;
+
+typedef struct _MODMAGIC
+{
+	BYTE nOrders;
+	BYTE nRestartPos;
+	BYTE Orders[128];
+        char Magic[4];          // changed from CHAR
+} MODMAGIC, *PMODMAGIC;
+
+#pragma pack()
+
+static BOOL IsMagic(LPCSTR s1, LPCSTR s2)
+{
+	return ((*(DWORD *)s1) == (*(DWORD *)s2)) ? TRUE : FALSE;
+}
+
+
+BOOL CSoundFile_ReadMod(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
+//---------------------------------------------------------------
+{
+    char s[1024];          // changed from CHAR
+	DWORD dwMemPos, dwTotalSampleLen;
+	PMODMAGIC pMagic;
+	UINT nErr;
+
+	if ((!lpStream) || (dwMemLength < 0x600)) return FALSE;
+	dwMemPos = 20;
+	_this->m_nSamples = 31;
+	_this->m_nChannels = 4;
+	pMagic = (PMODMAGIC)(lpStream+dwMemPos+sizeof(MODSAMPLE)*31);
+	// Check Mod Magic
+	SDL_memcpy(s, pMagic->Magic, 4);
+	if ((IsMagic(s, "M.K.")) || (IsMagic(s, "M!K!"))
+	 || (IsMagic(s, "M&K!")) || (IsMagic(s, "N.T."))) _this->m_nChannels = 4; else
+	if ((IsMagic(s, "CD81")) || (IsMagic(s, "OKTA"))) _this->m_nChannels = 8; else
+	if ((s[0]=='F') && (s[1]=='L') && (s[2]=='T') && (s[3]>='4') && (s[3]<='9')) _this->m_nChannels = s[3] - '0'; else
+	if ((s[0]>='2') && (s[0]<='9') && (s[1]=='C') && (s[2]=='H') && (s[3]=='N')) _this->m_nChannels = s[0] - '0'; else
+	if ((s[0]=='1') && (s[1]>='0') && (s[1]<='9') && (s[2]=='C') && (s[3]=='H')) _this->m_nChannels = s[1] - '0' + 10; else
+	if ((s[0]=='2') && (s[1]>='0') && (s[1]<='9') && (s[2]=='C') && (s[3]=='H')) _this->m_nChannels = s[1] - '0' + 20; else
+	if ((s[0]=='3') && (s[1]>='0') && (s[1]<='2') && (s[2]=='C') && (s[3]=='H')) _this->m_nChannels = s[1] - '0' + 30; else
+	if ((s[0]=='T') && (s[1]=='D') && (s[2]=='Z') && (s[3]>='4') && (s[3]<='9')) _this->m_nChannels = s[3] - '0'; else
+	if (IsMagic(s,"16CN")) _this->m_nChannels = 16; else
+	if (IsMagic(s,"32CN")) _this->m_nChannels = 32; else _this->m_nSamples = 15;
+	// Load Samples
+	nErr = 0;
+	dwTotalSampleLen = 0;
+	for	(UINT i=1; i<=_this->m_nSamples; i++)
+	{
+		PMODSAMPLE pms = (PMODSAMPLE)(lpStream+dwMemPos);
+		MODINSTRUMENT *psmp = &_this->Ins[i];
+		UINT loopstart, looplen;
+
+		psmp->uFlags = 0;
+		psmp->nLength = bswapBE16(pms->length)*2;
+		dwTotalSampleLen += psmp->nLength;
+		psmp->nFineTune = MOD2XMFineTune(pms->finetune & 0x0F);
+		psmp->nVolume = 4*pms->volume;
+		if (psmp->nVolume > 256) { psmp->nVolume = 256; nErr++; }
+		psmp->nGlobalVol = 64;
+		psmp->nPan = 128;
+		loopstart = bswapBE16(pms->loopstart)*2;
+		looplen = bswapBE16(pms->looplen)*2;
+		// Fix loops
+		if ((looplen > 2) && (loopstart+looplen > psmp->nLength)
+		 && (loopstart/2+looplen <= psmp->nLength))
+		{
+			loopstart /= 2;
+		}
+		psmp->nLoopStart = loopstart;
+		psmp->nLoopEnd = loopstart + looplen;
+		if (psmp->nLength < 4) psmp->nLength = 0;
+		if (psmp->nLength)
+		{
+			if (psmp->nLoopStart >= psmp->nLength) { psmp->nLoopStart = psmp->nLength-1; }
+			if (psmp->nLoopEnd > psmp->nLength) { psmp->nLoopEnd = psmp->nLength; }
+
+			if ((psmp->nLoopStart > psmp->nLoopEnd) || (psmp->nLoopEnd <= 8)
+			 || (psmp->nLoopEnd - psmp->nLoopStart <= 4))
+			{
+				psmp->nLoopStart = 0;
+				psmp->nLoopEnd = 0;
+			}
+			if (psmp->nLoopEnd > psmp->nLoopStart)
+			{
+				psmp->uFlags |= CHN_LOOP;
+			}
+		}
+		dwMemPos += sizeof(MODSAMPLE);
+	}
+	if ((_this->m_nSamples == 15) && (dwTotalSampleLen > dwMemLength * 4)) return FALSE;
+	pMagic = (PMODMAGIC)(lpStream+dwMemPos);
+	dwMemPos += sizeof(MODMAGIC);
+	if (_this->m_nSamples == 15) dwMemPos -= 4;
+	SDL_memset(_this->Order, 0,sizeof(_this->Order));
+	SDL_memcpy(_this->Order, pMagic->Orders, 128);
+
+	UINT nbp, nbpbuggy, nbpbuggy2, norders;
+
+	norders = pMagic->nOrders;
+	if ((!norders) || (norders > 0x80))
+	{
+		norders = 0x80;
+		while ((norders > 1) && (!_this->Order[norders-1])) norders--;
+	}
+	nbpbuggy = 0;
+	nbpbuggy2 = 0;
+	nbp = 0;
+	for (UINT iord=0; iord<128; iord++)
+	{
+		UINT i = _this->Order[iord];
+		if ((i < 0x80) && (nbp <= i))
+		{
+			nbp = i+1;
+			if (iord<norders) nbpbuggy = nbp;
+		}
+		if (i >= nbpbuggy2) nbpbuggy2 = i+1;
+	}
+	for (UINT iend=norders; iend<MAX_ORDERS; iend++) _this->Order[iend] = 0xFF;
+	norders--;
+	_this->m_nRestartPos = pMagic->nRestartPos;
+	if (_this->m_nRestartPos >= 0x78) _this->m_nRestartPos = 0;
+	if (_this->m_nRestartPos + 1 >= (UINT)norders) _this->m_nRestartPos = 0;
+	if (!nbp) return FALSE;
+	DWORD dwWowTest = dwTotalSampleLen+dwMemPos;
+	if ((IsMagic(pMagic->Magic, "M.K.")) && (dwWowTest + nbp*8*256 == dwMemLength)) _this->m_nChannels = 8;
+	if ((nbp != nbpbuggy) && (dwWowTest + nbp*_this->m_nChannels*256 != dwMemLength))
+	{
+		if (dwWowTest + nbpbuggy*_this->m_nChannels*256 == dwMemLength) nbp = nbpbuggy;
+		else nErr += 8;
+	} else
+	if ((nbpbuggy2 > nbp) && (dwWowTest + nbpbuggy2*_this->m_nChannels*256 == dwMemLength))
+	{
+		nbp = nbpbuggy2;
+	}
+	if ((dwWowTest < 0x600) || (dwWowTest > dwMemLength)) nErr += 8;
+	if ((_this->m_nSamples == 15) && (nErr >= 16)) return FALSE;
+	// Default settings	
+	_this->m_nType = MOD_TYPE_MOD;
+	_this->m_nDefaultSpeed = 6;
+	_this->m_nDefaultTempo = 125;
+	_this->m_nMinPeriod = 14 << 2;
+	_this->m_nMaxPeriod = 3424 << 2;
+	// Setting channels pan
+	for (UINT ich=0; ich<_this->m_nChannels; ich++)
+	{
+		_this->ChnSettings[ich].nVolume = 64;
+		if (_this->gdwSoundSetup & SNDMIX_MAXDEFAULTPAN)
+			_this->ChnSettings[ich].nPan = (((ich&3)==1) || ((ich&3)==2)) ? 256 : 0;
+		else
+			_this->ChnSettings[ich].nPan = (((ich&3)==1) || ((ich&3)==2)) ? 0xC0 : 0x40;
+	}
+	// Reading channels
+	for (UINT ipat=0; ipat<nbp; ipat++)
+	{
+		if (ipat < MAX_PATTERNS)
+		{
+			if ((_this->Patterns[ipat] = CSoundFile_AllocatePattern(64, _this->m_nChannels)) == NULL) break;
+			_this->PatternSize[ipat] = 64;
+			if (dwMemPos + _this->m_nChannels*256 >= dwMemLength) break;
+			MODCOMMAND *m = _this->Patterns[ipat];
+			LPCBYTE p = lpStream + dwMemPos;
+			for (UINT j=_this->m_nChannels*64; j; m++,p+=4,j--)
+			{
+				BYTE A0=p[0], A1=p[1], A2=p[2], A3=p[3];
+				UINT n = ((((UINT)A0 & 0x0F) << 8) | (A1));
+				if ((n) && (n != 0xFFF)) m->note = CSoundFile_GetNoteFromPeriod(_this, n << 2);
+				m->instr = ((UINT)A2 >> 4) | (A0 & 0x10);
+				m->command = A2 & 0x0F;
+				m->param = A3;
+				if ((m->command) || (m->param)) CSoundFile_ConvertModCommand(_this, m);
+			}
+		}
+		dwMemPos += _this->m_nChannels*256;
+	}
+	// Reading instruments
+	DWORD dwErrCheck = 0;
+	for (UINT ismp=1; ismp<=_this->m_nSamples; ismp++) if (_this->Ins[ismp].nLength)
+	{
+		LPSTR p = (LPSTR)(lpStream+dwMemPos);
+		UINT flags = 0;
+		if (dwMemPos + 5 >= dwMemLength) break;
+		if (!SDL_strncasecmp(p, "ADPCM", 5))
+		{
+			flags = 3;
+			p += 5;
+			dwMemPos += 5;
+		}
+		DWORD dwSize = CSoundFile_ReadSample(_this, &_this->Ins[ismp], flags, p, dwMemLength - dwMemPos);
+		if (dwSize)
+		{
+			dwMemPos += dwSize;
+			dwErrCheck++;
+		}
+	}
+#ifdef MODPLUG_TRACKER
+	return TRUE;
+#else
+	return (dwErrCheck) ? TRUE : FALSE;
+#endif
+}
+

data/dependencies/SDL_sound/libmodplug/load_mt2.c

@@ -0,0 +1,546 @@
+#include "libmodplug.h"
+
+#pragma pack(1)
+
+typedef struct _MT2FILEHEADER
+{
+	DWORD dwMT20;	// 0x3032544D "MT20"
+	DWORD dwSpecial;
+	WORD wVersion;
+	CHAR szTrackerName[32];	// "MadTracker 2.0"
+	CHAR szSongName[64];
+	WORD nOrders;
+	WORD wRestart;
+	WORD wPatterns;
+	WORD wChannels;
+	WORD wSamplesPerTick;
+	BYTE bTicksPerLine;
+	BYTE bLinesPerBeat;
+	DWORD fulFlags; // b0=packed patterns
+	WORD wInstruments;
+	WORD wSamples;
+	BYTE Orders[256];
+} MT2FILEHEADER;
+
+typedef struct _MT2PATTERN
+{
+	WORD wLines;
+	DWORD wDataLen;
+} MT2PATTERN;
+
+typedef struct _MT2COMMAND
+{
+	BYTE note;	// 0=nothing, 97=note off
+	BYTE instr;
+	BYTE vol;
+	BYTE pan;
+	BYTE fxcmd;
+	BYTE fxparam1;
+	BYTE fxparam2;
+} MT2COMMAND;
+
+typedef struct _MT2DRUMSDATA
+{
+	WORD wDrumPatterns;
+	WORD wDrumSamples[8];
+	BYTE DrumPatternOrder[256];
+} MT2DRUMSDATA;
+
+typedef struct _MT2AUTOMATION
+{
+	DWORD dwFlags;
+	DWORD dwEffectId;
+	DWORD nEnvPoints;
+} MT2AUTOMATION;
+
+typedef struct _MT2INSTRUMENT
+{
+	DWORD dwDataLen;
+	WORD wSamples;
+	BYTE GroupsMapping[96];
+	BYTE bVibType;
+	BYTE bVibSweep;
+	BYTE bVibDepth;
+	BYTE bVibRate;
+	WORD wFadeOut;
+	WORD wNNA;
+	WORD wInstrFlags;
+	WORD wEnvFlags1;
+	WORD wEnvFlags2;
+} MT2INSTRUMENT;
+
+typedef struct _MT2ENVELOPE
+{
+	BYTE nFlags;
+	BYTE nPoints;
+	BYTE nSustainPos;
+	BYTE nLoopStart;
+	BYTE nLoopEnd;
+	BYTE bReserved[3];
+	BYTE EnvData[64];
+} MT2ENVELOPE;
+
+typedef struct _MT2SYNTH
+{
+	BYTE nSynthId;
+	BYTE nFxId;
+	WORD wCutOff;
+	BYTE nResonance;
+	BYTE nAttack;
+	BYTE nDecay;
+	BYTE bReserved[25];
+} MT2SYNTH;
+
+typedef struct _MT2SAMPLE
+{
+	DWORD dwDataLen;
+	DWORD dwLength;
+	DWORD dwFrequency;
+	BYTE nQuality;
+	BYTE nChannels;
+	BYTE nFlags;
+	BYTE nLoop;
+	DWORD dwLoopStart;
+	DWORD dwLoopEnd;
+	WORD wVolume;
+	BYTE nPan;
+	BYTE nBaseNote;
+	WORD wSamplesPerBeat;
+} MT2SAMPLE;
+
+typedef struct _MT2GROUP
+{
+	BYTE nSmpNo;
+	BYTE nVolume;	// 0-128
+	BYTE nFinePitch;
+	BYTE Reserved[5];
+} MT2GROUP;
+
+#pragma pack()
+
+
+static VOID ConvertMT2Command(CSoundFile *that, MODCOMMAND *m, const MT2COMMAND *p)
+//---------------------------------------------------------------------------
+{
+	// Note
+	m->note = 0;
+	if (p->note) m->note = (p->note > 96) ? 0xFF : p->note+12;
+	// Instrument
+	m->instr = p->instr;
+	// Volume Column
+	if ((p->vol >= 0x10) && (p->vol <= 0x90))
+	{
+		m->volcmd = VOLCMD_VOLUME;
+		m->vol = (p->vol - 0x10) >> 1;
+	} else
+	if ((p->vol >= 0xA0) && (p->vol <= 0xAF))
+	{
+		m->volcmd = VOLCMD_VOLSLIDEDOWN;
+		m->vol = (p->vol & 0x0f);
+	} else
+	if ((p->vol >= 0xB0) && (p->vol <= 0xBF))
+	{
+		m->volcmd = VOLCMD_VOLSLIDEUP;
+		m->vol = (p->vol & 0x0f);
+	} else
+	if ((p->vol >= 0xC0) && (p->vol <= 0xCF))
+	{
+		m->volcmd = VOLCMD_FINEVOLDOWN;
+		m->vol = (p->vol & 0x0f);
+	} else
+	if ((p->vol >= 0xD0) && (p->vol <= 0xDF))
+	{
+		m->volcmd = VOLCMD_FINEVOLUP;
+		m->vol = (p->vol & 0x0f);
+	} else
+	{
+		m->volcmd = 0;
+		m->vol = 0;
+	}
+	// Effects
+	m->command = 0;
+	m->param = 0;
+	if ((p->fxcmd) || (p->fxparam1) || (p->fxparam2))
+	{
+		if (!p->fxcmd)
+		{
+			m->command = p->fxparam2;
+			m->param = p->fxparam1;
+			CSoundFile_ConvertModCommand(that, m);
+		} else
+		{
+			// TODO: MT2 Effects
+		}
+	}
+}
+
+
+BOOL CSoundFile_ReadMT2(CSoundFile *_this, LPCBYTE lpStream, DWORD dwMemLength)
+//-----------------------------------------------------------
+{
+	const MT2FILEHEADER *pfh = (MT2FILEHEADER *)lpStream;
+	DWORD dwMemPos, dwDrumDataPos, dwExtraDataPos;
+	UINT nDrumDataLen, nExtraDataLen;
+	const MT2DRUMSDATA *pdd;
+	const MT2INSTRUMENT *InstrMap[255];
+	const MT2SAMPLE *SampleMap[256];
+
+	if ((!lpStream) || (dwMemLength < sizeof(MT2FILEHEADER))
+	 || (pfh->dwMT20 != 0x3032544D)
+	 || (pfh->wVersion < 0x0200) || (pfh->wVersion >= 0x0300)
+	 || (pfh->wChannels < 4) || (pfh->wChannels > 64)) return FALSE;
+	pdd = NULL;
+	_this->m_nType = MOD_TYPE_MT2;
+	_this->m_nChannels = pfh->wChannels;
+	_this->m_nRestartPos = pfh->wRestart;
+	_this->m_nDefaultSpeed = pfh->bTicksPerLine;
+	_this->m_nDefaultTempo = 125;
+	if ((pfh->wSamplesPerTick > 100) && (pfh->wSamplesPerTick < 5000))
+	{
+		_this->m_nDefaultTempo = 110250 / pfh->wSamplesPerTick;
+	}
+	for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
+	{
+		_this->Order[iOrd] = (BYTE)((iOrd < pfh->nOrders) ? pfh->Orders[iOrd] : 0xFF);
+	}
+	dwMemPos = sizeof(MT2FILEHEADER);
+	nDrumDataLen = *(WORD *)(lpStream + dwMemPos);
+	dwDrumDataPos = dwMemPos + 2;
+	if (nDrumDataLen >= 2) pdd = (MT2DRUMSDATA *)(lpStream+dwDrumDataPos);
+	dwMemPos += 2 + nDrumDataLen;
+	if (dwMemPos >= dwMemLength-12) return TRUE;
+	if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
+	if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
+	nExtraDataLen = *(DWORD *)(lpStream+dwMemPos);
+	dwExtraDataPos = dwMemPos + 4;
+	dwMemPos += 4;
+	if (dwMemPos + nExtraDataLen >= dwMemLength) return TRUE;
+	while (dwMemPos+8 < dwExtraDataPos + nExtraDataLen)
+	{
+		DWORD dwId = *(DWORD *)(lpStream+dwMemPos);
+		DWORD dwLen = *(DWORD *)(lpStream+dwMemPos+4);
+		dwMemPos += 8;
+		if (dwMemPos + dwLen > dwMemLength) return TRUE;
+		switch(dwId)
+		{
+		// MSG
+		case 0x0047534D:
+			break;
+		// SUM -> author name (or "Unregistered")
+		// TMAP
+		// TRKS
+		case 0x534b5254:
+			break;
+		}
+		dwMemPos += dwLen;
+	}
+	// Load Patterns
+	dwMemPos = dwExtraDataPos + nExtraDataLen;
+	for (UINT iPat=0; iPat<pfh->wPatterns; iPat++) if (dwMemPos < dwMemLength-6)
+	{
+		const MT2PATTERN *pmp = (MT2PATTERN *)(lpStream+dwMemPos);
+		UINT wDataLen = (pmp->wDataLen + 1) & ~1;
+		dwMemPos += 6;
+		if (dwMemPos + wDataLen > dwMemLength) break;
+		UINT nLines = pmp->wLines;
+		if ((iPat < MAX_PATTERNS) && (nLines > 0) && (nLines <= 256))
+		{
+			_this->PatternSize[iPat] = nLines;
+			_this->Patterns[iPat] = CSoundFile_AllocatePattern(nLines, _this->m_nChannels);
+			if (!_this->Patterns[iPat]) return TRUE;
+			MODCOMMAND *m = _this->Patterns[iPat];
+			UINT len = wDataLen;
+			if (pfh->fulFlags & 1) // Packed Patterns
+			{
+				BYTE *p = (BYTE *)(lpStream+dwMemPos);
+				UINT pos = 0, row=0, ch=0;
+				while (pos < len)
+				{
+					MT2COMMAND cmd;
+					UINT infobyte = p[pos++];
+					UINT rptcount = 0;
+					if (infobyte == 0xff)
+					{
+						rptcount = p[pos++];
+						infobyte = p[pos++];
+					}
+					if (infobyte & 0x7f)
+					{
+						UINT patpos = row*_this->m_nChannels+ch;
+						cmd.note = cmd.instr = cmd.vol = cmd.pan = cmd.fxcmd = cmd.fxparam1 = cmd.fxparam2 = 0;
+						if (infobyte & 1) cmd.note = p[pos++];
+						if (infobyte & 2) cmd.instr = p[pos++];
+						if (infobyte & 4) cmd.vol = p[pos++];
+						if (infobyte & 8) cmd.pan = p[pos++];
+						if (infobyte & 16) cmd.fxcmd = p[pos++];
+						if (infobyte & 32) cmd.fxparam1 = p[pos++];
+						if (infobyte & 64) cmd.fxparam2 = p[pos++];
+						ConvertMT2Command(_this, &m[patpos], &cmd);
+					}
+					row += rptcount+1;
+					while (row >= nLines) { row-=nLines; ch++; }
+					if (ch >= _this->m_nChannels) break;
+				}
+			} else
+			{
+				const MT2COMMAND *p = (MT2COMMAND *)(lpStream+dwMemPos);
+				UINT n = 0;
+				while ((len > sizeof(MT2COMMAND)) && (n < _this->m_nChannels*nLines))
+				{
+					ConvertMT2Command(_this, m, p);
+					len -= sizeof(MT2COMMAND);
+					n++;
+					p++;
+					m++;
+				}
+			}
+		}
+		dwMemPos += wDataLen;
+	}
+	// Skip Drum Patterns
+	if (pdd)
+	{
+		for (UINT iDrm=0; iDrm<pdd->wDrumPatterns; iDrm++)
+		{
+			if (dwMemPos > dwMemLength-2) return TRUE;
+			UINT nLines = *(WORD *)(lpStream+dwMemPos);
+			dwMemPos += 2 + nLines * 32;
+		}
+	}
+	// Automation
+	if (pfh->fulFlags & 2)
+	{
+		UINT nAutoCount = _this->m_nChannels;
+		if (pfh->fulFlags & 0x10) nAutoCount++; // Master Automation
+		if ((pfh->fulFlags & 0x08) && (pdd)) nAutoCount += 8; // Drums Automation
+		nAutoCount *= pfh->wPatterns;
+		for (UINT iAuto=0; iAuto<nAutoCount; iAuto++)
+		{
+			if (dwMemPos+12 >= dwMemLength) return TRUE;
+			const MT2AUTOMATION *pma = (MT2AUTOMATION *)(lpStream+dwMemPos);
+			dwMemPos += (pfh->wVersion <= 0x201) ? 4 : 8;
+			for (UINT iEnv=0; iEnv<14; iEnv++)
+			{
+				if (pma->dwFlags & (1 << iEnv))
+				{
+					dwMemPos += 260;
+				}
+			}
+		}
+	}
+	// Load Instruments
+	SDL_memset(InstrMap, 0, sizeof(InstrMap));
+	_this->m_nInstruments = (pfh->wInstruments < MAX_INSTRUMENTS) ? pfh->wInstruments : MAX_INSTRUMENTS-1;
+	for (UINT iIns=1; iIns<=255; iIns++)
+	{
+		if (dwMemPos+36 > dwMemLength) return TRUE;
+		const MT2INSTRUMENT *pmi = (MT2INSTRUMENT *)(lpStream+dwMemPos);
+		INSTRUMENTHEADER *penv = NULL;
+		if (iIns <= _this->m_nInstruments)
+		{
+			penv = (INSTRUMENTHEADER *) SDL_malloc(sizeof (INSTRUMENTHEADER));
+			_this->Headers[iIns] = penv;
+			if (penv)
+			{
+				SDL_memset(penv, 0, sizeof(INSTRUMENTHEADER));
+				penv->nGlobalVol = 64;
+				penv->nPan = 128;
+				for (UINT i=0; i<NOTE_MAX; i++)
+				{
+					penv->NoteMap[i] = i+1;
+				}
+			}
+		}
+		if (((LONG)pmi->dwDataLen > 0) && (dwMemPos <= dwMemLength - 40) && (pmi->dwDataLen <= dwMemLength - (dwMemPos + 40)))
+		{
+			InstrMap[iIns-1] = pmi;
+			if (penv)
+			{
+				penv->nFadeOut = pmi->wFadeOut;
+				penv->nNNA = pmi->wNNA & 3;
+				penv->nDCT = (pmi->wNNA>>8) & 3;
+				penv->nDNA = (pmi->wNNA>>12) & 3;
+				MT2ENVELOPE *pehdr[4];
+				WORD *pedata[4];
+				if (pfh->wVersion <= 0x201)
+				{
+					DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT) - 4;
+					pehdr[0] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
+					pehdr[1] = (MT2ENVELOPE *)(lpStream+dwEnvPos+8);
+					pehdr[2] = pehdr[3] = NULL;
+					pedata[0] = (WORD *)(lpStream+dwEnvPos+16);
+					pedata[1] = (WORD *)(lpStream+dwEnvPos+16+64);
+					pedata[2] = pedata[3] = NULL;
+				} else
+				{
+					DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT);
+					for (UINT i=0; i<4; i++)
+					{
+						if (pmi->wEnvFlags1 & (1<<i))
+						{
+							pehdr[i] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
+							pedata[i] = (WORD *)pehdr[i]->EnvData;
+							dwEnvPos += sizeof(MT2ENVELOPE);
+						} else
+						{
+							pehdr[i] = NULL;
+							pedata[i] = NULL;
+						}
+					}
+				}
+				// Load envelopes
+				for (UINT iEnv=0; iEnv<4; iEnv++) if (pehdr[iEnv])
+				{
+					const MT2ENVELOPE *pme = pehdr[iEnv];
+					WORD *pEnvPoints = NULL;
+					BYTE *pEnvData = NULL;
+					switch(iEnv)
+					{
+					// Volume Envelope
+					case 0:
+						if (pme->nFlags & 1) penv->dwFlags |= ENV_VOLUME;
+						if (pme->nFlags & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
+						if (pme->nFlags & 4) penv->dwFlags |= ENV_VOLLOOP;
+						penv->nVolEnv = (pme->nPoints > 16) ? 16 : pme->nPoints;
+						penv->nVolSustainBegin = penv->nVolSustainEnd = pme->nSustainPos;
+						penv->nVolLoopStart = pme->nLoopStart;
+						penv->nVolLoopEnd = pme->nLoopEnd;
+						pEnvPoints = penv->VolPoints;
+						pEnvData = penv->VolEnv;
+						break;
+
+					// Panning Envelope
+					case 1:
+						if (pme->nFlags & 1) penv->dwFlags |= ENV_PANNING;
+						if (pme->nFlags & 2) penv->dwFlags |= ENV_PANSUSTAIN;
+						if (pme->nFlags & 4) penv->dwFlags |= ENV_PANLOOP;
+						penv->nPanEnv = (pme->nPoints > 16) ? 16 : pme->nPoints;
+						penv->nPanSustainBegin = penv->nPanSustainEnd = pme->nSustainPos;
+						penv->nPanLoopStart = pme->nLoopStart;
+						penv->nPanLoopEnd = pme->nLoopEnd;
+						pEnvPoints = penv->PanPoints;
+						pEnvData = penv->PanEnv;
+						break;
+
+					// Pitch/Filter envelope
+					default:
+						if (pme->nFlags & 1) penv->dwFlags |= (iEnv==3) ? (ENV_PITCH|ENV_FILTER) : ENV_PITCH;
+						if (pme->nFlags & 2) penv->dwFlags |= ENV_PITCHSUSTAIN;
+						if (pme->nFlags & 4) penv->dwFlags |= ENV_PITCHLOOP;
+						penv->nPitchEnv = (pme->nPoints > 16) ? 16 : pme->nPoints;
+						penv->nPitchSustainBegin = penv->nPitchSustainEnd = pme->nSustainPos;
+						penv->nPitchLoopStart = pme->nLoopStart;
+						penv->nPitchLoopEnd = pme->nLoopEnd;
+						pEnvPoints = penv->PitchPoints;
+						pEnvData = penv->PitchEnv;
+					}
+					// Envelope data
+					if ((pEnvPoints) && (pEnvData) && (pedata[iEnv]))
+					{
+						WORD *psrc = pedata[iEnv];
+						for (UINT i=0; i<16; i++)
+						{
+							pEnvPoints[i] = psrc[i*2];
+							pEnvData[i] = (BYTE)psrc[i*2+1];
+						}
+					}
+				}
+			}
+			dwMemPos += pmi->dwDataLen + 36;
+			if (pfh->wVersion > 0x201) dwMemPos += 4; // ?
+		} else
+		{
+			dwMemPos += 36;
+		}
+	}
+	SDL_memset(SampleMap, 0, sizeof(SampleMap));
+	_this->m_nSamples = (pfh->wSamples < MAX_SAMPLES) ? pfh->wSamples : MAX_SAMPLES-1;
+	for (UINT iSmp=1; iSmp<=256; iSmp++)
+	{
+		if (dwMemPos+36 > dwMemLength) return TRUE;
+		const MT2SAMPLE *pms = (MT2SAMPLE *)(lpStream+dwMemPos);
+		if (pms->dwDataLen > 0)
+		{
+			SampleMap[iSmp-1] = pms;
+			if (iSmp < MAX_SAMPLES)
+			{
+				MODINSTRUMENT *psmp = &_this->Ins[iSmp];
+				psmp->nGlobalVol = 64;
+				psmp->nVolume = (pms->wVolume >> 7);
+				psmp->nPan = (pms->nPan == 0x80) ? 128 : (pms->nPan^0x80);
+				psmp->nLength = pms->dwLength;
+				psmp->nC4Speed = pms->dwFrequency;
+				psmp->nLoopStart = pms->dwLoopStart;
+				psmp->nLoopEnd = pms->dwLoopEnd;
+				CSoundFile_FrequencyToTransposeInstrument(psmp);
+				psmp->RelativeTone -= pms->nBaseNote - 49;
+				psmp->nC4Speed = CSoundFile_TransposeToFrequency(psmp->RelativeTone, psmp->nFineTune);
+				if (pms->nQuality == 2) { psmp->uFlags |= CHN_16BIT; psmp->nLength >>= 1; }
+				if (pms->nChannels == 2) { psmp->nLength >>= 1; }
+				if (pms->nLoop == 1) psmp->uFlags |= CHN_LOOP;
+				if (pms->nLoop == 2) psmp->uFlags |= CHN_LOOP|CHN_PINGPONGLOOP;
+			}
+			dwMemPos += pms->dwDataLen + 36;
+		} else
+		{
+			dwMemPos += 36;
+		}
+	}
+	for (UINT iMap=0; iMap<255; iMap++) if (InstrMap[iMap])
+	{
+		if (dwMemPos+8 > dwMemLength) return TRUE;
+		const MT2INSTRUMENT *pmi = InstrMap[iMap];
+		INSTRUMENTHEADER *penv = NULL;
+		if (iMap<_this->m_nInstruments) penv = _this->Headers[iMap+1];
+		for (UINT iGrp=0; iGrp<pmi->wSamples; iGrp++)
+		{
+			if (penv)
+			{
+				const MT2GROUP *pmg = (MT2GROUP *)(lpStream+dwMemPos);
+				for (UINT i=0; i<96; i++)
+				{
+					if (pmi->GroupsMapping[i] == iGrp)
+					{
+						UINT nSmp = pmg->nSmpNo+1;
+						penv->Keyboard[i+12] = (BYTE)nSmp;
+						if (nSmp <= _this->m_nSamples)
+						{
+							_this->Ins[nSmp].nVibType = pmi->bVibType;
+							_this->Ins[nSmp].nVibSweep = pmi->bVibSweep;
+							_this->Ins[nSmp].nVibDepth = pmi->bVibDepth;
+							_this->Ins[nSmp].nVibRate = pmi->bVibRate;
+						}
+					}
+				}
+			}
+			dwMemPos += 8;
+		}
+	}
+	for (UINT iData=0; iData<256; iData++) if ((iData < _this->m_nSamples) && (SampleMap[iData]))
+	{
+		const MT2SAMPLE *pms = SampleMap[iData];
+		MODINSTRUMENT *psmp = &_this->Ins[iData+1];
+		if (!(pms->nFlags & 5))
+		{
+			if (psmp->nLength > 0) 
+			{
+				UINT rsflags;
+				
+				if (pms->nChannels == 2)
+					rsflags = (psmp->uFlags & CHN_16BIT) ? RS_STPCM16D : RS_STPCM8D;
+				else
+					rsflags = (psmp->uFlags & CHN_16BIT) ? RS_PCM16D : RS_PCM8D;
+
+				dwMemPos += CSoundFile_ReadSample(_this, psmp, rsflags, (LPCSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
+			}
+		} else
+		if (dwMemPos+4 < dwMemLength)
+		{
+			UINT nNameLen = *(DWORD *)(lpStream+dwMemPos);
+			dwMemPos += nNameLen + 16;
+		}
+		if (dwMemPos+4 >= dwMemLength) break;
+	}
+	return TRUE;
+}
+