steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/soundlib/InstrumentExtensions.cpp

776 lines
31 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
/*
* InstrumentExtensions.cpp
* ------------------------
* Purpose: Instrument properties I/O
* Notes : Welcome to the absolutely horrible abominations that are the "extended instrument properties"
* which are some of the earliest additions OpenMPT did to the IT / XM format. They are ugly,
* and the way they work even differs between IT/XM and ITI/XI/ITP.
* Yes, the world would be a better place without this stuff.
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Loaders.h"
#ifndef MODPLUG_NO_FILESAVE
#include "mpt/io/base.hpp"
#include "mpt/io/io.hpp"
#include "mpt/io/io_stdstream.hpp"
#endif
OPENMPT_NAMESPACE_BEGIN
/*---------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------
MODULAR (in/out) ModInstrument :
-----------------------------------------------------------------------------------------------
* to update:
------------
- both following functions need to be updated when adding a new member in ModInstrument :
void WriteInstrumentHeaderStructOrField(ModInstrument * input, std::ostream &file, uint32 only_this_code, int16 fixedsize);
bool ReadInstrumentHeaderField(ModInstrument * input, uint32 fcode, int16 fsize, FileReader &file);
- see below for body declaration.
* members:
----------
- 32bit identification CODE tag (must be unique)
- 16bit content SIZE in byte(s)
- member field
* CODE tag naming convention:
-----------------------------
- have a look below in current tag dictionnary
- take the initial ones of the field name
- 4 caracters code (not more, not less)
- must be filled with '.' caracters if code has less than 4 caracters
- for arrays, must include a '[' caracter following significant caracters ('.' not significant!!!)
- use only caracters used in full member name, ordered as they appear in it
- match caracter attribute (small,capital)
Example with "PanEnv.nLoopEnd" , "PitchEnv.nLoopEnd" & "VolEnv.Values[MAX_ENVPOINTS]" members :
- use 'PLE.' for PanEnv.nLoopEnd
- use 'PiLE' for PitchEnv.nLoopEnd
- use 'VE[.' for VolEnv.Values[MAX_ENVPOINTS]
* In use CODE tag dictionary (alphabetical order):
--------------------------------------------------
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!! SECTION TO BE UPDATED !!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
[EXT] means external (not related) to ModInstrument content
AUTH [EXT] Song artist
C... [EXT] nChannels
ChnS [EXT] IT/MPTM: Channel settings for channels 65-127 if needed (doesn't fit to IT header).
CS.. nCutSwing
CUES [EXT] Sample cue points
CWV. [EXT] dwCreatedWithVersion
DCT. nDCT;
dF.. dwFlags;
DGV. [EXT] nDefaultGlobalVolume
DT.. [EXT] nDefaultTempo;
DTFR [EXT] Fractional part of default tempo
DNA. nDNA;
EBIH [EXT] embeded instrument header tag (ITP file format)
FM.. filterMode;
fn[. filename[12];
FO.. nFadeOut;
GV.. nGlobalVol;
IFC. nIFC;
IFR. nIFR;
K[. Keyboard[128];
LSWV [EXT] Last Saved With Version
MB.. wMidiBank;
MC.. nMidiChannel;
MDK. nMidiDrumKey;
MIMA [EXT] MIdi MApping directives
MiP. nMixPlug;
MP.. nMidiProgram;
MPTS [EXT] Extra song info tag
MPTX [EXT] EXTRA INFO tag
MSF. [EXT] Mod(Specific)Flags
n[.. name[32];
NNA. nNNA;
NM[. NoteMap[128];
P... nPan;
PE.. PanEnv.nNodes;
PE[. PanEnv.Values[MAX_ENVPOINTS];
PiE. PitchEnv.nNodes;
PiE[ PitchEnv.Values[MAX_ENVPOINTS];
PiLE PitchEnv.nLoopEnd;
PiLS PitchEnv.nLoopStart;
PiP[ PitchEnv.Ticks[MAX_ENVPOINTS];
PiSB PitchEnv.nSustainStart;
PiSE PitchEnv.nSustainEnd;
PLE. PanEnv.nLoopEnd;
PLS. PanEnv.nLoopStart;
PMM. [EXT] nPlugMixMode;
PP[. PanEnv.Ticks[MAX_ENVPOINTS];
PPC. nPPC;
PPS. nPPS;
PS.. nPanSwing;
PSB. PanEnv.nSustainStart;
PSE. PanEnv.nSustainEnd;
PTTL pitchToTempoLock;
PTTF pitchToTempoLock (fractional part);
PVEH pluginVelocityHandling;
PVOH pluginVolumeHandling;
R... resampling;
RP.. [EXT] nRestartPos;
RPB. [EXT] nRowsPerBeat;
RPM. [EXT] nRowsPerMeasure;
RS.. nResSwing;
RSMP [EXT] Global resampling
SEP@ [EXT] chunk SEPARATOR tag
SPA. [EXT] m_nSamplePreAmp;
TM.. [EXT] nTempoMode;
VE.. VolEnv.nNodes;
VE[. VolEnv.Values[MAX_ENVPOINTS];
VLE. VolEnv.nLoopEnd;
VLS. VolEnv.nLoopStart;
VP[. VolEnv.Ticks[MAX_ENVPOINTS];
VR.. nVolRampUp;
VS.. nVolSwing;
VSB. VolEnv.nSustainStart;
VSE. VolEnv.nSustainEnd;
VSTV [EXT] nVSTiVolume;
PERN PitchEnv.nReleaseNode
AERN PanEnv.nReleaseNode
VERN VolEnv.nReleaseNode
PFLG PitchEnv.dwFlag
AFLG PanEnv.dwFlags
VFLG VolEnv.dwFlags
MPWD MIDI Pitch Wheel Depth
-----------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------*/
#ifndef MODPLUG_NO_FILESAVE
template<typename T, bool is_signed> struct IsNegativeFunctor { bool operator()(T val) const { return val < 0; } };
template<typename T> struct IsNegativeFunctor<T, true> { bool operator()(T val) const { return val < 0; } };
template<typename T> struct IsNegativeFunctor<T, false> { bool operator()(T /*val*/) const { return false; } };
template<typename T>
bool IsNegative(const T &val)
{
return IsNegativeFunctor<T, std::numeric_limits<T>::is_signed>()(val);
}
// ------------------------------------------------------------------------------------------
// Convenient macro to help WRITE_HEADER declaration for single type members ONLY (non-array)
// ------------------------------------------------------------------------------------------
#define WRITE_MPTHEADER_sized_member(name,type,code) \
static_assert(sizeof(input->name) == sizeof(type), "Instrument property does match specified type!");\
fcode = code;\
fsize = sizeof( type );\
if(writeAll) \
{ \
mpt::IO::WriteIntLE<uint32>(file, fcode); \
mpt::IO::WriteIntLE<uint16>(file, fsize); \
} else if(only_this_code == fcode)\
{ \
MPT_ASSERT(fixedsize == fsize); \
} \
if(only_this_code == fcode || only_this_code == Util::MaxValueOfType(only_this_code)) \
{ \
type tmp = (type)(input-> name ); \
mpt::IO::WriteIntLE(file, tmp); \
} \
/**/
// -----------------------------------------------------------------------------------------------------
// Convenient macro to help WRITE_HEADER declaration for single type members which are written truncated
// -----------------------------------------------------------------------------------------------------
#define WRITE_MPTHEADER_trunc_member(name,type,code) \
static_assert(sizeof(input->name) > sizeof(type), "Instrument property would not be truncated, use WRITE_MPTHEADER_sized_member instead!");\
fcode = code;\
fsize = sizeof( type );\
if(writeAll) \
{ \
mpt::IO::WriteIntLE<uint32>(file, fcode); \
mpt::IO::WriteIntLE<uint16>(file, fsize); \
type tmp = (type)(input-> name ); \
mpt::IO::WriteIntLE(file, tmp); \
} else if(only_this_code == fcode)\
{ \
/* hackish workaround to resolve mismatched size values: */ \
/* nResampling was a long time declared as uint32 but these macro tables used uint16 and UINT. */ \
/* This worked fine on little-endian, on big-endian not so much. Thus support writing size-mismatched fields. */ \
MPT_ASSERT(fixedsize >= fsize); \
type tmp = (type)(input-> name ); \
mpt::IO::WriteIntLE(file, tmp); \
if(fixedsize > fsize) \
{ \
for(int16 i = 0; i < fixedsize - fsize; ++i) \
{ \
uint8 fillbyte = !IsNegative(tmp) ? 0 : 0xff; /* sign extend */ \
mpt::IO::WriteIntLE(file, fillbyte); \
} \
} \
} \
/**/
// ------------------------------------------------------------------------
// Convenient macro to help WRITE_HEADER declaration for array members ONLY
// ------------------------------------------------------------------------
#define WRITE_MPTHEADER_array_member(name,type,code,arraysize) \
static_assert(sizeof(type) == sizeof(input-> name [0])); \
MPT_ASSERT(sizeof(input->name) >= sizeof(type) * arraysize);\
fcode = code;\
fsize = sizeof( type ) * arraysize;\
if(writeAll) \
{ \
mpt::IO::WriteIntLE<uint32>(file, fcode); \
mpt::IO::WriteIntLE<uint16>(file, fsize); \
} else if(only_this_code == fcode)\
{ \
/* MPT_ASSERT(fixedsize <= fsize); */ \
fsize = fixedsize; /* just trust the size we got passed */ \
} \
if(only_this_code == fcode || only_this_code == Util::MaxValueOfType(only_this_code)) \
{ \
for(std::size_t i = 0; i < fsize/sizeof(type); ++i) \
{ \
type tmp; \
tmp = input-> name [i]; \
mpt::IO::WriteIntLE(file, tmp); \
} \
} \
/**/
// ------------------------------------------------------------------------
// Convenient macro to help WRITE_HEADER declaration for envelope members ONLY
// ------------------------------------------------------------------------
#define WRITE_MPTHEADER_envelope_member(envType,envField,type,code) \
{\
const InstrumentEnvelope &env = input->GetEnvelope(envType); \
static_assert(sizeof(type) == sizeof(env[0]. envField)); \
fcode = code;\
fsize = mpt::saturate_cast<int16>(sizeof( type ) * env.size());\
MPT_ASSERT(size_t(fsize) == sizeof( type ) * env.size()); \
\
if(writeAll) \
{ \
mpt::IO::WriteIntLE<uint32>(file, fcode); \
mpt::IO::WriteIntLE<uint16>(file, fsize); \
} else if(only_this_code == fcode)\
{ \
fsize = fixedsize; /* just trust the size we got passed */ \
} \
if(only_this_code == fcode || only_this_code == Util::MaxValueOfType(only_this_code)) \
{ \
uint32 maxNodes = std::min(static_cast<uint32>(fsize/sizeof(type)), static_cast<uint32>(env.size())); \
for(uint32 i = 0; i < maxNodes; ++i) \
{ \
type tmp; \
tmp = env[i]. envField ; \
mpt::IO::WriteIntLE(file, tmp); \
} \
/* Not every instrument's envelope will be the same length. fill up with zeros. */ \
for(uint32 i = maxNodes; i < fsize/sizeof(type); ++i) \
{ \
type tmp = 0; \
mpt::IO::WriteIntLE(file, tmp); \
} \
} \
}\
/**/
// Write (in 'file') 'input' ModInstrument with 'code' & 'size' extra field infos for each member
void WriteInstrumentHeaderStructOrField(ModInstrument * input, std::ostream &file, uint32 only_this_code, uint16 fixedsize)
{
uint32 fcode;
uint16 fsize;
// If true, all extension are written to the file; otherwise only the specified extension is written.
// writeAll is true iff we are saving an instrument (or, hypothetically, the legacy ITP format)
const bool writeAll = only_this_code == Util::MaxValueOfType(only_this_code);
if(!writeAll)
{
MPT_ASSERT(fixedsize > 0);
}
// clang-format off
WRITE_MPTHEADER_sized_member( nFadeOut , uint32 , MagicBE("FO..") )
WRITE_MPTHEADER_sized_member( nPan , uint32 , MagicBE("P...") )
WRITE_MPTHEADER_sized_member( VolEnv.size() , uint32 , MagicBE("VE..") )
WRITE_MPTHEADER_sized_member( PanEnv.size() , uint32 , MagicBE("PE..") )
WRITE_MPTHEADER_sized_member( PitchEnv.size() , uint32 , MagicBE("PiE.") )
WRITE_MPTHEADER_sized_member( wMidiBank , uint16 , MagicBE("MB..") )
WRITE_MPTHEADER_sized_member( nMidiProgram , uint8 , MagicBE("MP..") )
WRITE_MPTHEADER_sized_member( nMidiChannel , uint8 , MagicBE("MC..") )
WRITE_MPTHEADER_envelope_member( ENV_VOLUME , tick , uint16 , MagicBE("VP[.") )
WRITE_MPTHEADER_envelope_member( ENV_PANNING , tick , uint16 , MagicBE("PP[.") )
WRITE_MPTHEADER_envelope_member( ENV_PITCH , tick , uint16 , MagicBE("PiP[") )
WRITE_MPTHEADER_envelope_member( ENV_VOLUME , value , uint8 , MagicBE("VE[.") )
WRITE_MPTHEADER_envelope_member( ENV_PANNING , value , uint8 , MagicBE("PE[.") )
WRITE_MPTHEADER_envelope_member( ENV_PITCH , value , uint8 , MagicBE("PiE[") )
WRITE_MPTHEADER_sized_member( nMixPlug , uint8 , MagicBE("MiP.") )
WRITE_MPTHEADER_sized_member( nVolRampUp , uint16 , MagicBE("VR..") )
WRITE_MPTHEADER_sized_member( resampling , uint8 , MagicBE("R...") )
WRITE_MPTHEADER_sized_member( nCutSwing , uint8 , MagicBE("CS..") )
WRITE_MPTHEADER_sized_member( nResSwing , uint8 , MagicBE("RS..") )
WRITE_MPTHEADER_sized_member( filterMode , uint8 , MagicBE("FM..") )
WRITE_MPTHEADER_sized_member( pluginVelocityHandling , uint8 , MagicBE("PVEH") )
WRITE_MPTHEADER_sized_member( pluginVolumeHandling , uint8 , MagicBE("PVOH") )
WRITE_MPTHEADER_trunc_member( pitchToTempoLock.GetInt() , uint16 , MagicBE("PTTL") )
WRITE_MPTHEADER_trunc_member( pitchToTempoLock.GetFract() , uint16 , MagicLE("PTTF") )
WRITE_MPTHEADER_sized_member( PitchEnv.nReleaseNode , uint8 , MagicBE("PERN") )
WRITE_MPTHEADER_sized_member( PanEnv.nReleaseNode , uint8 , MagicBE("AERN") )
WRITE_MPTHEADER_sized_member( VolEnv.nReleaseNode , uint8 , MagicBE("VERN") )
WRITE_MPTHEADER_sized_member( PitchEnv.dwFlags , uint8 , MagicBE("PFLG") )
WRITE_MPTHEADER_sized_member( PanEnv.dwFlags , uint8 , MagicBE("AFLG") )
WRITE_MPTHEADER_sized_member( VolEnv.dwFlags , uint8 , MagicBE("VFLG") )
WRITE_MPTHEADER_sized_member( midiPWD , int8 , MagicBE("MPWD") )
// clang-format on
}
template<typename TIns, typename PropType>
static bool IsPropertyNeeded(const TIns &Instruments, PropType ModInstrument::*Prop)
{
const ModInstrument defaultIns;
for(const auto &ins : Instruments)
{
if(ins != nullptr && defaultIns.*Prop != ins->*Prop)
return true;
}
return false;
}
template<typename PropType>
static void WritePropertyIfNeeded(const CSoundFile &sndFile, PropType ModInstrument::*Prop, uint32 code, uint16 size, std::ostream &f, INSTRUMENTINDEX numInstruments)
{
if(IsPropertyNeeded(sndFile.Instruments, Prop))
{
sndFile.WriteInstrumentPropertyForAllInstruments(code, size, f, numInstruments);
}
}
// Used only when saving IT, XM and MPTM.
// ITI, ITP saves using Ericus' macros etc...
// The reason is that ITs and XMs save [code][size][ins1.Value][ins2.Value]...
// whereas ITP saves [code][size][ins1.Value][code][size][ins2.Value]...
// too late to turn back....
void CSoundFile::SaveExtendedInstrumentProperties(INSTRUMENTINDEX numInstruments, std::ostream &f) const
{
uint32 code = MagicBE("MPTX"); // write extension header code
mpt::IO::WriteIntLE<uint32>(f, code);
if (numInstruments == 0)
return;
WritePropertyIfNeeded(*this, &ModInstrument::nVolRampUp, MagicBE("VR.."), sizeof(ModInstrument::nVolRampUp), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::nMixPlug, MagicBE("MiP."), sizeof(ModInstrument::nMixPlug), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::nMidiChannel, MagicBE("MC.."), sizeof(ModInstrument::nMidiChannel), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::nMidiProgram, MagicBE("MP.."), sizeof(ModInstrument::nMidiProgram), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::wMidiBank, MagicBE("MB.."), sizeof(ModInstrument::wMidiBank), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::resampling, MagicBE("R..."), sizeof(ModInstrument::resampling), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::pluginVelocityHandling, MagicBE("PVEH"), sizeof(ModInstrument::pluginVelocityHandling), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::pluginVolumeHandling, MagicBE("PVOH"), sizeof(ModInstrument::pluginVolumeHandling), f, numInstruments);
if(!(GetType() & MOD_TYPE_XM))
{
// XM instrument headers already stores full-precision fade-out
WritePropertyIfNeeded(*this, &ModInstrument::nFadeOut, MagicBE("FO.."), sizeof(ModInstrument::nFadeOut), f, numInstruments);
// XM instrument headers already have support for this
WritePropertyIfNeeded(*this, &ModInstrument::midiPWD, MagicBE("MPWD"), sizeof(ModInstrument::midiPWD), f, numInstruments);
// We never supported these as hacks in XM (luckily!)
WritePropertyIfNeeded(*this, &ModInstrument::nPan, MagicBE("P..."), sizeof(ModInstrument::nPan), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::nCutSwing, MagicBE("CS.."), sizeof(ModInstrument::nCutSwing), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::nResSwing, MagicBE("RS.."), sizeof(ModInstrument::nResSwing), f, numInstruments);
WritePropertyIfNeeded(*this, &ModInstrument::filterMode, MagicBE("FM.."), sizeof(ModInstrument::filterMode), f, numInstruments);
if(IsPropertyNeeded(Instruments, &ModInstrument::pitchToTempoLock))
{
WriteInstrumentPropertyForAllInstruments(MagicBE("PTTL"), sizeof(uint16), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicLE("PTTF"), sizeof(uint16), f, numInstruments);
}
}
if(GetType() & MOD_TYPE_MPT)
{
uint32 maxNodes[3] = { 0, 0, 0 };
bool hasReleaseNode[3] = { false, false, false };
for(INSTRUMENTINDEX i = 1; i <= numInstruments; i++) if(Instruments[i] != nullptr)
{
maxNodes[0] = std::max(maxNodes[0], Instruments[i]->VolEnv.size());
maxNodes[1] = std::max(maxNodes[1], Instruments[i]->PanEnv.size());
maxNodes[2] = std::max(maxNodes[2], Instruments[i]->PitchEnv.size());
hasReleaseNode[0] |= (Instruments[i]->VolEnv.nReleaseNode != ENV_RELEASE_NODE_UNSET);
hasReleaseNode[1] |= (Instruments[i]->PanEnv.nReleaseNode != ENV_RELEASE_NODE_UNSET);
hasReleaseNode[2] |= (Instruments[i]->PitchEnv.nReleaseNode != ENV_RELEASE_NODE_UNSET);
}
// write full envelope information for MPTM files (more env points)
if(maxNodes[0] > 25)
{
WriteInstrumentPropertyForAllInstruments(MagicBE("VE.."), sizeof(ModInstrument::VolEnv.size()), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("VP[."), static_cast<uint16>(maxNodes[0] * sizeof(EnvelopeNode::tick)), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("VE[."), static_cast<uint16>(maxNodes[0] * sizeof(EnvelopeNode::value)), f, numInstruments);
}
if(maxNodes[1] > 25)
{
WriteInstrumentPropertyForAllInstruments(MagicBE("PE.."), sizeof(ModInstrument::PanEnv.size()), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("PP[."), static_cast<uint16>(maxNodes[1] * sizeof(EnvelopeNode::tick)), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("PE[."), static_cast<uint16>(maxNodes[1] * sizeof(EnvelopeNode::value)), f, numInstruments);
}
if(maxNodes[2] > 25)
{
WriteInstrumentPropertyForAllInstruments(MagicBE("PiE."), sizeof(ModInstrument::PitchEnv.size()), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("PiP["), static_cast<uint16>(maxNodes[2] * sizeof(EnvelopeNode::tick)), f, numInstruments);
WriteInstrumentPropertyForAllInstruments(MagicBE("PiE["), static_cast<uint16>(maxNodes[2] * sizeof(EnvelopeNode::value)), f, numInstruments);
}
if(hasReleaseNode[0])
WriteInstrumentPropertyForAllInstruments(MagicBE("VERN"), sizeof(ModInstrument::VolEnv.nReleaseNode), f, numInstruments);
if(hasReleaseNode[1])
WriteInstrumentPropertyForAllInstruments(MagicBE("AERN"), sizeof(ModInstrument::PanEnv.nReleaseNode), f, numInstruments);
if(hasReleaseNode[2])
WriteInstrumentPropertyForAllInstruments(MagicBE("PERN"), sizeof(ModInstrument::PitchEnv.nReleaseNode), f, numInstruments);
}
}
void CSoundFile::WriteInstrumentPropertyForAllInstruments(uint32 code, uint16 size, std::ostream &f, INSTRUMENTINDEX nInstruments) const
{
mpt::IO::WriteIntLE<uint32>(f, code); //write code
mpt::IO::WriteIntLE<uint16>(f, size); //write size
for(INSTRUMENTINDEX i = 1; i <= nInstruments; i++) //for all instruments...
{
if (Instruments[i])
{
WriteInstrumentHeaderStructOrField(Instruments[i], f, code, size);
} else
{
ModInstrument emptyInstrument;
WriteInstrumentHeaderStructOrField(&emptyInstrument, f, code, size);
}
}
}
#endif // !MODPLUG_NO_FILESAVE
// --------------------------------------------------------------------------------------------
// Convenient macro to help GET_HEADER declaration for single type members ONLY (non-array)
// --------------------------------------------------------------------------------------------
#define GET_MPTHEADER_sized_member(name,type,code) \
case code: \
{\
if( fsize <= sizeof( type ) ) \
{ \
/* hackish workaround to resolve mismatched size values: */ \
/* nResampling was a long time declared as uint32 but these macro tables used uint16 and UINT. */ \
/* This worked fine on little-endian, on big-endian not so much. Thus support reading size-mismatched fields. */ \
if(file.CanRead(fsize)) \
{ \
type tmp; \
tmp = file.ReadTruncatedIntLE<type>(fsize); \
static_assert(sizeof(tmp) == sizeof(input-> name )); \
input-> name = decltype(input-> name )(tmp); \
result = true; \
} \
} \
} break;
// --------------------------------------------------------------------------------------------
// Convenient macro to help GET_HEADER declaration for array members ONLY
// --------------------------------------------------------------------------------------------
#define GET_MPTHEADER_array_member(name,type,code) \
case code: \
{\
if( fsize <= sizeof( type ) * std::size(input-> name) ) \
{ \
FileReader arrayChunk = file.ReadChunk(fsize); \
for(std::size_t i = 0; i < std::size(input-> name); ++i) \
{ \
input-> name [i] = arrayChunk.ReadIntLE<type>(); \
} \
result = true; \
} \
} break;
// --------------------------------------------------------------------------------------------
// Convenient macro to help GET_HEADER declaration for character buffer members ONLY
// --------------------------------------------------------------------------------------------
#define GET_MPTHEADER_charbuf_member(name,type,code) \
case code: \
{\
if( fsize <= sizeof( type ) * input-> name .static_length() ) \
{ \
FileReader arrayChunk = file.ReadChunk(fsize); \
std::string tmp; \
for(std::size_t i = 0; i < fsize; ++i) \
{ \
tmp += arrayChunk.ReadChar(); \
} \
input-> name = tmp; \
result = true; \
} \
} break;
// --------------------------------------------------------------------------------------------
// Convenient macro to help GET_HEADER declaration for envelope tick/value members
// --------------------------------------------------------------------------------------------
#define GET_MPTHEADER_envelope_member(envType,envField,type,code) \
case code: \
{\
FileReader arrayChunk = file.ReadChunk(fsize); \
InstrumentEnvelope &env = input->GetEnvelope(envType); \
for(uint32 i = 0; i < env.size(); i++) \
{ \
env[i]. envField = arrayChunk.ReadIntLE<type>(); \
} \
result = true; \
} break;
// Return a pointer on the wanted field in 'input' ModInstrument given field code & size
bool ReadInstrumentHeaderField(ModInstrument *input, uint32 fcode, uint16 fsize, FileReader &file)
{
if(input == nullptr) return false;
bool result = false;
// Members which can be found in this table but not in the write table are only required in the legacy ITP format.
switch(fcode)
{
// clang-format off
GET_MPTHEADER_sized_member( nFadeOut , uint32 , MagicBE("FO..") )
GET_MPTHEADER_sized_member( dwFlags , uint8 , MagicBE("dF..") )
GET_MPTHEADER_sized_member( nGlobalVol , uint32 , MagicBE("GV..") )
GET_MPTHEADER_sized_member( nPan , uint32 , MagicBE("P...") )
GET_MPTHEADER_sized_member( VolEnv.nLoopStart , uint8 , MagicBE("VLS.") )
GET_MPTHEADER_sized_member( VolEnv.nLoopEnd , uint8 , MagicBE("VLE.") )
GET_MPTHEADER_sized_member( VolEnv.nSustainStart , uint8 , MagicBE("VSB.") )
GET_MPTHEADER_sized_member( VolEnv.nSustainEnd , uint8 , MagicBE("VSE.") )
GET_MPTHEADER_sized_member( PanEnv.nLoopStart , uint8 , MagicBE("PLS.") )
GET_MPTHEADER_sized_member( PanEnv.nLoopEnd , uint8 , MagicBE("PLE.") )
GET_MPTHEADER_sized_member( PanEnv.nSustainStart , uint8 , MagicBE("PSB.") )
GET_MPTHEADER_sized_member( PanEnv.nSustainEnd , uint8 , MagicBE("PSE.") )
GET_MPTHEADER_sized_member( PitchEnv.nLoopStart , uint8 , MagicBE("PiLS") )
GET_MPTHEADER_sized_member( PitchEnv.nLoopEnd , uint8 , MagicBE("PiLE") )
GET_MPTHEADER_sized_member( PitchEnv.nSustainStart , uint8 , MagicBE("PiSB") )
GET_MPTHEADER_sized_member( PitchEnv.nSustainEnd , uint8 , MagicBE("PiSE") )
GET_MPTHEADER_sized_member( nNNA , uint8 , MagicBE("NNA.") )
GET_MPTHEADER_sized_member( nDCT , uint8 , MagicBE("DCT.") )
GET_MPTHEADER_sized_member( nDNA , uint8 , MagicBE("DNA.") )
GET_MPTHEADER_sized_member( nPanSwing , uint8 , MagicBE("PS..") )
GET_MPTHEADER_sized_member( nVolSwing , uint8 , MagicBE("VS..") )
GET_MPTHEADER_sized_member( nIFC , uint8 , MagicBE("IFC.") )
GET_MPTHEADER_sized_member( nIFR , uint8 , MagicBE("IFR.") )
GET_MPTHEADER_sized_member( wMidiBank , uint16 , MagicBE("MB..") )
GET_MPTHEADER_sized_member( nMidiProgram , uint8 , MagicBE("MP..") )
GET_MPTHEADER_sized_member( nMidiChannel , uint8 , MagicBE("MC..") )
GET_MPTHEADER_sized_member( nPPS , int8 , MagicBE("PPS.") )
GET_MPTHEADER_sized_member( nPPC , uint8 , MagicBE("PPC.") )
GET_MPTHEADER_envelope_member(ENV_VOLUME , tick , uint16 , MagicBE("VP[.") )
GET_MPTHEADER_envelope_member(ENV_PANNING , tick , uint16 , MagicBE("PP[.") )
GET_MPTHEADER_envelope_member(ENV_PITCH , tick , uint16 , MagicBE("PiP[") )
GET_MPTHEADER_envelope_member(ENV_VOLUME , value , uint8 , MagicBE("VE[.") )
GET_MPTHEADER_envelope_member(ENV_PANNING , value , uint8 , MagicBE("PE[.") )
GET_MPTHEADER_envelope_member(ENV_PITCH , value , uint8 , MagicBE("PiE[") )
GET_MPTHEADER_array_member( NoteMap , uint8 , MagicBE("NM[.") )
GET_MPTHEADER_array_member( Keyboard , uint16 , MagicBE("K[..") )
GET_MPTHEADER_charbuf_member( name , char , MagicBE("n[..") )
GET_MPTHEADER_charbuf_member( filename , char , MagicBE("fn[.") )
GET_MPTHEADER_sized_member( nMixPlug , uint8 , MagicBE("MiP.") )
GET_MPTHEADER_sized_member( nVolRampUp , uint16 , MagicBE("VR..") )
GET_MPTHEADER_sized_member( nCutSwing , uint8 , MagicBE("CS..") )
GET_MPTHEADER_sized_member( nResSwing , uint8 , MagicBE("RS..") )
GET_MPTHEADER_sized_member( filterMode , uint8 , MagicBE("FM..") )
GET_MPTHEADER_sized_member( pluginVelocityHandling , uint8 , MagicBE("PVEH") )
GET_MPTHEADER_sized_member( pluginVolumeHandling , uint8 , MagicBE("PVOH") )
GET_MPTHEADER_sized_member( PitchEnv.nReleaseNode , uint8 , MagicBE("PERN") )
GET_MPTHEADER_sized_member( PanEnv.nReleaseNode , uint8 , MagicBE("AERN") )
GET_MPTHEADER_sized_member( VolEnv.nReleaseNode , uint8 , MagicBE("VERN") )
GET_MPTHEADER_sized_member( PitchEnv.dwFlags , uint8 , MagicBE("PFLG") )
GET_MPTHEADER_sized_member( PanEnv.dwFlags , uint8 , MagicBE("AFLG") )
GET_MPTHEADER_sized_member( VolEnv.dwFlags , uint8 , MagicBE("VFLG") )
GET_MPTHEADER_sized_member( midiPWD , int8 , MagicBE("MPWD") )
// clang-format on
case MagicBE("R..."):
{
// Resampling has been written as various sizes including uint16 and uint32 in the past
uint32 tmp = file.ReadSizedIntLE<uint32>(fsize);
if(Resampling::IsKnownMode(tmp))
input->resampling = static_cast<ResamplingMode>(tmp);
result = true;
} break;
case MagicBE("PTTL"):
{
// Integer part of pitch/tempo lock
uint16 tmp = file.ReadSizedIntLE<uint16>(fsize);
input->pitchToTempoLock.Set(tmp, input->pitchToTempoLock.GetFract());
result = true;
} break;
case MagicLE("PTTF"):
{
// Fractional part of pitch/tempo lock
uint16 tmp = file.ReadSizedIntLE<uint16>(fsize);
input->pitchToTempoLock.Set(input->pitchToTempoLock.GetInt(), tmp);
result = true;
} break;
case MagicBE("VE.."):
input->VolEnv.resize(std::min(uint32(MAX_ENVPOINTS), file.ReadSizedIntLE<uint32>(fsize)));
result = true;
break;
case MagicBE("PE.."):
input->PanEnv.resize(std::min(uint32(MAX_ENVPOINTS), file.ReadSizedIntLE<uint32>(fsize)));
result = true;
break;
case MagicBE("PiE."):
input->PitchEnv.resize(std::min(uint32(MAX_ENVPOINTS), file.ReadSizedIntLE<uint32>(fsize)));
result = true;
break;
}
return result;
}
// Convert instrument flags which were read from 'dF..' extension to proper internal representation.
static void ConvertReadExtendedFlags(ModInstrument *pIns)
{
// Flags of 'dF..' datafield in extended instrument properties.
enum
{
dFdd_VOLUME = 0x0001,
dFdd_VOLSUSTAIN = 0x0002,
dFdd_VOLLOOP = 0x0004,
dFdd_PANNING = 0x0008,
dFdd_PANSUSTAIN = 0x0010,
dFdd_PANLOOP = 0x0020,
dFdd_PITCH = 0x0040,
dFdd_PITCHSUSTAIN = 0x0080,
dFdd_PITCHLOOP = 0x0100,
dFdd_SETPANNING = 0x0200,
dFdd_FILTER = 0x0400,
dFdd_VOLCARRY = 0x0800,
dFdd_PANCARRY = 0x1000,
dFdd_PITCHCARRY = 0x2000,
dFdd_MUTE = 0x4000,
};
const uint32 dwOldFlags = pIns->dwFlags.GetRaw();
pIns->VolEnv.dwFlags.set(ENV_ENABLED, (dwOldFlags & dFdd_VOLUME) != 0);
pIns->VolEnv.dwFlags.set(ENV_SUSTAIN, (dwOldFlags & dFdd_VOLSUSTAIN) != 0);
pIns->VolEnv.dwFlags.set(ENV_LOOP, (dwOldFlags & dFdd_VOLLOOP) != 0);
pIns->VolEnv.dwFlags.set(ENV_CARRY, (dwOldFlags & dFdd_VOLCARRY) != 0);
pIns->PanEnv.dwFlags.set(ENV_ENABLED, (dwOldFlags & dFdd_PANNING) != 0);
pIns->PanEnv.dwFlags.set(ENV_SUSTAIN, (dwOldFlags & dFdd_PANSUSTAIN) != 0);
pIns->PanEnv.dwFlags.set(ENV_LOOP, (dwOldFlags & dFdd_PANLOOP) != 0);
pIns->PanEnv.dwFlags.set(ENV_CARRY, (dwOldFlags & dFdd_PANCARRY) != 0);
pIns->PitchEnv.dwFlags.set(ENV_ENABLED, (dwOldFlags & dFdd_PITCH) != 0);
pIns->PitchEnv.dwFlags.set(ENV_SUSTAIN, (dwOldFlags & dFdd_PITCHSUSTAIN) != 0);
pIns->PitchEnv.dwFlags.set(ENV_LOOP, (dwOldFlags & dFdd_PITCHLOOP) != 0);
pIns->PitchEnv.dwFlags.set(ENV_CARRY, (dwOldFlags & dFdd_PITCHCARRY) != 0);
pIns->PitchEnv.dwFlags.set(ENV_FILTER, (dwOldFlags & dFdd_FILTER) != 0);
pIns->dwFlags.reset();
pIns->dwFlags.set(INS_SETPANNING, (dwOldFlags & dFdd_SETPANNING) != 0);
pIns->dwFlags.set(INS_MUTE, (dwOldFlags & dFdd_MUTE) != 0);
}
void ReadInstrumentExtensionField(ModInstrument* pIns, const uint32 code, const uint16 size, FileReader &file)
{
if(code == MagicBE("K[.."))
{
// skip keyboard mapping
file.Skip(size);
return;
}
bool success = ReadInstrumentHeaderField(pIns, code, size, file);
if(!success)
{
file.Skip(size);
return;
}
if(code == MagicBE("dF..")) // 'dF..' field requires additional processing.
ConvertReadExtendedFlags(pIns);
}
void ReadExtendedInstrumentProperty(ModInstrument* pIns, const uint32 code, FileReader &file)
{
uint16 size = file.ReadUint16LE();
if(!file.CanRead(size))
{
return;
}
ReadInstrumentExtensionField(pIns, code, size, file);
}
void ReadExtendedInstrumentProperties(ModInstrument* pIns, FileReader &file)
{
if(!file.ReadMagic("XTPM")) // 'MPTX'
{
return;
}
while(file.CanRead(7))
{
ReadExtendedInstrumentProperty(pIns, file.ReadUint32LE(), file);
}
}
bool CSoundFile::LoadExtendedInstrumentProperties(FileReader &file)
{
if(!file.ReadMagic("XTPM")) // 'MPTX'
{
return false;
}
while(file.CanRead(6))
{
uint32 code = file.ReadUint32LE();
if(code == MagicBE("MPTS") // Reached song extensions, break out of this loop
|| code == MagicLE("228\x04") // Reached MPTM extensions (in case there are no song extensions)
|| (code & 0x80808080) || !(code & 0x60606060)) // Non-ASCII chunk ID
{
file.SkipBack(4);
break;
}
// Read size of this property for *one* instrument
const uint16 size = file.ReadUint16LE();
for(INSTRUMENTINDEX i = 1; i <= GetNumInstruments(); i++)
{
if(Instruments[i])
{
ReadInstrumentExtensionField(Instruments[i], code, size, file);
}
}
}
return true;
}
OPENMPT_NAMESPACE_END