mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-12 19:36:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/modplug/libmodplug/load_xm.cpp
Jeremy Simon ac87bfc370 adding modplug 
Original commit message from CVS:
adding modplug
2002-02-28 21:10:42 +00:00

892 lines
26 KiB
C++
Raw Blame History

/*
* This source code is public domain.
*
* Authors: Olivier Lapicque <olivierl@jps.net>,
* Adam Goode <adam@evdebs.org> (endian and char fixes for PPC)
*/
#include "stdafx.h"
#include "sndfile.h"
////////////////////////////////////////////////////////
// FastTracker II XM file support
#ifdef MSC_VER
#pragma warning(disable:4244)
#endif
#pragma pack(1)
typedef struct tagXMFILEHEADER
{
DWORD size;
WORD norder;
WORD restartpos;
WORD channels;
WORD patterns;
WORD instruments;
WORD flags;
WORD speed;
WORD tempo;
BYTE order[256];
} XMFILEHEADER;
typedef struct tagXMINSTRUMENTHEADER
{
DWORD size;
CHAR name[22];
BYTE type;
BYTE samples;
BYTE samplesh;
} XMINSTRUMENTHEADER;
typedef struct tagXMSAMPLEHEADER
{
DWORD shsize;
BYTE snum[96];
WORD venv[24];
WORD penv[24];
BYTE vnum, pnum;
BYTE vsustain, vloops, vloope, psustain, ploops, ploope;
BYTE vtype, ptype;
BYTE vibtype, vibsweep, vibdepth, vibrate;
WORD volfade;
WORD res;
BYTE reserved1[20];
} XMSAMPLEHEADER;
typedef struct tagXMSAMPLESTRUCT
{
DWORD samplen;
DWORD loopstart;
DWORD looplen;
BYTE vol;
signed char finetune;
BYTE type;
BYTE pan;
signed char relnote;
BYTE res;
char name[22];
} XMSAMPLESTRUCT;
#pragma pack()
BOOL CSoundFile::ReadXM(const BYTE *lpStream, DWORD dwMemLength)
//--------------------------------------------------------------
{
XMSAMPLEHEADER xmsh;
XMSAMPLESTRUCT xmss;
DWORD dwMemPos, dwHdrSize;
WORD norders=0, restartpos=0, channels=0, patterns=0, instruments=0;
WORD xmflags=0, deftempo=125, defspeed=6;
BOOL InstUsed[256];
BYTE channels_used[MAX_CHANNELS];
BYTE pattern_map[256];
BOOL samples_used[MAX_SAMPLES];
UINT unused_samples;
m_nChannels = 0;
if ((!lpStream) || (dwMemLength < 0x200)) return FALSE;
if (strnicmp((LPCSTR)lpStream, "Extended Module", 15)) return FALSE;
memcpy(m_szNames[0], lpStream+17, 20);
dwHdrSize = bswapLE32(*((DWORD *)(lpStream+60)));
norders = bswapLE16(*((WORD *)(lpStream+64)));
if ((!norders) || (norders > MAX_ORDERS)) return FALSE;
restartpos = bswapLE16(*((WORD *)(lpStream+66)));
channels = bswapLE16(*((WORD *)(lpStream+68)));
if ((!channels) || (channels > 64)) return FALSE;
m_nType = MOD_TYPE_XM;
m_nMinPeriod = 27;
m_nMaxPeriod = 54784;
m_nChannels = channels;
if (restartpos < norders) m_nRestartPos = restartpos;
patterns = bswapLE16(*((WORD *)(lpStream+70)));
if (patterns > 256) patterns = 256;
instruments = bswapLE16(*((WORD *)(lpStream+72)));
if (instruments >= MAX_INSTRUMENTS) instruments = MAX_INSTRUMENTS-1;
m_nInstruments = instruments;
m_nSamples = 0;
memcpy(&xmflags, lpStream+74, 2);
xmflags = bswapLE16(xmflags);
if (xmflags & 1) m_dwSongFlags |= SONG_LINEARSLIDES;
if (xmflags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE;
defspeed = bswapLE16(*((WORD *)(lpStream+76)));
deftempo = bswapLE16(*((WORD *)(lpStream+78)));
if ((deftempo >= 32) && (deftempo < 256)) m_nDefaultTempo = deftempo;
if ((defspeed > 0) && (defspeed < 40)) m_nDefaultSpeed = defspeed;
memcpy(Order, lpStream+80, norders);
memset(InstUsed, 0, sizeof(InstUsed));
if (patterns > MAX_PATTERNS)
{
UINT i, j;
for (i=0; i<norders; i++)
{
if (Order[i] < patterns) InstUsed[Order[i]] = TRUE;
}
j = 0;
for (i=0; i<256; i++)
{
if (InstUsed[i]) pattern_map[i] = j++;
}
for (i=0; i<256; i++)
{
if (!InstUsed[i])
{
pattern_map[i] = (j < MAX_PATTERNS) ? j : 0xFE;
j++;
}
}
for (i=0; i<norders; i++)
{
Order[i] = pattern_map[Order[i]];
}
} else
{
for (UINT i=0; i<256; i++) pattern_map[i] = i;
}
memset(InstUsed, 0, sizeof(InstUsed));
dwMemPos = dwHdrSize + 60;
if (dwMemPos + 8 >= dwMemLength) return TRUE;
// Reading patterns
memset(channels_used, 0, sizeof(channels_used));
for (UINT ipat=0; ipat<patterns; ipat++)
{
UINT ipatmap = pattern_map[ipat];
DWORD dwSize = 0;
WORD rows=64, packsize=0;
dwSize = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
while ((dwMemPos + dwSize >= dwMemLength) || (dwSize & 0xFFFFFF00))
{
if (dwMemPos + 4 >= dwMemLength) break;
dwMemPos++;
dwSize = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
}
rows = bswapLE16(*((WORD *)(lpStream+dwMemPos+5)));
if ((!rows) || (rows > 256)) rows = 64;
packsize = bswapLE16(*((WORD *)(lpStream+dwMemPos+7)));
if (dwMemPos + dwSize + 4 > dwMemLength) return TRUE;
dwMemPos += dwSize;
if (dwMemPos + packsize + 4 > dwMemLength) return TRUE;
MODCOMMAND *p;
if (ipatmap < MAX_PATTERNS)
{
PatternSize[ipatmap] = rows;
if ((Patterns[ipatmap] = AllocatePattern(rows, m_nChannels)) == NULL) return TRUE;
if (!packsize) continue;
p = Patterns[ipatmap];
} else p = NULL;
const BYTE *src = lpStream+dwMemPos;
UINT j=0;
for (UINT row=0; row<rows; row++)
{
for (UINT chn=0; chn<m_nChannels; chn++)
{
if ((p) && (j < packsize))
{
BYTE b = src[j++];
UINT vol = 0;
if (b & 0x80)
{
if (b & 1) p->note = src[j++];
if (b & 2) p->instr = src[j++];
if (b & 4) vol = src[j++];
if (b & 8) p->command = src[j++];
if (b & 16) p->param = src[j++];
} else
{
p->note = b;
p->instr = src[j++];
vol = src[j++];
p->command = src[j++];
p->param = src[j++];
}
if (p->note == 97) p->note = 0xFF; else
if ((p->note) && (p->note < 97)) p->note += 12;
if (p->note) channels_used[chn] = 1;
if (p->command | p->param) ConvertModCommand(p);
if (p->instr == 0xff) p->instr = 0;
if (p->instr) InstUsed[p->instr] = TRUE;
if ((vol >= 0x10) && (vol <= 0x50))
{
p->volcmd = VOLCMD_VOLUME;
p->vol = vol - 0x10;
} else
if (vol >= 0x60)
{
UINT v = vol & 0xF0;
vol &= 0x0F;
p->vol = vol;
switch(v)
{
// 60-6F: Volume Slide Down
case 0x60: p->volcmd = VOLCMD_VOLSLIDEDOWN; break;
// 70-7F: Volume Slide Up:
case 0x70: p->volcmd = VOLCMD_VOLSLIDEUP; break;
// 80-8F: Fine Volume Slide Down
case 0x80: p->volcmd = VOLCMD_FINEVOLDOWN; break;
// 90-9F: Fine Volume Slide Up
case 0x90: p->volcmd = VOLCMD_FINEVOLUP; break;
// A0-AF: Set Vibrato Speed
case 0xA0: p->volcmd = VOLCMD_VIBRATOSPEED; break;
// B0-BF: Vibrato
case 0xB0: p->volcmd = VOLCMD_VIBRATO; break;
// C0-CF: Set Panning
case 0xC0: p->volcmd = VOLCMD_PANNING; p->vol = (vol << 2) + 2; break;
// D0-DF: Panning Slide Left
case 0xD0: p->volcmd = VOLCMD_PANSLIDELEFT; break;
// E0-EF: Panning Slide Right
case 0xE0: p->volcmd = VOLCMD_PANSLIDERIGHT; break;
// F0-FF: Tone Portamento
case 0xF0: p->volcmd = VOLCMD_TONEPORTAMENTO; break;
}
}
p++;
} else
if (j < packsize)
{
BYTE b = src[j++];
if (b & 0x80)
{
if (b & 1) j++;
if (b & 2) j++;
if (b & 4) j++;
if (b & 8) j++;
if (b & 16) j++;
} else j += 4;
} else break;
}
}
dwMemPos += packsize;
}
// Wrong offset check
while (dwMemPos + 4 < dwMemLength)
{
DWORD d = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
if (d < 0x300) break;
dwMemPos++;
}
memset(samples_used, 0, sizeof(samples_used));
unused_samples = 0;
// Reading instruments
for (UINT iIns=1; iIns<=instruments; iIns++)
{
XMINSTRUMENTHEADER *pih;
BYTE flags[32];
DWORD samplesize[32];
UINT samplemap[32];
WORD nsamples;
if (dwMemPos + sizeof(XMINSTRUMENTHEADER) >= dwMemLength) return TRUE;
pih = (XMINSTRUMENTHEADER *)(lpStream+dwMemPos);
if (dwMemPos + bswapLE32(pih->size) > dwMemLength) return TRUE;
if ((Headers[iIns] = new INSTRUMENTHEADER) == NULL) continue;
memset(Headers[iIns], 0, sizeof(INSTRUMENTHEADER));
memcpy(Headers[iIns]->name, pih->name, 22);
if ((nsamples = pih->samples) > 0)
{
if (dwMemPos + sizeof(XMSAMPLEHEADER) > dwMemLength) return TRUE;
memcpy(&xmsh, lpStream+dwMemPos+sizeof(XMINSTRUMENTHEADER), sizeof(XMSAMPLEHEADER));
xmsh.shsize = bswapLE32(xmsh.shsize);
for (int i = 0; i < 24; ++i) {
xmsh.venv[i] = bswapLE16(xmsh.venv[i]);
xmsh.penv[i] = bswapLE16(xmsh.penv[i]);
}
xmsh.volfade = bswapLE16(xmsh.volfade);
xmsh.res = bswapLE16(xmsh.res);
dwMemPos += bswapLE32(pih->size);
} else
{
if (bswapLE32(pih->size)) dwMemPos += bswapLE32(pih->size);
else dwMemPos += sizeof(XMINSTRUMENTHEADER);
continue;
}
memset(samplemap, 0, sizeof(samplemap));
if (nsamples > 32) return TRUE;
UINT newsamples = m_nSamples;
for (UINT nmap=0; nmap<nsamples; nmap++)
{
UINT n = m_nSamples+nmap+1;
if (n >= MAX_SAMPLES)
{
n = m_nSamples;
while (n > 0)
{
if (!Ins[n].pSample)
{
for (UINT xmapchk=0; xmapchk < nmap; xmapchk++)
{
if (samplemap[xmapchk] == n) goto alreadymapped;
}
for (UINT clrs=1; clrs<iIns; clrs++) if (Headers[clrs])
{
INSTRUMENTHEADER *pks = Headers[clrs];
for (UINT ks=0; ks<128; ks++)
{
if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0;
}
}
break;
}
alreadymapped:
n--;
}
#ifndef FASTSOUNDLIB
// Damn! more than 200 samples: look for duplicates
if (!n)
{
if (!unused_samples)
{
unused_samples = DetectUnusedSamples(samples_used);
if (!unused_samples) unused_samples = 0xFFFF;
}
if ((unused_samples) && (unused_samples != 0xFFFF))
{
for (UINT iext=m_nSamples; iext>=1; iext--) if (!samples_used[iext])
{
unused_samples--;
samples_used[iext] = TRUE;
DestroySample(iext);
n = iext;
for (UINT mapchk=0; mapchk<nmap; mapchk++)
{
if (samplemap[mapchk] == n) samplemap[mapchk] = 0;
}
for (UINT clrs=1; clrs<iIns; clrs++) if (Headers[clrs])
{
INSTRUMENTHEADER *pks = Headers[clrs];
for (UINT ks=0; ks<128; ks++)
{
if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0;
}
}
memset(&Ins[n], 0, sizeof(Ins[0]));
break;
}
}
}
#endif // FASTSOUNDLIB
}
if (newsamples < n) newsamples = n;
samplemap[nmap] = n;
}
m_nSamples = newsamples;
// Reading Volume Envelope
INSTRUMENTHEADER *penv = Headers[iIns];
penv->nMidiProgram = pih->type;
penv->nFadeOut = xmsh.volfade;
penv->nPan = 128;
penv->nPPC = 5*12;
if (xmsh.vtype & 1) penv->dwFlags |= ENV_VOLUME;
if (xmsh.vtype & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
if (xmsh.vtype & 4) penv->dwFlags |= ENV_VOLLOOP;
if (xmsh.ptype & 1) penv->dwFlags |= ENV_PANNING;
if (xmsh.ptype & 2) penv->dwFlags |= ENV_PANSUSTAIN;
if (xmsh.ptype & 4) penv->dwFlags |= ENV_PANLOOP;
if (xmsh.vnum > 12) xmsh.vnum = 12;
if (xmsh.pnum > 12) xmsh.pnum = 12;
penv->nVolEnv = xmsh.vnum;
if (!xmsh.vnum) penv->dwFlags &= ~ENV_VOLUME;
if (!xmsh.pnum) penv->dwFlags &= ~ENV_PANNING;
penv->nPanEnv = xmsh.pnum;
penv->nVolSustainBegin = penv->nVolSustainEnd = xmsh.vsustain;
if (xmsh.vsustain >= 12) penv->dwFlags &= ~ENV_VOLSUSTAIN;
penv->nVolLoopStart = xmsh.vloops;
penv->nVolLoopEnd = xmsh.vloope;
if (penv->nVolLoopEnd >= 12) penv->nVolLoopEnd = 0;
if (penv->nVolLoopStart >= penv->nVolLoopEnd) penv->dwFlags &= ~ENV_VOLLOOP;
penv->nPanSustainBegin = penv->nPanSustainEnd = xmsh.psustain;
if (xmsh.psustain >= 12) penv->dwFlags &= ~ENV_PANSUSTAIN;
penv->nPanLoopStart = xmsh.ploops;
penv->nPanLoopEnd = xmsh.ploope;
if (penv->nPanLoopEnd >= 12) penv->nPanLoopEnd = 0;
if (penv->nPanLoopStart >= penv->nPanLoopEnd) penv->dwFlags &= ~ENV_PANLOOP;
penv->nGlobalVol = 64;
for (UINT ienv=0; ienv<12; ienv++)
{
penv->VolPoints[ienv] = (WORD)xmsh.venv[ienv*2];
penv->VolEnv[ienv] = (BYTE)xmsh.venv[ienv*2+1];
penv->PanPoints[ienv] = (WORD)xmsh.penv[ienv*2];
penv->PanEnv[ienv] = (BYTE)xmsh.penv[ienv*2+1];
if (ienv)
{
if (penv->VolPoints[ienv] < penv->VolPoints[ienv-1])
{
penv->VolPoints[ienv] &= 0xFF;
penv->VolPoints[ienv] += penv->VolPoints[ienv-1] & 0xFF00;
if (penv->VolPoints[ienv] < penv->VolPoints[ienv-1]) penv->VolPoints[ienv] += 0x100;
}
if (penv->PanPoints[ienv] < penv->PanPoints[ienv-1])
{
penv->PanPoints[ienv] &= 0xFF;
penv->PanPoints[ienv] += penv->PanPoints[ienv-1] & 0xFF00;
if (penv->PanPoints[ienv] < penv->PanPoints[ienv-1]) penv->PanPoints[ienv] += 0x100;
}
}
}
for (UINT j=0; j<96; j++)
{
penv->NoteMap[j+12] = j+1+12;
if (xmsh.snum[j] < nsamples)
penv->Keyboard[j+12] = samplemap[xmsh.snum[j]];
}
// Reading samples
for (UINT ins=0; ins<nsamples; ins++)
{
if ((dwMemPos + sizeof(xmss) > dwMemLength)
|| (dwMemPos + xmsh.shsize > dwMemLength)) return TRUE;
memcpy(&xmss, lpStream+dwMemPos, sizeof(xmss));
xmss.samplen = bswapLE32(xmss.samplen);
xmss.loopstart = bswapLE32(xmss.loopstart);
xmss.looplen = bswapLE32(xmss.looplen);
dwMemPos += xmsh.shsize;
flags[ins] = (xmss.type & 0x10) ? RS_PCM16D : RS_PCM8D;
if (xmss.type & 0x20) flags[ins] = (xmss.type & 0x10) ? RS_STPCM16D : RS_STPCM8D;
samplesize[ins] = xmss.samplen;
if (!samplemap[ins]) continue;
if (xmss.type & 0x10)
{
xmss.looplen >>= 1;
xmss.loopstart >>= 1;
xmss.samplen >>= 1;
}
if (xmss.type & 0x20)
{
xmss.looplen >>= 1;
xmss.loopstart >>= 1;
xmss.samplen >>= 1;
}
if (xmss.samplen > MAX_SAMPLE_LENGTH) xmss.samplen = MAX_SAMPLE_LENGTH;
if (xmss.loopstart >= xmss.samplen) xmss.type &= ~3;
xmss.looplen += xmss.loopstart;
if (xmss.looplen > xmss.samplen) xmss.looplen = xmss.samplen;
if (!xmss.looplen) xmss.type &= ~3;
UINT imapsmp = samplemap[ins];
memcpy(m_szNames[imapsmp], xmss.name, 22);
m_szNames[imapsmp][22] = 0;
MODINSTRUMENT *pins = &Ins[imapsmp];
pins->nLength = (xmss.samplen > MAX_SAMPLE_LENGTH) ? MAX_SAMPLE_LENGTH : xmss.samplen;
pins->nLoopStart = xmss.loopstart;
pins->nLoopEnd = xmss.looplen;
if (pins->nLoopEnd > pins->nLength) pins->nLoopEnd = pins->nLength;
if (pins->nLoopStart >= pins->nLoopEnd)
{
pins->nLoopStart = pins->nLoopEnd = 0;
}
if (xmss.type & 3) pins->uFlags |= CHN_LOOP;
if (xmss.type & 2) pins->uFlags |= CHN_PINGPONGLOOP;
pins->nVolume = xmss.vol << 2;
if (pins->nVolume > 256) pins->nVolume = 256;
pins->nGlobalVol = 64;
if ((xmss.res == 0xAD) && (!(xmss.type & 0x30)))
{
flags[ins] = RS_ADPCM4;
samplesize[ins] = (samplesize[ins]+1)/2 + 16;
}
pins->nFineTune = xmss.finetune;
pins->RelativeTone = (int)xmss.relnote;
pins->nPan = xmss.pan;
pins->uFlags |= CHN_PANNING;
pins->nVibType = xmsh.vibtype;
pins->nVibSweep = xmsh.vibsweep;
pins->nVibDepth = xmsh.vibdepth;
pins->nVibRate = xmsh.vibrate;
memcpy(pins->name, xmss.name, 22);
pins->name[21] = 0;
}
#if 0
if ((xmsh.reserved2 > nsamples) && (xmsh.reserved2 <= 16))
{
dwMemPos += (((UINT)xmsh.reserved2) - nsamples) * xmsh.shsize;
}
#endif
for (UINT ismpd=0; ismpd<nsamples; ismpd++)
{
if ((samplemap[ismpd]) && (samplesize[ismpd]) && (dwMemPos < dwMemLength))
{
ReadSample(&Ins[samplemap[ismpd]], flags[ismpd], (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
}
dwMemPos += samplesize[ismpd];
if (dwMemPos >= dwMemLength) break;
}
}
// Read song comments: "TEXT"
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x74786574))
{
UINT len = *((DWORD *)(lpStream+dwMemPos+4));
dwMemPos += 8;
if ((dwMemPos + len <= dwMemLength) && (len < 16384))
{
m_lpszSongComments = new char[len+1];
if (m_lpszSongComments)
{
memcpy(m_lpszSongComments, lpStream+dwMemPos, len);
m_lpszSongComments[len] = 0;
}
dwMemPos += len;
}
}
// Read midi config: "MIDI"
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4944494D))
{
UINT len = *((DWORD *)(lpStream+dwMemPos+4));
dwMemPos += 8;
if (len == sizeof(MODMIDICFG))
{
memcpy(&m_MidiCfg, lpStream+dwMemPos, len);
m_dwSongFlags |= SONG_EMBEDMIDICFG;
}
}
// Read pattern names: "PNAM"
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e50))
{
UINT len = *((DWORD *)(lpStream+dwMemPos+4));
dwMemPos += 8;
if ((dwMemPos + len <= dwMemLength) && (len <= MAX_PATTERNS*MAX_PATTERNNAME) && (len >= MAX_PATTERNNAME))
{
m_lpszPatternNames = new char[len];
if (m_lpszPatternNames)
{
m_nPatternNames = len / MAX_PATTERNNAME;
memcpy(m_lpszPatternNames, lpStream+dwMemPos, len);
}
dwMemPos += len;
}
}
// Read channel names: "CNAM"
if ((dwMemPos + 8 < dwMemLength) && (bswapLE32(*((DWORD *)(lpStream+dwMemPos))) == 0x4d414e43))
{
UINT len = *((DWORD *)(lpStream+dwMemPos+4));
dwMemPos += 8;
if ((dwMemPos + len <= dwMemLength) && (len <= MAX_BASECHANNELS*MAX_CHANNELNAME))
{
UINT n = len / MAX_CHANNELNAME;
for (UINT i=0; i<n; i++)
{
memcpy(ChnSettings[i].szName, (lpStream+dwMemPos+i*MAX_CHANNELNAME), MAX_CHANNELNAME);
ChnSettings[i].szName[MAX_CHANNELNAME-1] = 0;
}
dwMemPos += len;
}
}
// Read mix plugins information
if (dwMemPos + 8 < dwMemLength)
{
dwMemPos += LoadMixPlugins(lpStream+dwMemPos, dwMemLength-dwMemPos);
}
return TRUE;
}
#ifndef MODPLUG_NO_FILESAVE
BOOL CSoundFile::SaveXM(LPCSTR lpszFileName, UINT nPacking)
//---------------------------------------------------------
{
BYTE s[64*64*5];
XMFILEHEADER header;
XMINSTRUMENTHEADER xmih;
XMSAMPLEHEADER xmsh;
XMSAMPLESTRUCT xmss;
BYTE smptable[32];
BYTE xmph[9];
FILE *f;
int i;
if ((!m_nChannels) || (!lpszFileName)) return FALSE;
if ((f = fopen(lpszFileName, "wb")) == NULL) return FALSE;
fwrite("Extended Module: ", 17, 1, f);
fwrite(m_szNames[0], 20, 1, f);
s[0] = 0x1A;
lstrcpy((LPSTR)&s[1], (nPacking) ? "MOD Plugin packed " : "FastTracker v2.00 ");
s[21] = 0x04;
s[22] = 0x01;
fwrite(s, 23, 1, f);
// Writing song header
memset(&header, 0, sizeof(header));
header.size = sizeof(XMFILEHEADER);
header.norder = 0;
header.restartpos = m_nRestartPos;
header.channels = m_nChannels;
header.patterns = 0;
for (i=0; i<MAX_ORDERS; i++)
{
if (Order[i] == 0xFF) break;
header.norder++;
if ((Order[i] >= header.patterns) && (Order[i] < MAX_PATTERNS)) header.patterns = Order[i]+1;
}
header.instruments = m_nInstruments;
if (!header.instruments) header.instruments = m_nSamples;
header.flags = (m_dwSongFlags & SONG_LINEARSLIDES) ? 0x01 : 0x00;
if (m_dwSongFlags & SONG_EXFILTERRANGE) header.flags |= 0x1000;
header.tempo = m_nDefaultTempo;
header.speed = m_nDefaultSpeed;
memcpy(header.order, Order, header.norder);
fwrite(&header, 1, sizeof(header), f);
// Writing patterns
for (i=0; i<header.patterns; i++) if (Patterns[i])
{
MODCOMMAND *p = Patterns[i];
UINT len = 0;
memset(&xmph, 0, sizeof(xmph));
xmph[0] = 9;
xmph[5] = (BYTE)(PatternSize[i] & 0xFF);
xmph[6] = (BYTE)(PatternSize[i] >> 8);
for (UINT j=m_nChannels*PatternSize[i]; j; j--,p++)
{
UINT note = p->note;
UINT param = ModSaveCommand(p, TRUE);
UINT command = param >> 8;
param &= 0xFF;
if (note >= 0xFE) note = 97; else
if ((note <= 12) || (note > 96+12)) note = 0; else
note -= 12;
UINT vol = 0;
if (p->volcmd)
{
UINT volcmd = p->volcmd;
switch(volcmd)
{
case VOLCMD_VOLUME: vol = 0x10 + p->vol; break;
case VOLCMD_VOLSLIDEDOWN: vol = 0x60 + (p->vol & 0x0F); break;
case VOLCMD_VOLSLIDEUP: vol = 0x70 + (p->vol & 0x0F); break;
case VOLCMD_FINEVOLDOWN: vol = 0x80 + (p->vol & 0x0F); break;
case VOLCMD_FINEVOLUP: vol = 0x90 + (p->vol & 0x0F); break;
case VOLCMD_VIBRATOSPEED: vol = 0xA0 + (p->vol & 0x0F); break;
case VOLCMD_VIBRATO: vol = 0xB0 + (p->vol & 0x0F); break;
case VOLCMD_PANNING: vol = 0xC0 + (p->vol >> 2); if (vol > 0xCF) vol = 0xCF; break;
case VOLCMD_PANSLIDELEFT: vol = 0xD0 + (p->vol & 0x0F); break;
case VOLCMD_PANSLIDERIGHT: vol = 0xE0 + (p->vol & 0x0F); break;
case VOLCMD_TONEPORTAMENTO: vol = 0xF0 + (p->vol & 0x0F); break;
}
}
if ((note) && (p->instr) && (vol > 0x0F) && (command) && (param))
{
s[len++] = note;
s[len++] = p->instr;
s[len++] = vol;
s[len++] = command;
s[len++] = param;
} else
{
BYTE b = 0x80;
if (note) b |= 0x01;
if (p->instr) b |= 0x02;
if (vol >= 0x10) b |= 0x04;
if (command) b |= 0x08;
if (param) b |= 0x10;
s[len++] = b;
if (b & 1) s[len++] = note;
if (b & 2) s[len++] = p->instr;
if (b & 4) s[len++] = vol;
if (b & 8) s[len++] = command;
if (b & 16) s[len++] = param;
}
if (len > sizeof(s) - 5) break;
}
xmph[7] = (BYTE)(len & 0xFF);
xmph[8] = (BYTE)(len >> 8);
fwrite(xmph, 1, 9, f);
fwrite(s, 1, len, f);
} else
{
memset(&xmph, 0, sizeof(xmph));
xmph[0] = 9;
xmph[5] = (BYTE)(PatternSize[i] & 0xFF);
xmph[6] = (BYTE)(PatternSize[i] >> 8);
fwrite(xmph, 1, 9, f);
}
// Writing instruments
for (i=1; i<=header.instruments; i++)
{
MODINSTRUMENT *pins;
BYTE flags[32];
memset(&xmih, 0, sizeof(xmih));
memset(&xmsh, 0, sizeof(xmsh));
xmih.size = sizeof(xmih) + sizeof(xmsh);
memcpy(xmih.name, m_szNames[i], 22);
xmih.type = 0;
xmih.samples = 0;
if (m_nInstruments)
{
INSTRUMENTHEADER *penv = Headers[i];
if (penv)
{
memcpy(xmih.name, penv->name, 22);
xmih.type = penv->nMidiProgram;
xmsh.volfade = penv->nFadeOut;
xmsh.vnum = (BYTE)penv->nVolEnv;
xmsh.pnum = (BYTE)penv->nPanEnv;
if (xmsh.vnum > 12) xmsh.vnum = 12;
if (xmsh.pnum > 12) xmsh.pnum = 12;
for (UINT ienv=0; ienv<12; ienv++)
{
xmsh.venv[ienv*2] = penv->VolPoints[ienv];
xmsh.venv[ienv*2+1] = penv->VolEnv[ienv];
xmsh.penv[ienv*2] = penv->PanPoints[ienv];
xmsh.penv[ienv*2+1] = penv->PanEnv[ienv];
}
if (penv->dwFlags & ENV_VOLUME) xmsh.vtype |= 1;
if (penv->dwFlags & ENV_VOLSUSTAIN) xmsh.vtype |= 2;
if (penv->dwFlags & ENV_VOLLOOP) xmsh.vtype |= 4;
if (penv->dwFlags & ENV_PANNING) xmsh.ptype |= 1;
if (penv->dwFlags & ENV_PANSUSTAIN) xmsh.ptype |= 2;
if (penv->dwFlags & ENV_PANLOOP) xmsh.ptype |= 4;
xmsh.vsustain = (BYTE)penv->nVolSustainBegin;
xmsh.vloops = (BYTE)penv->nVolLoopStart;
xmsh.vloope = (BYTE)penv->nVolLoopEnd;
xmsh.psustain = (BYTE)penv->nPanSustainBegin;
xmsh.ploops = (BYTE)penv->nPanLoopStart;
xmsh.ploope = (BYTE)penv->nPanLoopEnd;
for (UINT j=0; j<96; j++) if (penv->Keyboard[j+12])
{
UINT k;
for (k=0; k<xmih.samples; k++) if (smptable[k] == penv->Keyboard[j+12]) break;
if (k == xmih.samples)
{
smptable[xmih.samples++] = penv->Keyboard[j+12];
}
if (xmih.samples >= 32) break;
xmsh.snum[j] = k;
}
// xmsh.reserved2 = xmih.samples;
}
} else
{
xmih.samples = 1;
// xmsh.reserved2 = 1;
smptable[0] = i;
}
xmsh.shsize = (xmih.samples) ? 40 : 0;
fwrite(&xmih, 1, sizeof(xmih), f);
if (smptable[0])
{
MODINSTRUMENT *pvib = &Ins[smptable[0]];
xmsh.vibtype = pvib->nVibType;
xmsh.vibsweep = pvib->nVibSweep;
xmsh.vibdepth = pvib->nVibDepth;
xmsh.vibrate = pvib->nVibRate;
}
fwrite(&xmsh, 1, xmih.size - sizeof(xmih), f);
if (!xmih.samples) continue;
for (UINT ins=0; ins<xmih.samples; ins++)
{
memset(&xmss, 0, sizeof(xmss));
if (smptable[ins]) memcpy(xmss.name, m_szNames[smptable[ins]], 22);
pins = &Ins[smptable[ins]];
xmss.samplen = pins->nLength;
xmss.loopstart = pins->nLoopStart;
xmss.looplen = pins->nLoopEnd - pins->nLoopStart;
xmss.vol = pins->nVolume / 4;
xmss.finetune = (char)pins->nFineTune;
xmss.type = 0;
if (pins->uFlags & CHN_LOOP) xmss.type = (pins->uFlags & CHN_PINGPONGLOOP) ? 2 : 1;
flags[ins] = RS_PCM8D;
#ifndef NO_PACKING
if (nPacking)
{
if ((!(pins->uFlags & (CHN_16BIT|CHN_STEREO)))
&& (CanPackSample(pins->pSample, pins->nLength, nPacking)))
{
flags[ins] = RS_ADPCM4;
xmss.res = 0xAD;
}
} else
#endif
{
if (pins->uFlags & CHN_16BIT)
{
flags[ins] = RS_PCM16D;
xmss.type |= 0x10;
xmss.looplen *= 2;
xmss.loopstart *= 2;
xmss.samplen *= 2;
}
if (pins->uFlags & CHN_STEREO)
{
flags[ins] = (pins->uFlags & CHN_16BIT) ? RS_STPCM16D : RS_STPCM8D;
xmss.type |= 0x20;
xmss.looplen *= 2;
xmss.loopstart *= 2;
xmss.samplen *= 2;
}
}
xmss.pan = 255;
if (pins->nPan < 256) xmss.pan = (BYTE)pins->nPan;
xmss.relnote = (signed char)pins->RelativeTone;
fwrite(&xmss, 1, xmsh.shsize, f);
}
for (UINT ismpd=0; ismpd<xmih.samples; ismpd++)
{
pins = &Ins[smptable[ismpd]];
if (pins->pSample)
{
#ifndef NO_PACKING
if ((flags[ismpd] == RS_ADPCM4) && (xmih.samples>1)) CanPackSample(pins->pSample, pins->nLength, nPacking);
#endif // NO_PACKING
WriteSample(f, pins, flags[ismpd]);
}
}
}
// Writing song comments
if ((m_lpszSongComments) && (m_lpszSongComments[0]))
{
DWORD d = 0x74786574;
fwrite(&d, 1, 4, f);
d = strlen(m_lpszSongComments);
fwrite(&d, 1, 4, f);
fwrite(m_lpszSongComments, 1, d, f);
}
// Writing midi cfg
if (m_dwSongFlags & SONG_EMBEDMIDICFG)
{
DWORD d = 0x4944494D;
fwrite(&d, 1, 4, f);
d = sizeof(MODMIDICFG);
fwrite(&d, 1, 4, f);
fwrite(&m_MidiCfg, 1, sizeof(MODMIDICFG), f);
}
// Writing Pattern Names
if ((m_nPatternNames) && (m_lpszPatternNames))
{
DWORD dwLen = m_nPatternNames * MAX_PATTERNNAME;
while ((dwLen >= MAX_PATTERNNAME) && (!m_lpszPatternNames[dwLen-MAX_PATTERNNAME])) dwLen -= MAX_PATTERNNAME;
if (dwLen >= MAX_PATTERNNAME)
{
DWORD d = 0x4d414e50;
fwrite(&d, 1, 4, f);
fwrite(&dwLen, 1, 4, f);
fwrite(m_lpszPatternNames, 1, dwLen, f);
}
}
// Writing Channel Names
{
UINT nChnNames = 0;
for (UINT inam=0; inam<m_nChannels; inam++)
{
if (ChnSettings[inam].szName[0]) nChnNames = inam+1;
}
// Do it!
if (nChnNames)
{
DWORD dwLen = nChnNames * MAX_CHANNELNAME;
DWORD d = 0x4d414e43;
fwrite(&d, 1, 4, f);
fwrite(&dwLen, 1, 4, f);
for (UINT inam=0; inam<nChnNames; inam++)
{
fwrite(ChnSettings[inam].szName, 1, MAX_CHANNELNAME, f);
}
}
}
// Save mix plugins information
SaveMixPlugins(f);
fclose(f);
return TRUE;
}
#endif // MODPLUG_NO_FILESAVE
Reference in a new issue View git blame Copy permalink