winamp/Src/external_dependencies/openmpt-trunk/soundlib/tuning.h

253 lines
7.5 KiB
C
Raw Normal View History

2024-09-24 12:54:57 +00:00
/*
* tuning.h
* --------
* Purpose: Alternative sample tuning.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#pragma once
#include "openmpt/all/BuildSettings.hpp"
#include <map>
#include "tuningbase.h"
OPENMPT_NAMESPACE_BEGIN
namespace Tuning {
class CTuning
{
public:
static constexpr char s_FileExtension[5] = ".tun";
static constexpr RATIOTYPE s_DefaultFallbackRatio = 1.0f;
static constexpr NOTEINDEXTYPE s_NoteMinDefault = -64;
static constexpr UNOTEINDEXTYPE s_RatioTableSizeDefault = 128;
static constexpr USTEPINDEXTYPE s_RatioTableFineSizeMaxDefault = 1000;
public:
// To return ratio of certain note.
RATIOTYPE GetRatio(const NOTEINDEXTYPE note) const;
// To return ratio from a 'step'(noteindex + stepindex)
RATIOTYPE GetRatio(const NOTEINDEXTYPE baseNote, const STEPINDEXTYPE baseFineSteps) const;
//Tuning might not be valid for arbitrarily large range,
//so this can be used to ask where it is valid. Tells the lowest and highest
//note that are valid.
MPT_FORCEINLINE NoteRange GetNoteRange() const
{
return NoteRange{m_NoteMin, static_cast<NOTEINDEXTYPE>(m_NoteMin + static_cast<NOTEINDEXTYPE>(m_RatioTable.size()) - 1)};
}
// Return true if note is within note range
MPT_FORCEINLINE bool IsValidNote(const NOTEINDEXTYPE n) const
{
return (GetNoteRange().first <= n && n <= GetNoteRange().last);
}
MPT_FORCEINLINE UNOTEINDEXTYPE GetGroupSize() const
{
return m_GroupSize;
}
RATIOTYPE GetGroupRatio() const {return m_GroupRatio;}
// To return (fine)stepcount between two consecutive mainsteps.
MPT_FORCEINLINE USTEPINDEXTYPE GetFineStepCount() const
{
return m_FineStepCount;
}
//To return 'directed distance' between given notes.
STEPINDEXTYPE GetStepDistance(const NOTEINDEXTYPE& from, const NOTEINDEXTYPE& to) const
{return (to - from)*(static_cast<NOTEINDEXTYPE>(GetFineStepCount())+1);}
//To return 'directed distance' between given steps.
STEPINDEXTYPE GetStepDistance(const NOTEINDEXTYPE& noteFrom, const STEPINDEXTYPE& stepDistFrom, const NOTEINDEXTYPE& noteTo, const STEPINDEXTYPE& stepDistTo) const
{return GetStepDistance(noteFrom, noteTo) + stepDistTo - stepDistFrom;}
//To set finestepcount between two consecutive mainsteps.
//Finestep count == 0 means that
//stepdistances become the same as note distances.
void SetFineStepCount(const USTEPINDEXTYPE& fs);
// Multiply all ratios by given number.
bool Multiply(const RATIOTYPE r);
bool SetRatio(const NOTEINDEXTYPE& s, const RATIOTYPE& r);
MPT_FORCEINLINE Tuning::Type GetType() const
{
return m_TuningType;
}
mpt::ustring GetNoteName(const NOTEINDEXTYPE &x, bool addOctave = true) const;
void SetNoteName(const NOTEINDEXTYPE &, const mpt::ustring &);
static std::unique_ptr<CTuning> CreateDeserialize(std::istream &f, mpt::Charset defaultCharset)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
if(pT->InitDeserialize(f, defaultCharset) != SerializationResult::Success)
{
return nullptr;
}
return pT;
}
//Try to read old version (v.3) and return pointer to new instance if succesfull, else nullptr.
static std::unique_ptr<CTuning> CreateDeserializeOLD(std::istream &f, mpt::Charset defaultCharset)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
if(pT->InitDeserializeOLD(f, defaultCharset) != SerializationResult::Success)
{
return nullptr;
}
return pT;
}
static std::unique_ptr<CTuning> CreateGeneral(const mpt::ustring &name)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
pT->SetName(name);
return pT;
}
static std::unique_ptr<CTuning> CreateGroupGeometric(const mpt::ustring &name, UNOTEINDEXTYPE groupsize, RATIOTYPE groupratio, USTEPINDEXTYPE finestepcount)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
pT->SetName(name);
if(!pT->CreateGroupGeometric(groupsize, groupratio, 0))
{
return nullptr;
}
pT->SetFineStepCount(finestepcount);
return pT;
}
static std::unique_ptr<CTuning> CreateGroupGeometric(const mpt::ustring &name, const std::vector<RATIOTYPE> &ratios, RATIOTYPE groupratio, USTEPINDEXTYPE finestepcount)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
pT->SetName(name);
NoteRange range = NoteRange{s_NoteMinDefault, static_cast<NOTEINDEXTYPE>(s_NoteMinDefault + s_RatioTableSizeDefault - 1)};
range.last = std::max(range.last, mpt::saturate_cast<NOTEINDEXTYPE>(ratios.size() - 1));
range.first = 0 - range.last - 1;
if(!pT->CreateGroupGeometric(ratios, groupratio, range, 0))
{
return nullptr;
}
pT->SetFineStepCount(finestepcount);
return pT;
}
static std::unique_ptr<CTuning> CreateGeometric(const mpt::ustring &name, UNOTEINDEXTYPE groupsize, RATIOTYPE groupratio, USTEPINDEXTYPE finestepcount)
{
std::unique_ptr<CTuning> pT = std::unique_ptr<CTuning>(new CTuning());
pT->SetName(name);
if(!pT->CreateGeometric(groupsize, groupratio))
{
return nullptr;
}
pT->SetFineStepCount(finestepcount);
return pT;
}
Tuning::SerializationResult Serialize(std::ostream& out) const;
#ifdef MODPLUG_TRACKER
bool WriteSCL(std::ostream &f, const mpt::PathString &filename) const;
#endif
bool ChangeGroupsize(const NOTEINDEXTYPE&);
bool ChangeGroupRatio(const RATIOTYPE&);
void SetName(const mpt::ustring &s)
{
m_TuningName = s;
}
mpt::ustring GetName() const
{
return m_TuningName;
}
private:
CTuning();
SerializationResult InitDeserialize(std::istream &inStrm, mpt::Charset defaultCharset);
//Try to read old version (v.3) and return pointer to new instance if succesfull, else nullptr.
SerializationResult InitDeserializeOLD(std::istream &inStrm, mpt::Charset defaultCharset);
//Create GroupGeometric tuning of *this using virtual ProCreateGroupGeometric.
bool CreateGroupGeometric(const std::vector<RATIOTYPE> &v, const RATIOTYPE &r, const NoteRange &range, const NOTEINDEXTYPE &ratiostartpos);
//Create GroupGeometric of *this using ratios from 'itself' and ratios starting from
//position given as third argument.
bool CreateGroupGeometric(const NOTEINDEXTYPE &s, const RATIOTYPE &r, const NOTEINDEXTYPE &startindex);
//Create geometric tuning of *this using ratio(0) = 1.
bool CreateGeometric(const UNOTEINDEXTYPE &p, const RATIOTYPE &r);
bool CreateGeometric(const UNOTEINDEXTYPE &s, const RATIOTYPE &r, const NoteRange &range);
void UpdateFineStepTable();
// GroupPeriodic-specific.
// Get the corresponding note in [0, period-1].
// For example GetRefNote(-1) is to return note :'groupsize-1'.
MPT_FORCEINLINE NOTEINDEXTYPE GetRefNote(NOTEINDEXTYPE note) const
{
MPT_ASSERT(GetType() == Type::GROUPGEOMETRIC || GetType() == Type::GEOMETRIC);
return static_cast<NOTEINDEXTYPE>(mpt::wrapping_modulo(note, GetGroupSize()));
}
static bool IsValidRatio(RATIOTYPE ratio)
{
return (ratio > static_cast<RATIOTYPE>(0.0));
}
private:
Tuning::Type m_TuningType;
//Noteratios
std::vector<RATIOTYPE> m_RatioTable;
//'Fineratios'
std::vector<RATIOTYPE> m_RatioTableFine;
// The lowest index of note in the table
NOTEINDEXTYPE m_NoteMin;
//For groupgeometric tunings, tells the 'group size' and 'group ratio'
//m_GroupSize should always be >= 0.
NOTEINDEXTYPE m_GroupSize;
RATIOTYPE m_GroupRatio;
USTEPINDEXTYPE m_FineStepCount; // invariant: 0 <= m_FineStepCount <= FINESTEPCOUNT_MAX
mpt::ustring m_TuningName;
std::map<NOTEINDEXTYPE, mpt::ustring> m_NoteNameMap;
}; // class CTuning
} // namespace Tuning
OPENMPT_NAMESPACE_END