mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-28 19:20:35 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/modplug/libmodplug/load_psm.cpp

840 lines
28 KiB
C++
Raw Normal View History

adding modplug Original commit message from CVS: adding modplug
2002-02-28 21:10:42 +00:00
/*
* This source code is public domain.
*
* Authors: Olivier Lapicque <olivierl@jps.net>
*/
///////////////////////////////////////////////////
//
// PSM module loader
//
///////////////////////////////////////////////////
#include "stdafx.h"
#include "sndfile.h"
//#define PSM_LOG
#define PSM_ID_NEW 0x204d5350
#define PSM_ID_OLD 0xfe4d5350
#define IFFID_FILE 0x454c4946
#define IFFID_TITL 0x4c544954
#define IFFID_SDFT 0x54464453
#define IFFID_PBOD 0x444f4250
#define IFFID_SONG 0x474e4f53
#define IFFID_PATT 0x54544150
#define IFFID_DSMP 0x504d5344
#define IFFID_OPLH 0x484c504f
#pragma pack(1)
typedef struct _PSMCHUNK
{
DWORD id;
DWORD len;
DWORD listid;
} PSMCHUNK;
typedef struct _PSMSONGHDR
{
CHAR songname[8]; // "MAINSONG"
BYTE reserved1;
BYTE reserved2;
BYTE channels;
} PSMSONGHDR;
typedef struct _PSMPATTERN
{
DWORD size;
DWORD name;
WORD rows;
WORD reserved1;
BYTE data[4];
} PSMPATTERN;
typedef struct _PSMSAMPLE
{
BYTE flags;
CHAR songname[8];
DWORD smpid;
CHAR samplename[34];
DWORD reserved1;
BYTE reserved2;
BYTE insno;
BYTE reserved3;
DWORD length;
DWORD loopstart;
DWORD loopend;
WORD reserved4;
BYTE defvol;
DWORD reserved5;
DWORD samplerate;
BYTE reserved6[19];
} PSMSAMPLE;
#pragma pack()
BOOL CSoundFile::ReadPSM(LPCBYTE lpStream, DWORD dwMemLength)
//-----------------------------------------------------------
{
PSMCHUNK *pfh = (PSMCHUNK *)lpStream;
DWORD dwMemPos, dwSongPos;
DWORD smpnames[MAX_SAMPLES];
DWORD patptrs[MAX_PATTERNS];
BYTE samplemap[MAX_SAMPLES];
UINT nPatterns;
// Chunk0: "PSM ",filesize,"FILE"
if (dwMemLength < 256) return FALSE;
if (pfh->id == PSM_ID_OLD)
{
#ifdef PSM_LOG
Log("Old PSM format not supported\n");
#endif
return FALSE;
}
if ((pfh->id != PSM_ID_NEW) || (pfh->len+12 > dwMemLength) || (pfh->listid != IFFID_FILE)) return FALSE;
m_nType = MOD_TYPE_PSM;
m_nChannels = 16;
m_nSamples = 0;
nPatterns = 0;
dwMemPos = 12;
dwSongPos = 0;
for (UINT iChPan=0; iChPan<16; iChPan++)
{
UINT pan = (((iChPan & 3) == 1) || ((iChPan&3)==2)) ? 0xC0 : 0x40;
ChnSettings[iChPan].nPan = pan;
}
while (dwMemPos+8 < dwMemLength)
{
PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
if ((pchunk->len >= dwMemLength - 8) || (dwMemPos + pchunk->len + 8 > dwMemLength)) break;
dwMemPos += 8;
PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
ULONG len = pchunk->len;
if (len) switch(pchunk->id)
{
// "TITL": Song title
case IFFID_TITL:
if (!pdata[0]) { pdata++; len--; }
memcpy(m_szNames[0], pdata, (len>31) ? 31 : len);
m_szNames[0][31] = 0;
break;
// "PBOD": Pattern
case IFFID_PBOD:
if ((len >= 12) && (nPatterns < MAX_PATTERNS))
{
patptrs[nPatterns++] = dwMemPos-8;
}
break;
// "SONG": Song description
case IFFID_SONG:
if ((len >= sizeof(PSMSONGHDR)+8) && (!dwSongPos))
{
dwSongPos = dwMemPos - 8;
}
break;
// "DSMP": Sample Data
case IFFID_DSMP:
if ((len >= sizeof(PSMSAMPLE)) && (m_nSamples+1 < MAX_SAMPLES))
{
m_nSamples++;
MODINSTRUMENT *pins = &Ins[m_nSamples];
PSMSAMPLE *psmp = (PSMSAMPLE *)pdata;
smpnames[m_nSamples] = psmp->smpid;
memcpy(m_szNames[m_nSamples], psmp->samplename, 31);
m_szNames[m_nSamples][31] = 0;
samplemap[m_nSamples-1] = (BYTE)m_nSamples;
// Init sample
pins->nGlobalVol = 0x40;
pins->nC4Speed = psmp->samplerate;
pins->nLength = psmp->length;
pins->nLoopStart = psmp->loopstart;
pins->nLoopEnd = psmp->loopend;
pins->nPan = 128;
pins->nVolume = (psmp->defvol+1) * 2;
pins->uFlags = (psmp->flags & 0x80) ? CHN_LOOP : 0;
if (pins->nLoopStart > 0) pins->nLoopStart--;
// Point to sample data
pdata += 0x60;
len -= 0x60;
// Load sample data
if ((pins->nLength > 3) && (len > 3))
{
ReadSample(pins, RS_PCM8D, (LPCSTR)pdata, len);
} else
{
pins->nLength = 0;
}
}
break;
#if 0
default:
{
CHAR s[8], s2[64];
*(DWORD *)s = pchunk->id;
s[4] = 0;
wsprintf(s2, "%s: %4d bytes @ %4d\n", s, pchunk->len, dwMemPos);
OutputDebugString(s2);
}
#endif
}
dwMemPos += pchunk->len;
}
// Step #1: convert song structure
PSMSONGHDR *pSong = (PSMSONGHDR *)(lpStream+dwSongPos+8);
if ((!dwSongPos) || (pSong->channels < 2) || (pSong->channels > 32)) return TRUE;
m_nChannels = pSong->channels;
// Valid song header -> convert attached chunks
{
DWORD dwSongEnd = dwSongPos + 8 + *(DWORD *)(lpStream+dwSongPos+4);
dwMemPos = dwSongPos + 8 + 11; // sizeof(PSMCHUNK)+sizeof(PSMSONGHDR)
while (dwMemPos + 8 < dwSongEnd)
{
PSMCHUNK *pchunk = (PSMCHUNK *)(lpStream+dwMemPos);
dwMemPos += 8;
if ((pchunk->len > dwSongEnd) || (dwMemPos + pchunk->len > dwSongEnd)) break;
PUCHAR pdata = (PUCHAR)(lpStream+dwMemPos);
ULONG len = pchunk->len;
switch(pchunk->id)
{
case IFFID_OPLH:
if (len >= 0x20)
{
UINT pos = len - 3;
while (pos > 5)
{
BOOL bFound = FALSE;
pos -= 5;
DWORD dwName = *(DWORD *)(pdata+pos);
for (UINT i=0; i<nPatterns; i++)
{
DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
if (dwName == dwPatName)
{
bFound = TRUE;
break;
}
}
if ((!bFound) && (pdata[pos+1] > 0) && (pdata[pos+1] <= 0x10)
&& (pdata[pos+3] > 0x40) && (pdata[pos+3] < 0xC0))
{
m_nDefaultSpeed = pdata[pos+1];
m_nDefaultTempo = pdata[pos+3];
break;
}
}
UINT iOrd = 0;
while ((pos+5<len) && (iOrd < MAX_ORDERS))
{
DWORD dwName = *(DWORD *)(pdata+pos);
for (UINT i=0; i<nPatterns; i++)
{
DWORD dwPatName = ((PSMPATTERN *)(lpStream+patptrs[i]+8))->name;
if (dwName == dwPatName)
{
Order[iOrd++] = i;
break;
}
}
pos += 5;
}
}
break;
}
dwMemPos += pchunk->len;
}
}
// Step #2: convert patterns
for (UINT nPat=0; nPat<nPatterns; nPat++)
{
PSMPATTERN *pPsmPat = (PSMPATTERN *)(lpStream+patptrs[nPat]+8);
ULONG len = *(DWORD *)(lpStream+patptrs[nPat]+4) - 12;
UINT nRows = pPsmPat->rows;
if (len > pPsmPat->size) len = pPsmPat->size;
if ((nRows < 64) || (nRows > 256)) nRows = 64;
PatternSize[nPat] = nRows;
if ((Patterns[nPat] = AllocatePattern(nRows, m_nChannels)) == NULL) break;
MODCOMMAND *m = Patterns[nPat];
BYTE *p = pPsmPat->data;
UINT pos = 0;
UINT row = 0;
UINT oldch = 0;
BOOL bNewRow = FALSE;
#ifdef PSM_LOG
Log("Pattern %d at offset 0x%04X\n", nPat, (DWORD)(p - (BYTE *)lpStream));
#endif
while ((row < nRows) && (pos+1 < len))
{
UINT flags = p[pos++];
UINT ch = p[pos++];
#ifdef PSM_LOG
//Log("flags+ch: %02X.%02X\n", flags, ch);
#endif
if (((flags & 0xf0) == 0x10) && (ch <= oldch) /*&& (!bNewRow)*/)
{
if ((pos+1<len) && (!(p[pos] & 0x0f)) && (p[pos+1] < m_nChannels))
{
#ifdef PSM_LOG
//if (!nPat) Log("Continuing on new row\n");
#endif
row++;
m += m_nChannels;
oldch = ch;
continue;
}
}
if ((pos >= len) || (row >= nRows)) break;
if (!(flags & 0xf0))
{
#ifdef PSM_LOG
//if (!nPat) Log("EOR(%d): %02X.%02X\n", row, p[pos], p[pos+1]);
#endif
row++;
m += m_nChannels;
bNewRow = TRUE;
oldch = ch;
continue;
}
bNewRow = FALSE;
if (ch >= m_nChannels)
{
#ifdef PSM_LOG
if (!nPat) Log("Invalid channel row=%d (0x%02X.0x%02X)\n", row, flags, ch);
#endif
ch = 0;
}
// Note + Instr
if ((flags & 0x40) && (pos+1 < len))
{
UINT note = p[pos++];
UINT nins = p[pos++];
#ifdef PSM_LOG
//if (!nPat) Log("note+ins: %02X.%02X\n", note, nins);
if ((!nPat) && (nins >= m_nSamples)) Log("WARNING: invalid instrument number (%d)\n", nins);
#endif
if ((note) && (note < 0x80)) note = (note>>4)*12+(note&0x0f)+12+1;
m[ch].instr = samplemap[nins];
m[ch].note = note;
}
// Volume
if ((flags & 0x20) && (pos < len))
{
m[ch].volcmd = VOLCMD_VOLUME;
m[ch].vol = p[pos++] / 2;
}
// Effect
if ((flags & 0x10) && (pos+1 < len))
{
UINT command = p[pos++];
UINT param = p[pos++];
// Convert effects
switch(command)
{
// 01: fine volslide up
case 0x01: command = CMD_VOLUMESLIDE; param |= 0x0f; break;
// 04: fine volslide down
case 0x04: command = CMD_VOLUMESLIDE; param>>=4; param |= 0xf0; break;
// 0C: portamento up
case 0x0C: command = CMD_PORTAMENTOUP; param = (param+1)/2; break;
// 0E: portamento down
case 0x0E: command = CMD_PORTAMENTODOWN; param = (param+1)/2; break;
// 33: Position Jump
case 0x33: command = CMD_POSITIONJUMP; break;
// 34: Pattern break
case 0x34: command = CMD_PATTERNBREAK; break;
// 3D: speed
case 0x3D: command = CMD_SPEED; break;
// 3E: tempo
case 0x3E: command = CMD_TEMPO; break;
// Unknown
default:
#ifdef PSM_LOG
Log("Unknown PSM effect pat=%d row=%d ch=%d: %02X.%02X\n", nPat, row, ch, command, param);
#endif
command = param = 0;
}
m[ch].command = (BYTE)command;
m[ch].param = (BYTE)param;
}
oldch = ch;
}
#ifdef PSM_LOG
if (pos < len)
{
Log("Pattern %d: %d/%d[%d] rows (%d bytes) -> %d bytes left\n", nPat, row, nRows, pPsmPat->rows, pPsmPat->size, len-pos);
}
#endif
}
// Done (finally!)
return TRUE;
}
//////////////////////////////////////////////////////////////
//
// PSM Old Format
//
/*
CONST
c_PSM_MaxOrder = $FF;
c_PSM_MaxSample = $FF;
c_PSM_MaxChannel = $0F;
TYPE
PPSM_Header = ^TPSM_Header;
TPSM_Header = RECORD
PSM_Sign : ARRAY[01..04] OF CHAR; { PSM + #254 }
PSM_SongName : ARRAY[01..58] OF CHAR;
PSM_Byte00 : BYTE;
PSM_Byte1A : BYTE;
PSM_Unknown00 : BYTE;
PSM_Unknown01 : BYTE;
PSM_Unknown02 : BYTE;
PSM_Speed : BYTE;
PSM_Tempo : BYTE;
PSM_Unknown03 : BYTE;
PSM_Unknown04 : WORD;
PSM_OrderLength : WORD;
PSM_PatternNumber : WORD;
PSM_SampleNumber : WORD;
PSM_ChannelNumber : WORD;
PSM_ChannelUsed : WORD;
PSM_OrderPosition : LONGINT;
PSM_ChannelSettingPosition : LONGINT;
PSM_PatternPosition : LONGINT;
PSM_SamplePosition : LONGINT;
{ *** perhaps there are some more infos in a larger header,
but i have not decoded it and so it apears here NOT }
END;
PPSM_Sample = ^TPSM_Sample;
TPSM_Sample = RECORD
PSM_SampleFileName : ARRAY[01..12] OF CHAR;
PSM_SampleByte00 : BYTE;
PSM_SampleName : ARRAY[01..22] OF CHAR;
PSM_SampleUnknown00 : ARRAY[01..02] OF BYTE;
PSM_SamplePosition : LONGINT;
PSM_SampleUnknown01 : ARRAY[01..04] OF BYTE;
PSM_SampleNumber : BYTE;
PSM_SampleFlags : WORD;
PSM_SampleLength : LONGINT;
PSM_SampleLoopBegin : LONGINT;
PSM_SampleLoopEnd : LONGINT;
PSM_Unknown03 : BYTE;
PSM_SampleVolume : BYTE;
PSM_SampleC5Speed : WORD;
END;
PPSM_SampleList = ^TPSM_SampleList;
TPSM_SampleList = ARRAY[01..c_PSM_MaxSample] OF TPSM_Sample;
PPSM_Order = ^TPSM_Order;
TPSM_Order = ARRAY[00..c_PSM_MaxOrder] OF BYTE;
PPSM_ChannelSettings = ^TPSM_ChannelSettings;
TPSM_ChannelSettings = ARRAY[00..c_PSM_MaxChannel] OF BYTE;
CONST
PSM_NotesInPattern : BYTE = $00;
PSM_ChannelInPattern : BYTE = $00;
CONST
c_PSM_SetSpeed = 60;
FUNCTION PSM_Size(FileName : STRING;FilePosition : LONGINT) : LONGINT;
BEGIN
END;
PROCEDURE PSM_UnpackPattern(VAR Source,Destination;PatternLength : WORD);
VAR
Witz : ARRAY[00..04] OF WORD;
I1,I2 : WORD;
I3,I4 : WORD;
TopicalByte : ^BYTE;
Pattern : PUnpackedPattern;
ChannelP : BYTE;
NoteP : BYTE;
InfoByte : BYTE;
CodeByte : BYTE;
InfoWord : WORD;
Effect : BYTE;
Opperand : BYTE;
Panning : BYTE;
Volume : BYTE;
PrevInfo : BYTE;
InfoIndex : BYTE;
BEGIN
Pattern := @Destination;
TopicalByte := @Source;
{ *** Initialize patttern }
FOR I2 := 0 TO c_Maximum_NoteIndex DO
FOR I3 := 0 TO c_Maximum_ChannelIndex DO
BEGIN
Pattern^[I2,I3,c_Pattern_NoteIndex] := $FF;
Pattern^[I2,I3,c_Pattern_SampleIndex] := $00;
Pattern^[I2,I3,c_Pattern_VolumeIndex] := $FF;
Pattern^[I2,I3,c_Pattern_PanningIndex] := $FF;
Pattern^[I2,I3,c_Pattern_EffectIndex] := $00;
Pattern^[I2,I3,c_Pattern_OpperandIndex] := $00;
END;
{ *** Byte-pointer on first pattern-entry }
ChannelP := $00;
NoteP := $00;
InfoByte := $00;
PrevInfo := $00;
InfoIndex := $02;
{ *** read notes in pattern }
PSM_NotesInPattern := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
PSM_ChannelInPattern := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
{ *** unpack pattern }
WHILE (INTEGER(PatternLength) > 0) AND (NoteP < c_Maximum_NoteIndex) DO
BEGIN
{ *** Read info-byte }
InfoByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength); INC(InfoIndex);
IF InfoByte <> $00 THEN
BEGIN
ChannelP := InfoByte AND $0F;
IF InfoByte AND 128 = 128 THEN { note and sample }
BEGIN
{ *** read note }
CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
DEC(CodeByte);
CodeByte := CodeByte MOD 12 * 16 + CodeByte DIV 12 + 2;
Pattern^[NoteP,ChannelP,c_Pattern_NoteIndex] := CodeByte;
{ *** read sample }
CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
Pattern^[NoteP,ChannelP,c_Pattern_SampleIndex] := CodeByte;
END;
IF InfoByte AND 64 = 64 THEN { Volume }
BEGIN
CodeByte := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
Pattern^[NoteP,ChannelP,c_Pattern_VolumeIndex] := CodeByte;
END;
IF InfoByte AND 32 = 32 THEN { effect AND opperand }
BEGIN
Effect := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
Opperand := TopicalByte^; INC(TopicalByte); DEC(PatternLength);
CASE Effect OF
c_PSM_SetSpeed:
BEGIN
Effect := c_I_Set_Speed;
END;
ELSE
BEGIN
Effect := c_I_NoEffect;
Opperand := $00;
END;
END;
Pattern^[NoteP,ChannelP,c_Pattern_EffectIndex] := Effect;
Pattern^[NoteP,ChannelP,c_Pattern_OpperandIndex] := Opperand;
END;
END ELSE INC(NoteP);
END;
END;
PROCEDURE PSM_Load(FileName : STRING;FilePosition : LONGINT;VAR Module : PModule;VAR ErrorCode : WORD);
{ *** caution : Module has to be inited before!!!! }
VAR
Header : PPSM_Header;
Sample : PPSM_SampleList;
Order : PPSM_Order;
ChannelSettings : PPSM_ChannelSettings;
MultiPurposeBuffer : PByteArray;
PatternBuffer : PUnpackedPattern;
TopicalParaPointer : WORD;
InFile : FILE;
I1,I2 : WORD;
I3,I4 : WORD;
TempW : WORD;
TempB : BYTE;
TempP : PByteArray;
TempI : INTEGER;
{ *** copy-vars for loop-extension }
CopySource : LONGINT;
CopyDestination : LONGINT;
CopyLength : LONGINT;
BEGIN
{ *** try to open file }
ASSIGN(InFile,FileName);
{$I-}
RESET(InFile,1);
{$I+}
IF IORESULT <> $00 THEN
BEGIN
EXIT;
END;
{$I-}
{ *** seek start of module }
IF FILESIZE(InFile) < FilePosition THEN
BEGIN
EXIT;
END;
SEEK(InFile,FilePosition);
{ *** look for enough memory for temporary variables }
IF MEMAVAIL < SIZEOF(TPSM_Header) + SIZEOF(TPSM_SampleList) +
SIZEOF(TPSM_Order) + SIZEOF(TPSM_ChannelSettings) +
SIZEOF(TByteArray) + SIZEOF(TUnpackedPattern)
THEN
BEGIN
EXIT;
END;
{ *** init dynamic variables }
NEW(Header);
NEW(Sample);
NEW(Order);
NEW(ChannelSettings);
NEW(MultiPurposeBuffer);
NEW(PatternBuffer);
{ *** read header }
BLOCKREAD(InFile,Header^,SIZEOF(TPSM_Header));
{ *** test if this is a DSM-file }
IF NOT ((Header^.PSM_Sign[1] = 'P') AND (Header^.PSM_Sign[2] = 'S') AND
(Header^.PSM_Sign[3] = 'M') AND (Header^.PSM_Sign[4] = #254)) THEN
BEGIN
ErrorCode := c_NoValidFileFormat;
CLOSE(InFile);
EXIT;
END;
{ *** read order }
SEEK(InFile,FilePosition + Header^.PSM_OrderPosition);
BLOCKREAD(InFile,Order^,Header^.PSM_OrderLength);
{ *** read channelsettings }
SEEK(InFile,FilePosition + Header^.PSM_ChannelSettingPosition);
BLOCKREAD(InFile,ChannelSettings^,SIZEOF(TPSM_ChannelSettings));
{ *** read samplelist }
SEEK(InFile,FilePosition + Header^.PSM_SamplePosition);
BLOCKREAD(InFile,Sample^,Header^.PSM_SampleNumber * SIZEOF(TPSM_Sample));
{ *** copy header to intern NTMIK-structure }
Module^.Module_Sign := 'MF';
Module^.Module_FileFormatVersion := $0100;
Module^.Module_SampleNumber := Header^.PSM_SampleNumber;
Module^.Module_PatternNumber := Header^.PSM_PatternNumber;
Module^.Module_OrderLength := Header^.PSM_OrderLength;
Module^.Module_ChannelNumber := Header^.PSM_ChannelNumber+1;
Module^.Module_Initial_GlobalVolume := 64;
Module^.Module_Initial_MasterVolume := $C0;
Module^.Module_Initial_Speed := Header^.PSM_Speed;
Module^.Module_Initial_Tempo := Header^.PSM_Tempo;
{ *** paragraph 01 start }
Module^.Module_Flags := c_Module_Flags_ZeroVolume * BYTE(1) +
c_Module_Flags_Stereo * BYTE(1) +
c_Module_Flags_ForceAmigaLimits * BYTE(0) +
c_Module_Flags_Panning * BYTE(1) +
c_Module_Flags_Surround * BYTE(1) +
c_Module_Flags_QualityMixing * BYTE(1) +
c_Module_Flags_FastVolumeSlides * BYTE(0) +
c_Module_Flags_SpecialCustomData * BYTE(0) +
c_Module_Flags_SongName * BYTE(1);
I1 := $01;
WHILE (Header^.PSM_SongName[I1] > #00) AND (I1 < c_Module_SongNameLength) DO
BEGIN
Module^.Module_Name[I1] := Header^.PSM_SongName[I1];
INC(I1);
END;
Module^.Module_Name[c_Module_SongNameLength] := #00;
{ *** Init channelsettings }
FOR I1 := 0 TO c_Maximum_ChannelIndex DO
BEGIN
IF I1 < Header^.PSM_ChannelUsed THEN
BEGIN
{ *** channel enabled }
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_GlobalVolume := 64;
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Panning := (ChannelSettings^[I1]) * $08;
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Code := I1 + $10 * BYTE(ChannelSettings^[I1] > $08) +
c_ChannelSettings_Code_ChannelEnabled * BYTE(1) +
c_ChannelSettings_Code_ChannelDigital * BYTE(1);
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Controls :=
c_ChannelSettings_Controls_EnhancedMode * BYTE(1) +
c_ChannelSettings_Controls_SurroundMode * BYTE(0);
END
ELSE
BEGIN
{ *** channel disabled }
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_GlobalVolume := $00;
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Panning := $00;
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Code := $00;
Module^.Module_ChannelSettingPointer^[I1].ChannelSettings_Controls := $00;
END;
END;
{ *** init and copy order }
FILLCHAR(Module^.Module_OrderPointer^,c_Maximum_OrderIndex+1,$FF);
MOVE(Order^,Module^.Module_OrderPointer^,Header^.PSM_OrderLength);
{ *** read pattern }
SEEK(InFile,FilePosition + Header^.PSM_PatternPosition);
NTMIK_LoaderPatternNumber := Header^.PSM_PatternNumber-1;
FOR I1 := 0 TO Header^.PSM_PatternNumber-1 DO
BEGIN
NTMIK_LoadPatternProcedure;
{ *** read length }
BLOCKREAD(InFile,TempW,2);
{ *** read pattern }
BLOCKREAD(InFile,MultiPurposeBuffer^,TempW-2);
{ *** unpack pattern and set notes per channel to 64 }
PSM_UnpackPattern(MultiPurposeBuffer^,PatternBuffer^,TempW);
NTMIK_PackPattern(MultiPurposeBuffer^,PatternBuffer^,PSM_NotesInPattern);
TempW := WORD(256) * MultiPurposeBuffer^[01] + MultiPurposeBuffer^[00];
GETMEM(Module^.Module_PatternPointer^[I1],TempW);
MOVE(MultiPurposeBuffer^,Module^.Module_PatternPointer^[I1]^,TempW);
{ *** next pattern }
END;
{ *** read samples }
NTMIK_LoaderSampleNumber := Header^.PSM_SampleNumber;
FOR I1 := 1 TO Header^.PSM_SampleNumber DO
BEGIN
NTMIK_LoadSampleProcedure;
{ *** get index for sample }
I3 := Sample^[I1].PSM_SampleNumber;
{ *** clip PSM-sample }
IF Sample^[I1].PSM_SampleLoopEnd > Sample^[I1].PSM_SampleLength
THEN Sample^[I1].PSM_SampleLoopEnd := Sample^[I1].PSM_SampleLength;
{ *** init intern sample }
NEW(Module^.Module_SamplePointer^[I3]);
FILLCHAR(Module^.Module_SamplePointer^[I3]^,SIZEOF(TSample),$00);
FILLCHAR(Module^.Module_SamplePointer^[I3]^.Sample_SampleName,c_Sample_SampleNameLength,#32);
FILLCHAR(Module^.Module_SamplePointer^[I3]^.Sample_FileName,c_Sample_FileNameLength,#32);
{ *** copy informations to intern sample }
I2 := $01;
WHILE (Sample^[I1].PSM_SampleName[I2] > #00) AND (I2 < c_Sample_SampleNameLength) DO
BEGIN
Module^.Module_SamplePointer^[I3]^.Sample_SampleName[I2] := Sample^[I1].PSM_SampleName[I2];
INC(I2);
END;
Module^.Module_SamplePointer^[I3]^.Sample_Sign := 'DF';
Module^.Module_SamplePointer^[I3]^.Sample_FileFormatVersion := $00100;
Module^.Module_SamplePointer^[I3]^.Sample_Position := $00000000;
Module^.Module_SamplePointer^[I3]^.Sample_Selector := $0000;
Module^.Module_SamplePointer^[I3]^.Sample_Volume := Sample^[I1].PSM_SampleVolume;
Module^.Module_SamplePointer^[I3]^.Sample_LoopCounter := $00;
Module^.Module_SamplePointer^[I3]^.Sample_C5Speed := Sample^[I1].PSM_SampleC5Speed;
Module^.Module_SamplePointer^[I3]^.Sample_Length := Sample^[I1].PSM_SampleLength;
Module^.Module_SamplePointer^[I3]^.Sample_LoopBegin := Sample^[I1].PSM_SampleLoopBegin;
Module^.Module_SamplePointer^[I3]^.Sample_LoopEnd := Sample^[I1].PSM_SampleLoopEnd;
{ *** now it's time for the flags }
Module^.Module_SamplePointer^[I3]^.Sample_Flags :=
c_Sample_Flags_DigitalSample * BYTE(1) +
c_Sample_Flags_8BitSample * BYTE(1) +
c_Sample_Flags_UnsignedSampleData * BYTE(1) +
c_Sample_Flags_Packed * BYTE(0) +
c_Sample_Flags_LoopCounter * BYTE(0) +
c_Sample_Flags_SampleName * BYTE(1) +
c_Sample_Flags_LoopActive *
BYTE(Sample^[I1].PSM_SampleFlags AND (LONGINT(1) SHL 15) = (LONGINT(1) SHL 15));
{ *** alloc memory for sample-data }
E_Getmem(Module^.Module_SamplePointer^[I3]^.Sample_Selector,
Module^.Module_SamplePointer^[I3]^.Sample_Position,
Module^.Module_SamplePointer^[I3]^.Sample_Length + c_LoopExtensionSize);
{ *** read out data }
EPT(TempP).p_Selector := Module^.Module_SamplePointer^[I3]^.Sample_Selector;
EPT(TempP).p_Offset := $0000;
SEEK(InFile,Sample^[I1].PSM_SamplePosition);
E_BLOCKREAD(InFile,TempP^,Module^.Module_SamplePointer^[I3]^.Sample_Length);
{ *** 'coz the samples are signed in a DSM-file -> PC-fy them }
IF Module^.Module_SamplePointer^[I3]^.Sample_Length > 4 THEN
BEGIN
CopyLength := Module^.Module_SamplePointer^[I3]^.Sample_Length;
{ *** decode sample }
ASM
DB 066h; MOV CX,WORD PTR CopyLength
{ *** load sample selector }
MOV ES,WORD PTR TempP[00002h]
DB 066h; XOR SI,SI
DB 066h; XOR DI,DI
XOR AH,AH
{ *** conert all bytes }
@@MainLoop:
DB 026h; DB 067h; LODSB
ADD AL,AH
MOV AH,AL
DB 067h; STOSB
DB 066h; LOOP @@MainLoop
END;
{ *** make samples unsigned }
ASM
DB 066h; MOV CX,WORD PTR CopyLength
{ *** load sample selector }
MOV ES,WORD PTR TempP[00002h]
DB 066h; XOR SI,SI
DB 066h; XOR DI,DI
{ *** conert all bytes }
@@MainLoop:
DB 026h; DB 067h; LODSB
SUB AL,080h
DB 067h; STOSB
DB 066h; LOOP @@MainLoop
END;
{ *** Create Loop-Extension }
IF Module^.Module_SamplePointer^[I3]^.Sample_Flags AND c_Sample_Flags_LoopActive = c_Sample_Flags_LoopActive THEN
BEGIN
CopySource := Module^.Module_SamplePointer^[I3]^.Sample_LoopBegin;
CopyDestination := Module^.Module_SamplePointer^[I3]^.Sample_LoopEnd;
CopyLength := CopyDestination - CopySource;
ASM
{ *** load sample-selector }
MOV ES,WORD PTR TempP[00002h]
DB 066h; MOV DI,WORD PTR CopyDestination
{ *** calculate number of full sample-loops to copy }
XOR DX,DX
MOV AX,c_LoopExtensionSize
MOV BX,WORD PTR CopyLength
DIV BX
OR AX,AX
JE @@NoFullLoop
{ *** copy some full-loops (size=bx) }
MOV CX,AX
@@InnerLoop:
PUSH CX
DB 066h; MOV SI,WORD PTR CopySource
MOV CX,BX
DB 0F3h; DB 026h,067h,0A4h { REP MOVS BYTE PTR ES:[EDI],ES:[ESI] }
POP CX
LOOP @@InnerLoop
@@NoFullLoop:
{ *** calculate number of rest-bytes to copy }
DB 066h; MOV SI,WORD PTR CopySource
MOV CX,DX
DB 0F3h; DB 026h,067h,0A4h { REP MOVS BYTE PTR ES:[EDI],ES:[ESI] }
END;
END
ELSE
BEGIN
CopyDestination := Module^.Module_SamplePointer^[I3]^.Sample_Length;
ASM
{ *** load sample-selector }
MOV ES,WORD PTR TempP[00002h]
DB 066h; MOV DI,WORD PTR CopyDestination
{ *** clear extension }
MOV CX,c_LoopExtensionSize
MOV AL,080h
DB 0F3h; DB 067h,0AAh { REP STOS BYTE PTR ES:[EDI] }
END;
END;
END;
{ *** next sample }
END;
{ *** init period-ranges }
NTMIK_MaximumPeriod := $0000D600 SHR 1;
NTMIK_MinimumPeriod := $0000D600 SHR 8;
{ *** close file }
CLOSE(InFile);
{ *** dispose all dynamic variables }
DISPOSE(Header);
DISPOSE(Sample);
DISPOSE(Order);
DISPOSE(ChannelSettings);
DISPOSE(MultiPurposeBuffer);
DISPOSE(PatternBuffer);
{ *** set errorcode to noerror }
ErrorCode := c_NoError;
END;
*/
Reference in a new issue Copy permalink