mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-25 03:01:03 +00:00
635 lines
17 KiB
C++
635 lines
17 KiB
C++
#include "stdafx.h"
|
|
#include "sndfile.h"
|
|
|
|
//#define MT2DEBUG
|
|
|
|
#pragma pack(1)
|
|
|
|
typedef struct _MT2FILEHEADER
|
|
{
|
|
DWORD dwMT20; // 0x3032544D "MT20"
|
|
DWORD dwSpecial;
|
|
WORD wVersion;
|
|
CHAR szTrackerName[32]; // "MadTracker 2.0"
|
|
CHAR szSongName[64];
|
|
WORD nOrders;
|
|
WORD wRestart;
|
|
WORD wPatterns;
|
|
WORD wChannels;
|
|
WORD wSamplesPerTick;
|
|
BYTE bTicksPerLine;
|
|
BYTE bLinesPerBeat;
|
|
DWORD fulFlags; // b0=packed patterns
|
|
WORD wInstruments;
|
|
WORD wSamples;
|
|
BYTE Orders[256];
|
|
} MT2FILEHEADER;
|
|
|
|
typedef struct _MT2PATTERN
|
|
{
|
|
WORD wLines;
|
|
DWORD wDataLen;
|
|
} MT2PATTERN;
|
|
|
|
typedef struct _MT2COMMAND
|
|
{
|
|
BYTE note; // 0=nothing, 97=note off
|
|
BYTE instr;
|
|
BYTE vol;
|
|
BYTE pan;
|
|
BYTE fxcmd;
|
|
BYTE fxparam1;
|
|
BYTE fxparam2;
|
|
} MT2COMMAND;
|
|
|
|
typedef struct _MT2DRUMSDATA
|
|
{
|
|
WORD wDrumPatterns;
|
|
WORD wDrumSamples[8];
|
|
BYTE DrumPatternOrder[256];
|
|
} MT2DRUMSDATA;
|
|
|
|
typedef struct _MT2AUTOMATION
|
|
{
|
|
DWORD dwFlags;
|
|
DWORD dwEffectId;
|
|
DWORD nEnvPoints;
|
|
} MT2AUTOMATION;
|
|
|
|
typedef struct _MT2INSTRUMENT
|
|
{
|
|
CHAR szName[32];
|
|
DWORD dwDataLen;
|
|
WORD wSamples;
|
|
BYTE GroupsMapping[96];
|
|
BYTE bVibType;
|
|
BYTE bVibSweep;
|
|
BYTE bVibDepth;
|
|
BYTE bVibRate;
|
|
WORD wFadeOut;
|
|
WORD wNNA;
|
|
WORD wInstrFlags;
|
|
WORD wEnvFlags1;
|
|
WORD wEnvFlags2;
|
|
} MT2INSTRUMENT;
|
|
|
|
typedef struct _MT2ENVELOPE
|
|
{
|
|
BYTE nFlags;
|
|
BYTE nPoints;
|
|
BYTE nSustainPos;
|
|
BYTE nLoopStart;
|
|
BYTE nLoopEnd;
|
|
BYTE bReserved[3];
|
|
BYTE EnvData[64];
|
|
} MT2ENVELOPE;
|
|
|
|
typedef struct _MT2SYNTH
|
|
{
|
|
BYTE nSynthId;
|
|
BYTE nFxId;
|
|
WORD wCutOff;
|
|
BYTE nResonance;
|
|
BYTE nAttack;
|
|
BYTE nDecay;
|
|
BYTE bReserved[25];
|
|
} MT2SYNTH;
|
|
|
|
typedef struct _MT2SAMPLE
|
|
{
|
|
CHAR szName[32];
|
|
DWORD dwDataLen;
|
|
DWORD dwLength;
|
|
DWORD dwFrequency;
|
|
BYTE nQuality;
|
|
BYTE nChannels;
|
|
BYTE nFlags;
|
|
BYTE nLoop;
|
|
DWORD dwLoopStart;
|
|
DWORD dwLoopEnd;
|
|
WORD wVolume;
|
|
BYTE nPan;
|
|
BYTE nBaseNote;
|
|
WORD wSamplesPerBeat;
|
|
} MT2SAMPLE;
|
|
|
|
typedef struct _MT2GROUP
|
|
{
|
|
BYTE nSmpNo;
|
|
BYTE nVolume; // 0-128
|
|
BYTE nFinePitch;
|
|
BYTE Reserved[5];
|
|
} MT2GROUP;
|
|
|
|
#pragma pack()
|
|
|
|
|
|
static VOID ConvertMT2Command(CSoundFile *that, MODCOMMAND *m, MT2COMMAND *p)
|
|
//---------------------------------------------------------------------------
|
|
{
|
|
// Note
|
|
m->note = 0;
|
|
if (p->note) m->note = (p->note > 96) ? 0xFF : p->note+12;
|
|
// Instrument
|
|
m->instr = p->instr;
|
|
// Volume Column
|
|
if ((p->vol >= 0x10) && (p->vol <= 0x90))
|
|
{
|
|
m->volcmd = VOLCMD_VOLUME;
|
|
m->vol = (p->vol - 0x10) >> 1;
|
|
} else
|
|
if ((p->vol >= 0xA0) && (p->vol <= 0xAF))
|
|
{
|
|
m->volcmd = VOLCMD_VOLSLIDEDOWN;
|
|
m->vol = (p->vol & 0x0f);
|
|
} else
|
|
if ((p->vol >= 0xB0) && (p->vol <= 0xBF))
|
|
{
|
|
m->volcmd = VOLCMD_VOLSLIDEUP;
|
|
m->vol = (p->vol & 0x0f);
|
|
} else
|
|
if ((p->vol >= 0xC0) && (p->vol <= 0xCF))
|
|
{
|
|
m->volcmd = VOLCMD_FINEVOLDOWN;
|
|
m->vol = (p->vol & 0x0f);
|
|
} else
|
|
if ((p->vol >= 0xD0) && (p->vol <= 0xDF))
|
|
{
|
|
m->volcmd = VOLCMD_FINEVOLUP;
|
|
m->vol = (p->vol & 0x0f);
|
|
} else
|
|
{
|
|
m->volcmd = 0;
|
|
m->vol = 0;
|
|
}
|
|
// Effects
|
|
m->command = 0;
|
|
m->param = 0;
|
|
if ((p->fxcmd) || (p->fxparam1) || (p->fxparam2))
|
|
{
|
|
if (!p->fxcmd)
|
|
{
|
|
m->command = p->fxparam2;
|
|
m->param = p->fxparam1;
|
|
that->ConvertModCommand(m);
|
|
} else
|
|
{
|
|
// TODO: MT2 Effects
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CSoundFile::ReadMT2(LPCBYTE lpStream, DWORD dwMemLength)
|
|
//-----------------------------------------------------------
|
|
{
|
|
MT2FILEHEADER *pfh = (MT2FILEHEADER *)lpStream;
|
|
DWORD dwMemPos, dwDrumDataPos, dwExtraDataPos;
|
|
UINT nDrumDataLen, nExtraDataLen;
|
|
MT2DRUMSDATA *pdd;
|
|
MT2INSTRUMENT *InstrMap[255];
|
|
MT2SAMPLE *SampleMap[256];
|
|
|
|
if ((!lpStream) || (dwMemLength < sizeof(MT2FILEHEADER))
|
|
|| (pfh->dwMT20 != 0x3032544D)
|
|
|| (pfh->wVersion < 0x0200) || (pfh->wVersion >= 0x0300)
|
|
|| (pfh->wChannels < 4) || (pfh->wChannels > 64)) return FALSE;
|
|
pdd = NULL;
|
|
m_nType = MOD_TYPE_MT2;
|
|
m_nChannels = pfh->wChannels;
|
|
m_nRestartPos = pfh->wRestart;
|
|
m_nDefaultSpeed = pfh->bTicksPerLine;
|
|
m_nDefaultTempo = 125;
|
|
if ((pfh->wSamplesPerTick > 100) && (pfh->wSamplesPerTick < 5000))
|
|
{
|
|
m_nDefaultTempo = 110250 / pfh->wSamplesPerTick;
|
|
}
|
|
for (UINT iOrd=0; iOrd<MAX_ORDERS; iOrd++)
|
|
{
|
|
Order[iOrd] = (BYTE)((iOrd < pfh->nOrders) ? pfh->Orders[iOrd] : 0xFF);
|
|
}
|
|
memcpy(m_szNames[0], pfh->szSongName, 32);
|
|
m_szNames[0][31] = 0;
|
|
dwMemPos = sizeof(MT2FILEHEADER);
|
|
nDrumDataLen = *(WORD *)(lpStream + dwMemPos);
|
|
dwDrumDataPos = dwMemPos + 2;
|
|
if (nDrumDataLen >= 2) pdd = (MT2DRUMSDATA *)(lpStream+dwDrumDataPos);
|
|
dwMemPos += 2 + nDrumDataLen;
|
|
#ifdef MT2DEBUG
|
|
|
|
Log("MT2 v%03X: \"%s\" (flags=%04X)\n", pfh->wVersion, m_szNames[0], pfh->fulFlags);
|
|
Log("%d Channels, %d Patterns, %d Instruments, %d Samples\n", pfh->wChannels, pfh->wPatterns, pfh->wInstruments, pfh->wSamples);
|
|
Log("Drum Data: %d bytes @%04X\n", nDrumDataLen, dwDrumDataPos);
|
|
#endif
|
|
if (dwMemPos >= dwMemLength-12) return TRUE;
|
|
if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
|
|
if (!*(DWORD *)(lpStream+dwMemPos)) dwMemPos += 4;
|
|
nExtraDataLen = *(DWORD *)(lpStream+dwMemPos);
|
|
dwExtraDataPos = dwMemPos + 4;
|
|
dwMemPos += 4;
|
|
#ifdef MT2DEBUG
|
|
Log("Extra Data: %d bytes @%04X\n", nExtraDataLen, dwExtraDataPos);
|
|
#endif
|
|
if (dwMemPos + nExtraDataLen >= dwMemLength) return TRUE;
|
|
while (dwMemPos+8 < dwExtraDataPos + nExtraDataLen)
|
|
{
|
|
DWORD dwId = *(DWORD *)(lpStream+dwMemPos);
|
|
DWORD dwLen = *(DWORD *)(lpStream+dwMemPos+4);
|
|
dwMemPos += 8;
|
|
if (dwMemPos + dwLen > dwMemLength) return TRUE;
|
|
#ifdef MT2DEBUG
|
|
CHAR s[5];
|
|
memcpy(s, &dwId, 4);
|
|
s[4] = 0;
|
|
Log("pos=0x%04X: %s: %d bytes\n", dwMemPos-8, s, dwLen);
|
|
#endif
|
|
switch(dwId)
|
|
{
|
|
// MSG
|
|
case 0x0047534D:
|
|
if ((dwLen > 3) && (!m_lpszSongComments))
|
|
{
|
|
DWORD nTxtLen = dwLen;
|
|
if (nTxtLen > 32000) nTxtLen = 32000;
|
|
m_lpszSongComments = new char[nTxtLen]; // changed from CHAR
|
|
if (m_lpszSongComments)
|
|
{
|
|
memcpy(m_lpszSongComments, lpStream+dwMemPos+1, nTxtLen-1);
|
|
m_lpszSongComments[nTxtLen-1] = 0;
|
|
}
|
|
}
|
|
break;
|
|
// SUM -> author name (or "Unregistered")
|
|
// TMAP
|
|
// TRKS
|
|
case 0x534b5254:
|
|
break;
|
|
}
|
|
dwMemPos += dwLen;
|
|
}
|
|
// Load Patterns
|
|
dwMemPos = dwExtraDataPos + nExtraDataLen;
|
|
for (UINT iPat=0; iPat<pfh->wPatterns; iPat++) if (dwMemPos < dwMemLength-6)
|
|
{
|
|
MT2PATTERN *pmp = (MT2PATTERN *)(lpStream+dwMemPos);
|
|
UINT wDataLen = (pmp->wDataLen + 1) & ~1;
|
|
dwMemPos += 6;
|
|
if (dwMemPos + wDataLen > dwMemLength) break;
|
|
UINT nLines = pmp->wLines;
|
|
if ((iPat < MAX_PATTERNS) && (nLines > 0) && (nLines <= 256))
|
|
{
|
|
#ifdef MT2DEBUG
|
|
Log("Pattern #%d @%04X: %d lines, %d bytes\n", iPat, dwMemPos-6, nLines, pmp->wDataLen);
|
|
#endif
|
|
PatternSize[iPat] = nLines;
|
|
Patterns[iPat] = AllocatePattern(nLines, m_nChannels);
|
|
if (!Patterns[iPat]) return TRUE;
|
|
MODCOMMAND *m = Patterns[iPat];
|
|
UINT len = wDataLen;
|
|
if (pfh->fulFlags & 1) // Packed Patterns
|
|
{
|
|
BYTE *p = (BYTE *)(lpStream+dwMemPos);
|
|
UINT pos = 0, row=0, ch=0;
|
|
while (pos < len)
|
|
{
|
|
MT2COMMAND cmd;
|
|
UINT infobyte = p[pos++];
|
|
UINT rptcount = 0;
|
|
if (infobyte == 0xff)
|
|
{
|
|
rptcount = p[pos++];
|
|
infobyte = p[pos++];
|
|
#if 0
|
|
Log("(%d.%d) FF(%02X).%02X\n", row, ch, rptcount, infobyte);
|
|
} else
|
|
{
|
|
Log("(%d.%d) %02X\n", row, ch, infobyte);
|
|
#endif
|
|
}
|
|
if (infobyte & 0x7f)
|
|
{
|
|
UINT patpos = row*m_nChannels+ch;
|
|
cmd.note = cmd.instr = cmd.vol = cmd.pan = cmd.fxcmd = cmd.fxparam1 = cmd.fxparam2 = 0;
|
|
if (infobyte & 1) cmd.note = p[pos++];
|
|
if (infobyte & 2) cmd.instr = p[pos++];
|
|
if (infobyte & 4) cmd.vol = p[pos++];
|
|
if (infobyte & 8) cmd.pan = p[pos++];
|
|
if (infobyte & 16) cmd.fxcmd = p[pos++];
|
|
if (infobyte & 32) cmd.fxparam1 = p[pos++];
|
|
if (infobyte & 64) cmd.fxparam2 = p[pos++];
|
|
#ifdef MT2DEBUG
|
|
if (cmd.fxcmd)
|
|
{
|
|
Log("(%d.%d) MT2 FX=%02X.%02X.%02X\n", row, ch, cmd.fxcmd, cmd.fxparam1, cmd.fxparam2);
|
|
}
|
|
#endif
|
|
ConvertMT2Command(this, &m[patpos], &cmd);
|
|
}
|
|
row += rptcount+1;
|
|
while (row >= nLines) { row-=nLines; ch++; }
|
|
if (ch >= m_nChannels) break;
|
|
}
|
|
} else
|
|
{
|
|
MT2COMMAND *p = (MT2COMMAND *)(lpStream+dwMemPos);
|
|
UINT n = 0;
|
|
while ((len > sizeof(MT2COMMAND)) && (n < m_nChannels*nLines))
|
|
{
|
|
ConvertMT2Command(this, m, p);
|
|
len -= sizeof(MT2COMMAND);
|
|
n++;
|
|
p++;
|
|
m++;
|
|
}
|
|
}
|
|
}
|
|
dwMemPos += wDataLen;
|
|
}
|
|
// Skip Drum Patterns
|
|
if (pdd)
|
|
{
|
|
#ifdef MT2DEBUG
|
|
Log("%d Drum Patterns at offset 0x%08X\n", pdd->wDrumPatterns, dwMemPos);
|
|
#endif
|
|
for (UINT iDrm=0; iDrm<pdd->wDrumPatterns; iDrm++)
|
|
{
|
|
if (dwMemPos > dwMemLength-2) return TRUE;
|
|
UINT nLines = *(WORD *)(lpStream+dwMemPos);
|
|
#ifdef MT2DEBUG
|
|
if (nLines != 64) Log("Drum Pattern %d: %d Lines @%04X\n", iDrm, nLines, dwMemPos);
|
|
#endif
|
|
dwMemPos += 2 + nLines * 32;
|
|
}
|
|
}
|
|
// Automation
|
|
if (pfh->fulFlags & 2)
|
|
{
|
|
#ifdef MT2DEBUG
|
|
Log("Automation at offset 0x%08X\n", dwMemPos);
|
|
#endif
|
|
UINT nAutoCount = m_nChannels;
|
|
if (pfh->fulFlags & 0x10) nAutoCount++; // Master Automation
|
|
if ((pfh->fulFlags & 0x08) && (pdd)) nAutoCount += 8; // Drums Automation
|
|
nAutoCount *= pfh->wPatterns;
|
|
for (UINT iAuto=0; iAuto<nAutoCount; iAuto++)
|
|
{
|
|
if (dwMemPos+12 >= dwMemLength) return TRUE;
|
|
MT2AUTOMATION *pma = (MT2AUTOMATION *)(lpStream+dwMemPos);
|
|
dwMemPos += (pfh->wVersion <= 0x201) ? 4 : 8;
|
|
for (UINT iEnv=0; iEnv<14; iEnv++)
|
|
{
|
|
if (pma->dwFlags & (1 << iEnv))
|
|
{
|
|
#ifdef MT2DEBUG
|
|
UINT nPoints = *(DWORD *)(lpStream+dwMemPos);
|
|
Log(" Env[%d/%d] %04X @%04X: %d points\n", iAuto, nAutoCount, 1 << iEnv, dwMemPos-8, nPoints);
|
|
#endif
|
|
dwMemPos += 260;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Load Instruments
|
|
#ifdef MT2DEBUG
|
|
Log("Loading instruments at offset 0x%08X\n", dwMemPos);
|
|
#endif
|
|
memset(InstrMap, 0, sizeof(InstrMap));
|
|
m_nInstruments = (pfh->wInstruments < MAX_INSTRUMENTS) ? pfh->wInstruments : MAX_INSTRUMENTS-1;
|
|
for (UINT iIns=1; iIns<=255; iIns++)
|
|
{
|
|
if (dwMemPos+36 > dwMemLength) return TRUE;
|
|
MT2INSTRUMENT *pmi = (MT2INSTRUMENT *)(lpStream+dwMemPos);
|
|
INSTRUMENTHEADER *penv = NULL;
|
|
if (iIns <= m_nInstruments)
|
|
{
|
|
penv = new INSTRUMENTHEADER;
|
|
Headers[iIns] = penv;
|
|
if (penv)
|
|
{
|
|
memset(penv, 0, sizeof(INSTRUMENTHEADER));
|
|
memcpy(penv->name, pmi->szName, 32);
|
|
penv->nGlobalVol = 64;
|
|
penv->nPan = 128;
|
|
for (UINT i=0; i<120; i++)
|
|
{
|
|
penv->NoteMap[i] = i+1;
|
|
}
|
|
}
|
|
}
|
|
#ifdef MT2DEBUG
|
|
if (iIns <= pfh->wInstruments) Log(" Instrument #%d at offset %04X: %d bytes\n", iIns, dwMemPos, pmi->dwDataLen);
|
|
#endif
|
|
if (((LONG)pmi->dwDataLen > 0) && (dwMemPos + pmi->dwDataLen + 40 <= dwMemLength))
|
|
{
|
|
InstrMap[iIns-1] = pmi;
|
|
if (penv)
|
|
{
|
|
penv->nFadeOut = pmi->wFadeOut;
|
|
penv->nNNA = pmi->wNNA & 3;
|
|
penv->nDCT = (pmi->wNNA>>8) & 3;
|
|
penv->nDNA = (pmi->wNNA>>12) & 3;
|
|
MT2ENVELOPE *pehdr[4];
|
|
WORD *pedata[4];
|
|
if (pfh->wVersion <= 0x201)
|
|
{
|
|
DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT) - 4;
|
|
pehdr[0] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
|
|
pehdr[1] = (MT2ENVELOPE *)(lpStream+dwEnvPos+8);
|
|
pehdr[2] = pehdr[3] = NULL;
|
|
pedata[0] = (WORD *)(lpStream+dwEnvPos+16);
|
|
pedata[1] = (WORD *)(lpStream+dwEnvPos+16+64);
|
|
pedata[2] = pedata[3] = NULL;
|
|
} else
|
|
{
|
|
DWORD dwEnvPos = dwMemPos + sizeof(MT2INSTRUMENT);
|
|
for (UINT i=0; i<4; i++)
|
|
{
|
|
if (pmi->wEnvFlags1 & (1<<i))
|
|
{
|
|
pehdr[i] = (MT2ENVELOPE *)(lpStream+dwEnvPos);
|
|
pedata[i] = (WORD *)pehdr[i]->EnvData;
|
|
dwEnvPos += sizeof(MT2ENVELOPE);
|
|
} else
|
|
{
|
|
pehdr[i] = NULL;
|
|
pedata[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
// Load envelopes
|
|
for (UINT iEnv=0; iEnv<4; iEnv++) if (pehdr[iEnv])
|
|
{
|
|
MT2ENVELOPE *pme = pehdr[iEnv];
|
|
WORD *pEnvPoints = NULL;
|
|
BYTE *pEnvData = NULL;
|
|
#ifdef MT2DEBUG
|
|
Log(" Env %d.%d @%04X: %d points\n", iIns, iEnv, (UINT)(((BYTE *)pme)-lpStream), pme->nPoints);
|
|
#endif
|
|
switch(iEnv)
|
|
{
|
|
// Volume Envelope
|
|
case 0:
|
|
if (pme->nFlags & 1) penv->dwFlags |= ENV_VOLUME;
|
|
if (pme->nFlags & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
|
|
if (pme->nFlags & 4) penv->dwFlags |= ENV_VOLLOOP;
|
|
penv->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;
|
|
}
|
|
}
|
|
#ifdef MT2DEBUG
|
|
Log("Loading samples at offset 0x%08X\n", dwMemPos);
|
|
#endif
|
|
memset(SampleMap, 0, sizeof(SampleMap));
|
|
m_nSamples = (pfh->wSamples < MAX_SAMPLES) ? pfh->wSamples : MAX_SAMPLES-1;
|
|
for (UINT iSmp=1; iSmp<=256; iSmp++)
|
|
{
|
|
if (dwMemPos+36 > dwMemLength) return TRUE;
|
|
MT2SAMPLE *pms = (MT2SAMPLE *)(lpStream+dwMemPos);
|
|
#ifdef MT2DEBUG
|
|
if (iSmp <= m_nSamples) Log(" Sample #%d at offset %04X: %d bytes\n", iSmp, dwMemPos, pms->dwDataLen);
|
|
#endif
|
|
if (iSmp < MAX_SAMPLES)
|
|
{
|
|
memcpy(m_szNames[iSmp], pms->szName, 32);
|
|
}
|
|
if (pms->dwDataLen > 0)
|
|
{
|
|
SampleMap[iSmp-1] = pms;
|
|
if (iSmp < MAX_SAMPLES)
|
|
{
|
|
MODINSTRUMENT *psmp = &Ins[iSmp];
|
|
psmp->nGlobalVol = 64;
|
|
psmp->nVolume = (pms->wVolume >> 7);
|
|
psmp->nPan = (pms->nPan == 0x80) ? 128 : (pms->nPan^0x80);
|
|
psmp->nLength = pms->dwLength;
|
|
psmp->nC4Speed = pms->dwFrequency;
|
|
psmp->nLoopStart = pms->dwLoopStart;
|
|
psmp->nLoopEnd = pms->dwLoopEnd;
|
|
FrequencyToTranspose(psmp);
|
|
psmp->RelativeTone -= pms->nBaseNote - 49;
|
|
psmp->nC4Speed = TransposeToFrequency(psmp->RelativeTone, psmp->nFineTune);
|
|
if (pms->nQuality == 2) { psmp->uFlags |= CHN_16BIT; psmp->nLength >>= 1; }
|
|
if (pms->nChannels == 2) { psmp->nLength >>= 1; }
|
|
if (pms->nLoop == 1) psmp->uFlags |= CHN_LOOP;
|
|
if (pms->nLoop == 2) psmp->uFlags |= CHN_LOOP|CHN_PINGPONGLOOP;
|
|
}
|
|
dwMemPos += pms->dwDataLen + 36;
|
|
} else
|
|
{
|
|
dwMemPos += 36;
|
|
}
|
|
}
|
|
#ifdef MT2DEBUG
|
|
Log("Loading groups at offset 0x%08X\n", dwMemPos);
|
|
#endif
|
|
for (UINT iMap=0; iMap<255; iMap++) if (InstrMap[iMap])
|
|
{
|
|
if (dwMemPos+8 > dwMemLength) return TRUE;
|
|
MT2INSTRUMENT *pmi = InstrMap[iMap];
|
|
INSTRUMENTHEADER *penv = NULL;
|
|
if (iMap<m_nInstruments) penv = Headers[iMap+1];
|
|
for (UINT iGrp=0; iGrp<pmi->wSamples; iGrp++)
|
|
{
|
|
if (penv)
|
|
{
|
|
MT2GROUP *pmg = (MT2GROUP *)(lpStream+dwMemPos);
|
|
for (UINT i=0; i<96; i++)
|
|
{
|
|
if (pmi->GroupsMapping[i] == iGrp)
|
|
{
|
|
UINT nSmp = pmg->nSmpNo+1;
|
|
penv->Keyboard[i+12] = (BYTE)nSmp;
|
|
if (nSmp <= m_nSamples)
|
|
{
|
|
Ins[nSmp].nVibType = pmi->bVibType;
|
|
Ins[nSmp].nVibSweep = pmi->bVibSweep;
|
|
Ins[nSmp].nVibDepth = pmi->bVibDepth;
|
|
Ins[nSmp].nVibRate = pmi->bVibRate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
dwMemPos += 8;
|
|
}
|
|
}
|
|
#ifdef MT2DEBUG
|
|
Log("Loading sample data at offset 0x%08X\n", dwMemPos);
|
|
#endif
|
|
for (UINT iData=0; iData<256; iData++) if ((iData < m_nSamples) && (SampleMap[iData]))
|
|
{
|
|
MT2SAMPLE *pms = SampleMap[iData];
|
|
MODINSTRUMENT *psmp = &Ins[iData+1];
|
|
if (!(pms->nFlags & 5))
|
|
{
|
|
if (psmp->nLength > 0)
|
|
{
|
|
#ifdef MT2DEBUG
|
|
Log(" Reading sample #%d at offset 0x%04X (len=%d)\n", iData+1, dwMemPos, psmp->nLength);
|
|
#endif
|
|
UINT rsflags;
|
|
|
|
if (pms->nChannels == 2)
|
|
rsflags = (psmp->uFlags & CHN_16BIT) ? RS_STPCM16D : RS_STPCM8D;
|
|
else
|
|
rsflags = (psmp->uFlags & CHN_16BIT) ? RS_PCM16D : RS_PCM8D;
|
|
|
|
dwMemPos += ReadSample(psmp, rsflags, (LPCSTR)(lpStream+dwMemPos), dwMemLength-dwMemPos);
|
|
}
|
|
} else
|
|
if (dwMemPos+4 < dwMemLength)
|
|
{
|
|
UINT nNameLen = *(DWORD *)(lpStream+dwMemPos);
|
|
dwMemPos += nNameLen + 16;
|
|
}
|
|
if (dwMemPos+4 >= dwMemLength) break;
|
|
}
|
|
return TRUE;
|
|
}
|