mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-12-12 11:01:00 -05:00
499 lines
12 KiB
C++
499 lines
12 KiB
C++
/*
|
|
* Load_okt.cpp
|
|
* ------------
|
|
* Purpose: OKT (Oktalyzer) module loader
|
|
* Notes : (currently none)
|
|
* Authors: Storlek (Original author - http://schismtracker.org/ - code ported with permission)
|
|
* Johannes Schultz (OpenMPT Port, tweaks)
|
|
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
|
*/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "Loaders.h"
|
|
|
|
OPENMPT_NAMESPACE_BEGIN
|
|
|
|
struct OktIffChunk
|
|
{
|
|
// IFF chunk names
|
|
enum ChunkIdentifiers
|
|
{
|
|
idCMOD = MagicBE("CMOD"),
|
|
idSAMP = MagicBE("SAMP"),
|
|
idSPEE = MagicBE("SPEE"),
|
|
idSLEN = MagicBE("SLEN"),
|
|
idPLEN = MagicBE("PLEN"),
|
|
idPATT = MagicBE("PATT"),
|
|
idPBOD = MagicBE("PBOD"),
|
|
idSBOD = MagicBE("SBOD"),
|
|
};
|
|
|
|
uint32be signature; // IFF chunk name
|
|
uint32be chunksize; // chunk size without header
|
|
};
|
|
|
|
MPT_BINARY_STRUCT(OktIffChunk, 8)
|
|
|
|
struct OktSample
|
|
{
|
|
char name[20];
|
|
uint32be length; // length in bytes
|
|
uint16be loopStart; // *2 for real value
|
|
uint16be loopLength; // ditto
|
|
uint16be volume; // default volume
|
|
uint16be type; // 7-/8-bit sample
|
|
};
|
|
|
|
MPT_BINARY_STRUCT(OktSample, 32)
|
|
|
|
|
|
// Parse the sample header block
|
|
static void ReadOKTSamples(FileReader &chunk, CSoundFile &sndFile)
|
|
{
|
|
sndFile.m_nSamples = std::min(static_cast<SAMPLEINDEX>(chunk.BytesLeft() / sizeof(OktSample)), static_cast<SAMPLEINDEX>(MAX_SAMPLES - 1));
|
|
|
|
for(SAMPLEINDEX smp = 1; smp <= sndFile.GetNumSamples(); smp++)
|
|
{
|
|
ModSample &mptSmp = sndFile.GetSample(smp);
|
|
OktSample oktSmp;
|
|
chunk.ReadStruct(oktSmp);
|
|
|
|
mptSmp.Initialize();
|
|
sndFile.m_szNames[smp] = mpt::String::ReadBuf(mpt::String::maybeNullTerminated, oktSmp.name);
|
|
|
|
mptSmp.nC5Speed = 8287;
|
|
mptSmp.nVolume = std::min(oktSmp.volume.get(), uint16(64)) * 4u;
|
|
mptSmp.nLength = oktSmp.length & ~1;
|
|
mptSmp.cues[0] = oktSmp.type; // Temporary storage for pattern reader, will be reset later
|
|
// Parse loops
|
|
const SmpLength loopStart = oktSmp.loopStart * 2;
|
|
const SmpLength loopLength = oktSmp.loopLength * 2;
|
|
if(loopLength > 2 && loopStart + loopLength <= mptSmp.nLength)
|
|
{
|
|
mptSmp.uFlags.set(CHN_SUSTAINLOOP);
|
|
mptSmp.nSustainStart = loopStart;
|
|
mptSmp.nSustainEnd = loopStart + loopLength;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Parse a pattern block
|
|
static void ReadOKTPattern(FileReader &chunk, PATTERNINDEX pat, CSoundFile &sndFile, const std::array<int8, 8> pairedChn)
|
|
{
|
|
if(!chunk.CanRead(2))
|
|
{
|
|
// Invent empty pattern
|
|
sndFile.Patterns.Insert(pat, 64);
|
|
return;
|
|
}
|
|
|
|
ROWINDEX rows = Clamp(static_cast<ROWINDEX>(chunk.ReadUint16BE()), ROWINDEX(1), MAX_PATTERN_ROWS);
|
|
|
|
if(!sndFile.Patterns.Insert(pat, rows))
|
|
{
|
|
return;
|
|
}
|
|
|
|
const CHANNELINDEX chns = sndFile.GetNumChannels();
|
|
|
|
for(ROWINDEX row = 0; row < rows; row++)
|
|
{
|
|
auto rowCmd = sndFile.Patterns[pat].GetRow(row);
|
|
for(CHANNELINDEX chn = 0; chn < chns; chn++)
|
|
{
|
|
ModCommand &m = rowCmd[chn];
|
|
const auto [note, instr, effect, param] = chunk.ReadArray<uint8, 4>();
|
|
|
|
if(note > 0 && note <= 36)
|
|
{
|
|
m.note = note + (NOTE_MIDDLEC - 13);
|
|
m.instr = instr + 1;
|
|
if(m.instr > 0 && m.instr <= sndFile.GetNumSamples())
|
|
{
|
|
const auto &sample = sndFile.GetSample(m.instr);
|
|
// Default volume only works on raw Paula channels
|
|
if(pairedChn[chn] && sample.nVolume < 256)
|
|
{
|
|
m.volcmd = VOLCMD_VOLUME;
|
|
m.vol = 64;
|
|
}
|
|
// If channel and sample type don't match, stop this channel (add 100 to the instrument number to make it understandable what happened during import)
|
|
if((sample.cues[0] == 1 && pairedChn[chn] != 0) || (sample.cues[0] == 0 && pairedChn[chn] == 0))
|
|
{
|
|
m.instr += 100;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch(effect)
|
|
{
|
|
case 0: // Nothing
|
|
break;
|
|
|
|
case 1: // 1 Portamento Down (Period)
|
|
if(param)
|
|
{
|
|
m.command = CMD_PORTAMENTOUP;
|
|
m.param = param;
|
|
}
|
|
break;
|
|
case 2: // 2 Portamento Up (Period)
|
|
if(param)
|
|
{
|
|
m.command = CMD_PORTAMENTODOWN;
|
|
m.param = param;
|
|
}
|
|
break;
|
|
|
|
#if 0
|
|
/* these aren't like regular arpeggio: "down" means to *subtract* the offset from the note.
|
|
For now I'm going to leave these unimplemented. */
|
|
case 10: // A Arpeggio 1 (down, orig, up)
|
|
case 11: // B Arpeggio 2 (orig, up, orig, down)
|
|
if(param)
|
|
{
|
|
m.command = CMD_ARPEGGIO;
|
|
m.param = param;
|
|
}
|
|
break;
|
|
#endif
|
|
// This one is close enough to "standard" arpeggio -- I think!
|
|
case 12: // C Arpeggio 3 (up, up, orig)
|
|
if(param)
|
|
{
|
|
m.command = CMD_ARPEGGIO;
|
|
m.param = param;
|
|
}
|
|
break;
|
|
|
|
case 13: // D Slide Down (Notes)
|
|
if(param)
|
|
{
|
|
m.command = CMD_NOTESLIDEDOWN;
|
|
m.param = 0x10 | std::min(uint8(0x0F), param);
|
|
}
|
|
break;
|
|
case 30: // U Slide Up (Notes)
|
|
if(param)
|
|
{
|
|
m.command = CMD_NOTESLIDEUP;
|
|
m.param = 0x10 | std::min(uint8(0x0F), param);
|
|
}
|
|
break;
|
|
// Fine Slides are only implemented for libopenmpt. For OpenMPT,
|
|
// sliding every 5 (non-note) ticks kind of works (at least at
|
|
// speed 6), but implementing separate (format-agnostic) fine slide commands would of course be better.
|
|
case 21: // L Slide Down Once (Notes)
|
|
if(param)
|
|
{
|
|
m.command = CMD_NOTESLIDEDOWN;
|
|
m.param = 0x50 | std::min(uint8(0x0F), param);
|
|
}
|
|
break;
|
|
case 17: // H Slide Up Once (Notes)
|
|
if(param)
|
|
{
|
|
m.command = CMD_NOTESLIDEUP;
|
|
m.param = 0x50 | std::min(uint8(0x0F), param);
|
|
}
|
|
break;
|
|
|
|
case 15: // F Set Filter <>00:ON
|
|
m.command = CMD_MODCMDEX;
|
|
m.param = !!param;
|
|
break;
|
|
|
|
case 25: // P Pos Jump
|
|
m.command = CMD_POSITIONJUMP;
|
|
m.param = param;
|
|
break;
|
|
|
|
case 27: // R Release sample (apparently not listed in the help!)
|
|
m.Clear();
|
|
m.note = NOTE_KEYOFF;
|
|
break;
|
|
|
|
case 28: // S Speed
|
|
if(param < 0x20)
|
|
{
|
|
m.command = CMD_SPEED;
|
|
m.param = param;
|
|
}
|
|
break;
|
|
|
|
case 31: // V Volume
|
|
// Volume on mixed channels is permanent, on hardware channels it behaves like in regular MODs
|
|
if(param & 0x0F)
|
|
{
|
|
m.command = pairedChn[chn] ? CMD_CHANNELVOLSLIDE : CMD_VOLUMESLIDE;
|
|
m.param = param & 0x0F;
|
|
}
|
|
|
|
switch(param >> 4)
|
|
{
|
|
case 4: // Normal slide down
|
|
if(param != 0x40)
|
|
break;
|
|
// 0x40 is set volume -- fall through
|
|
[[fallthrough]];
|
|
case 0: case 1: case 2: case 3:
|
|
if(pairedChn[chn])
|
|
{
|
|
m.command = CMD_CHANNELVOLUME;
|
|
m.param = param;
|
|
} else
|
|
{
|
|
m.volcmd = VOLCMD_VOLUME;
|
|
m.vol = param;
|
|
m.command = CMD_NONE;
|
|
}
|
|
break;
|
|
case 5: // Normal slide up
|
|
m.param <<= 4;
|
|
break;
|
|
case 6: // Fine slide down
|
|
m.param = 0xF0 | std::min(static_cast<uint8>(m.param), uint8(0x0E));
|
|
break;
|
|
case 7: // Fine slide up
|
|
m.param = (std::min(static_cast<uint8>(m.param), uint8(0x0E)) << 4) | 0x0F;
|
|
break;
|
|
default:
|
|
// Junk.
|
|
m.command = CMD_NONE;
|
|
break;
|
|
}
|
|
|
|
// Volume is shared between two mixed channels, second channel has priority
|
|
if(m.command == CMD_CHANNELVOLUME || m.command == CMD_CHANNELVOLSLIDE)
|
|
{
|
|
ModCommand &other = rowCmd[chn + pairedChn[chn]];
|
|
// Try to preserve effect if there already was one
|
|
if(other.ConvertVolEffect(other.command, other.param, true))
|
|
{
|
|
other.volcmd = other.command;
|
|
other.vol = other.param;
|
|
}
|
|
other.command = m.command;
|
|
other.param = m.param;
|
|
}
|
|
break;
|
|
|
|
#if 0
|
|
case 24: // O Old Volume (???)
|
|
m.command = CMD_VOLUMESLIDE;
|
|
m.param = 0;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
m.command = CMD_NONE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CSoundFile::ProbeResult CSoundFile::ProbeFileHeaderOKT(MemoryFileReader file, const uint64 *pfilesize)
|
|
{
|
|
if(!file.CanRead(8))
|
|
{
|
|
return ProbeWantMoreData;
|
|
}
|
|
if(!file.ReadMagic("OKTASONG"))
|
|
{
|
|
return ProbeFailure;
|
|
}
|
|
OktIffChunk iffHead;
|
|
if(!file.ReadStruct(iffHead))
|
|
{
|
|
return ProbeWantMoreData;
|
|
}
|
|
if(iffHead.chunksize == 0)
|
|
{
|
|
return ProbeFailure;
|
|
}
|
|
if((iffHead.signature & 0x80808080u) != 0) // ASCII?
|
|
{
|
|
return ProbeFailure;
|
|
}
|
|
MPT_UNREFERENCED_PARAMETER(pfilesize);
|
|
return ProbeSuccess;
|
|
}
|
|
|
|
|
|
bool CSoundFile::ReadOKT(FileReader &file, ModLoadingFlags loadFlags)
|
|
{
|
|
file.Rewind();
|
|
if(!file.ReadMagic("OKTASONG"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// prepare some arrays to store offsets etc.
|
|
std::vector<FileReader> patternChunks;
|
|
std::vector<FileReader> sampleChunks;
|
|
std::array<int8, 8> pairedChn{{}};
|
|
ORDERINDEX numOrders = 0;
|
|
|
|
InitializeGlobals(MOD_TYPE_OKT);
|
|
|
|
m_modFormat.formatName = U_("Oktalyzer");
|
|
m_modFormat.type = U_("okt");
|
|
m_modFormat.charset = mpt::Charset::Amiga_no_C1;
|
|
|
|
// Go through IFF chunks...
|
|
while(file.CanRead(sizeof(OktIffChunk)))
|
|
{
|
|
OktIffChunk iffHead;
|
|
if(!file.ReadStruct(iffHead))
|
|
{
|
|
break;
|
|
}
|
|
|
|
FileReader chunk = file.ReadChunk(iffHead.chunksize);
|
|
if(!chunk.IsValid())
|
|
{
|
|
break;
|
|
}
|
|
|
|
switch(iffHead.signature)
|
|
{
|
|
case OktIffChunk::idCMOD:
|
|
// Channel setup table
|
|
if(m_nChannels == 0 && chunk.GetLength() >= 8)
|
|
{
|
|
const auto chnTable = chunk.ReadArray<uint16be, 4>();
|
|
for(CHANNELINDEX chn = 0; chn < 4; chn++)
|
|
{
|
|
if(chnTable[chn])
|
|
{
|
|
pairedChn[m_nChannels] = 1;
|
|
pairedChn[m_nChannels + 1] = -1;
|
|
ChnSettings[m_nChannels].Reset();
|
|
ChnSettings[m_nChannels++].nPan = (((chn & 3) == 1) || ((chn & 3) == 2)) ? 0xC0 : 0x40;
|
|
}
|
|
ChnSettings[m_nChannels].Reset();
|
|
ChnSettings[m_nChannels++].nPan = (((chn & 3) == 1) || ((chn & 3) == 2)) ? 0xC0 : 0x40;
|
|
}
|
|
|
|
if(loadFlags == onlyVerifyHeader)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case OktIffChunk::idSAMP:
|
|
// Convert sample headers
|
|
if(m_nSamples > 0)
|
|
{
|
|
break;
|
|
}
|
|
ReadOKTSamples(chunk, *this);
|
|
break;
|
|
|
|
case OktIffChunk::idSPEE:
|
|
// Read default speed
|
|
if(chunk.GetLength() >= 2)
|
|
{
|
|
m_nDefaultSpeed = Clamp(chunk.ReadUint16BE(), uint16(1), uint16(255));
|
|
}
|
|
break;
|
|
|
|
case OktIffChunk::idSLEN:
|
|
// Number of patterns, we don't need this.
|
|
break;
|
|
|
|
case OktIffChunk::idPLEN:
|
|
// Read number of valid orders
|
|
if(chunk.GetLength() >= 2)
|
|
{
|
|
numOrders = chunk.ReadUint16BE();
|
|
}
|
|
break;
|
|
|
|
case OktIffChunk::idPATT:
|
|
// Read the orderlist
|
|
ReadOrderFromFile<uint8>(Order(), chunk, chunk.GetLength(), 0xFF, 0xFE);
|
|
break;
|
|
|
|
case OktIffChunk::idPBOD:
|
|
// Don't read patterns for now, as the number of channels might be unknown at this point.
|
|
if(patternChunks.size() < 256)
|
|
{
|
|
patternChunks.push_back(chunk);
|
|
}
|
|
break;
|
|
|
|
case OktIffChunk::idSBOD:
|
|
// Sample data - same as with patterns, as we need to know the sample format / length
|
|
if(sampleChunks.size() < MAX_SAMPLES - 1 && chunk.GetLength() > 0)
|
|
{
|
|
sampleChunks.push_back(chunk);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Non-ASCII chunk ID?
|
|
if(iffHead.signature & 0x80808080)
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If there wasn't even a CMOD chunk, we can't really load this.
|
|
if(m_nChannels == 0)
|
|
return false;
|
|
|
|
m_nDefaultTempo.Set(125);
|
|
m_nDefaultGlobalVolume = MAX_GLOBAL_VOLUME;
|
|
m_nSamplePreAmp = m_nVSTiVolume = 48;
|
|
m_nMinPeriod = 113 * 4;
|
|
m_nMaxPeriod = 856 * 4;
|
|
|
|
// Fix orderlist
|
|
Order().resize(numOrders);
|
|
|
|
// Read patterns
|
|
if(loadFlags & loadPatternData)
|
|
{
|
|
Patterns.ResizeArray(static_cast<PATTERNINDEX>(patternChunks.size()));
|
|
for(PATTERNINDEX pat = 0; pat < patternChunks.size(); pat++)
|
|
{
|
|
ReadOKTPattern(patternChunks[pat], pat, *this, pairedChn);
|
|
}
|
|
}
|
|
|
|
// Read samples
|
|
size_t fileSmp = 0;
|
|
for(SAMPLEINDEX smp = 1; smp < m_nSamples; smp++)
|
|
{
|
|
if(fileSmp >= sampleChunks.size() || !(loadFlags & loadSampleData))
|
|
break;
|
|
|
|
ModSample &mptSample = Samples[smp];
|
|
mptSample.SetDefaultCuePoints();
|
|
if(mptSample.nLength == 0)
|
|
continue;
|
|
|
|
// Weird stuff?
|
|
LimitMax(mptSample.nLength, mpt::saturate_cast<SmpLength>(sampleChunks[fileSmp].GetLength()));
|
|
|
|
SampleIO(
|
|
SampleIO::_8bit,
|
|
SampleIO::mono,
|
|
SampleIO::bigEndian,
|
|
SampleIO::signedPCM)
|
|
.ReadSample(mptSample, sampleChunks[fileSmp]);
|
|
|
|
fileSmp++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
OPENMPT_NAMESPACE_END
|