winamp/Src/external_dependencies/openmpt-trunk/soundlib/OPL.cpp

346 lines
8.7 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
/*
* OPL.cpp
* -------
* Purpose: Translate data coming from OpenMPT's mixer into OPL commands to be sent to the Opal emulator.
* Notes : (currently none)
* Authors: OpenMPT Devs
* Schism Tracker contributors (bisqwit, JosepMa, Malvineous, code relicensed from GPL to BSD with permission)
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "../common/misc_util.h"
#include "OPL.h"
#include "opal.h"
OPENMPT_NAMESPACE_BEGIN
OPL::OPL(uint32 samplerate)
{
Initialize(samplerate);
}
OPL::OPL(IRegisterLogger &logger)
: m_logger{&logger}
{
Initialize(OPL_BASERATE);
}
OPL::~OPL()
{
// This destructor is put here so that we can forward-declare the Opal emulator class.
}
void OPL::Initialize(uint32 samplerate)
{
if(m_opl == nullptr)
m_opl = std::make_unique<Opal>(samplerate);
else
m_opl->SetSampleRate(samplerate);
Reset();
}
void OPL::Mix(int32 *target, size_t count, uint32 volumeFactorQ16)
{
if(!m_isActive)
return;
// This factor causes a sample voice to be more or less as loud as an OPL voice
const int32 factor = Util::muldiv_unsigned(volumeFactorQ16, 6169, (1 << 16));
while(count--)
{
int16 l, r;
m_opl->Sample(&l, &r);
target[0] += l * factor;
target[1] += r * factor;
target += 2;
}
}
uint16 OPL::ChannelToRegister(uint8 oplCh)
{
if(oplCh < 9)
return oplCh;
else
return (oplCh - 9) | 0x100;
}
// Translate a channel's first operator address into a register
uint16 OPL::OperatorToRegister(uint8 oplCh)
{
static constexpr uint8 OPLChannelToOperator[] = { 0, 1, 2, 8, 9, 10, 16, 17, 18 };
if(oplCh < 9)
return OPLChannelToOperator[oplCh];
else
return OPLChannelToOperator[oplCh - 9] | 0x100;
}
uint8 OPL::GetVoice(CHANNELINDEX c) const
{
if((m_ChanToOPL[c] & OPL_CHANNEL_CUT) || m_ChanToOPL[c] == OPL_CHANNEL_INVALID)
return OPL_CHANNEL_INVALID;
return m_ChanToOPL[c] & OPL_CHANNEL_MASK;
}
uint8 OPL::AllocateVoice(CHANNELINDEX c)
{
// Can we re-use a previous channel?
if(auto oplCh = m_ChanToOPL[c]; oplCh != OPL_CHANNEL_INVALID)
{
if(!(m_ChanToOPL[c] & OPL_CHANNEL_CUT))
return oplCh;
// Check re-use hint
oplCh &= OPL_CHANNEL_MASK;
if(m_OPLtoChan[oplCh] == CHANNELINDEX_INVALID || m_OPLtoChan[oplCh] == c)
{
m_OPLtoChan[oplCh] = c;
m_ChanToOPL[c] = oplCh;
return oplCh;
}
}
// Search for unused channel or channel with released note
uint8 releasedChn = OPL_CHANNEL_INVALID, releasedCutChn = OPL_CHANNEL_INVALID;
for(uint8 oplCh = 0; oplCh < OPL_CHANNELS; oplCh++)
{
if(m_OPLtoChan[oplCh] == CHANNELINDEX_INVALID)
{
m_OPLtoChan[oplCh] = c;
m_ChanToOPL[c] = oplCh;
return oplCh;
} else if(!(m_KeyOnBlock[oplCh] & KEYON_BIT))
{
releasedChn = oplCh;
if(m_ChanToOPL[m_OPLtoChan[oplCh]] & OPL_CHANNEL_CUT)
releasedCutChn = oplCh;
}
}
if(releasedChn != OPL_CHANNEL_INVALID)
{
// Prefer channel that has been marked as cut over channel that has just been released
if(releasedCutChn != OPL_CHANNEL_INVALID)
releasedChn = releasedCutChn;
m_ChanToOPL[m_OPLtoChan[releasedChn]] = OPL_CHANNEL_INVALID;
m_OPLtoChan[releasedChn] = c;
m_ChanToOPL[c] = releasedChn;
}
return GetVoice(c);
}
void OPL::MoveChannel(CHANNELINDEX from, CHANNELINDEX to)
{
uint8 oplCh = GetVoice(from);
if(oplCh == OPL_CHANNEL_INVALID)
return;
m_OPLtoChan[oplCh] = to;
m_ChanToOPL[from] = OPL_CHANNEL_INVALID;
m_ChanToOPL[to] = oplCh;
}
void OPL::NoteOff(CHANNELINDEX c)
{
uint8 oplCh = GetVoice(c);
if(oplCh == OPL_CHANNEL_INVALID || m_opl == nullptr)
return;
m_KeyOnBlock[oplCh] &= ~KEYON_BIT;
Port(c, KEYON_BLOCK | ChannelToRegister(oplCh), m_KeyOnBlock[oplCh]);
}
void OPL::NoteCut(CHANNELINDEX c, bool unassign)
{
uint8 oplCh = GetVoice(c);
if(oplCh == OPL_CHANNEL_INVALID)
return;
NoteOff(c);
Volume(c, 0, false); // Note that a volume of 0 is not complete silence; the release portion of the sound will still be heard at -48dB
if(unassign)
{
m_OPLtoChan[oplCh] = CHANNELINDEX_INVALID;
m_ChanToOPL[c] |= OPL_CHANNEL_CUT;
}
}
void OPL::Frequency(CHANNELINDEX c, uint32 milliHertz, bool keyOff, bool beatingOscillators)
{
uint8 oplCh = GetVoice(c);
if(oplCh == OPL_CHANNEL_INVALID || m_opl == nullptr)
return;
uint16 fnum = 1023;
uint8 block = 7;
if(milliHertz <= 6208431)
{
if(milliHertz > 3104215) block = 7;
else if(milliHertz > 1552107) block = 6;
else if(milliHertz > 776053) block = 5;
else if(milliHertz > 388026) block = 4;
else if(milliHertz > 194013) block = 3;
else if(milliHertz > 97006) block = 2;
else if(milliHertz > 48503) block = 1;
else block = 0;
fnum = static_cast<uint16>(Util::muldivr_unsigned(milliHertz, 1 << (20 - block), OPL_BASERATE * 1000));
MPT_ASSERT(fnum < 1024);
}
// Evil CDFM hack! Composer 670 slightly detunes each note based on the OPL channel number modulo 4.
// We allocate our OPL channels dynamically, which would result in slightly different beating characteristics,
// but we can just take the pattern channel number instead, as the pattern channel layout is always identical.
if(beatingOscillators)
fnum = std::min(static_cast<uint16>(fnum + (c & 3)), uint16(1023));
fnum |= (block << 10);
uint16 channel = ChannelToRegister(oplCh);
m_KeyOnBlock[oplCh] = (keyOff ? 0 : KEYON_BIT) | (fnum >> 8); // Key on bit + Octave (block) + F-number high 2 bits
Port(c, FNUM_LOW | channel, fnum & 0xFF); // F-Number low 8 bits
Port(c, KEYON_BLOCK | channel, m_KeyOnBlock[oplCh]);
m_isActive = true;
}
uint8 OPL::CalcVolume(uint8 trackerVol, uint8 kslVolume)
{
if(trackerVol >= 63u)
return kslVolume;
if(trackerVol > 0)
trackerVol++;
return (kslVolume & KSL_MASK) | (63u - ((63u - (kslVolume & TOTAL_LEVEL_MASK)) * trackerVol) / 64u);
}
void OPL::Volume(CHANNELINDEX c, uint8 vol, bool applyToModulator)
{
uint8 oplCh = GetVoice(c);
if(oplCh == OPL_CHANNEL_INVALID || m_opl == nullptr)
return;
const auto &patch = m_Patches[oplCh];
const uint16 modulator = OperatorToRegister(oplCh), carrier = modulator + 3;
if((patch[10] & CONNECTION_BIT) || applyToModulator)
{
// Set volume of both operators in additive mode
Port(c, KSL_LEVEL + modulator, CalcVolume(vol, patch[2]));
}
if(!applyToModulator)
{
Port(c, KSL_LEVEL + carrier, CalcVolume(vol, patch[3]));
}
}
int8 OPL::Pan(CHANNELINDEX c, int32 pan)
{
uint8 oplCh = GetVoice(c);
if(oplCh == OPL_CHANNEL_INVALID || m_opl == nullptr)
return 0;
const auto &patch = m_Patches[oplCh];
uint8 fbConn = patch[10] & ~STEREO_BITS;
// OPL3 only knows hard left, center and right, so we need to translate our
// continuous panning range into one of those three states.
// 0...84 = left, 85...170 = center, 171...256 = right
if(pan <= 170)
fbConn |= VOICE_TO_LEFT;
if(pan >= 85)
fbConn |= VOICE_TO_RIGHT;
Port(c, FEEDBACK_CONNECTION | ChannelToRegister(oplCh), fbConn);
return ((fbConn & VOICE_TO_LEFT) ? -1 : 0) + ((fbConn & VOICE_TO_RIGHT) ? 1 : 0);
}
void OPL::Patch(CHANNELINDEX c, const OPLPatch &patch)
{
uint8 oplCh = AllocateVoice(c);
if(oplCh == OPL_CHANNEL_INVALID || m_opl == nullptr)
return;
m_Patches[oplCh] = patch;
const uint16 modulator = OperatorToRegister(oplCh), carrier = modulator + 3;
for(uint8 op = 0; op < 2; op++)
{
const auto opReg = op ? carrier : modulator;
Port(c, AM_VIB | opReg, patch[0 + op]);
Port(c, KSL_LEVEL | opReg, patch[2 + op]);
Port(c, ATTACK_DECAY | opReg, patch[4 + op]);
Port(c, SUSTAIN_RELEASE | opReg, patch[6 + op]);
Port(c, WAVE_SELECT | opReg, patch[8 + op]);
}
Port(c, FEEDBACK_CONNECTION | ChannelToRegister(oplCh), patch[10]);
}
void OPL::Reset()
{
if(m_isActive)
{
for(CHANNELINDEX chn = 0; chn < MAX_CHANNELS; chn++)
{
NoteCut(chn);
}
m_isActive = false;
}
m_KeyOnBlock.fill(0);
m_OPLtoChan.fill(CHANNELINDEX_INVALID);
m_ChanToOPL.fill(OPL_CHANNEL_INVALID);
Port(CHANNELINDEX_INVALID, 0x105, 1); // Enable OPL3
Port(CHANNELINDEX_INVALID, 0x104, 0); // No 4-op voices
}
void OPL::Port(CHANNELINDEX c, uint16 reg, uint8 value)
{
if(!m_logger)
m_opl->Port(reg, value);
else
m_logger->Port(c, reg, value);
}
std::vector<uint16> OPL::AllVoiceRegisters()
{
static constexpr uint8 opRegisters[] = {OPL::AM_VIB, OPL::KSL_LEVEL, OPL::ATTACK_DECAY, OPL::SUSTAIN_RELEASE, OPL::WAVE_SELECT};
static constexpr uint8 chnRegisters[] = {OPL::FNUM_LOW, OPL::KEYON_BLOCK, OPL::FEEDBACK_CONNECTION};
std::vector<uint16> result;
result.reserve(234);
for(uint16 chip = 0; chip < 2; chip++)
{
for(uint8 opReg : opRegisters)
{
for(uint8 op = 0; op < 22; op++)
{
if((op & 7) < 6)
result.push_back((chip << 8) | opReg | op);
}
}
for(uint8 chnReg : chnRegisters)
{
for(uint8 chn = 0; chn < 9; chn++)
{
result.push_back((chip << 8) | chnReg | chn);
}
}
}
return result;
}
OPENMPT_NAMESPACE_END