mirror of https://github.com/AxioDL/amuse.git
684 lines
17 KiB
C++
684 lines
17 KiB
C++
#include "amuse/Sequencer.hpp"
|
|
#include "amuse/Submix.hpp"
|
|
#include "amuse/Voice.hpp"
|
|
#include "amuse/Engine.hpp"
|
|
#include <map>
|
|
|
|
namespace amuse
|
|
{
|
|
|
|
void Sequencer::ChannelState::_bringOutYourDead()
|
|
{
|
|
for (auto it = m_chanVoxs.begin(); it != m_chanVoxs.end();)
|
|
{
|
|
Voice* vox = it->second.get();
|
|
vox->_bringOutYourDead();
|
|
if (vox->_isRecursivelyDead())
|
|
{
|
|
it = m_chanVoxs.erase(it);
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
for (auto it = m_keyoffVoxs.begin(); it != m_keyoffVoxs.end();)
|
|
{
|
|
Voice* vox = it->get();
|
|
vox->_bringOutYourDead();
|
|
if (vox->_isRecursivelyDead())
|
|
{
|
|
it = m_keyoffVoxs.erase(it);
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
}
|
|
|
|
void Sequencer::_bringOutYourDead()
|
|
{
|
|
for (auto& chan : m_chanStates)
|
|
if (chan)
|
|
chan._bringOutYourDead();
|
|
|
|
if (!m_arrData && m_dieOnEnd && getVoiceCount() == 0)
|
|
m_state = SequencerState::Dead;
|
|
}
|
|
|
|
void Sequencer::_destroy()
|
|
{
|
|
Entity::_destroy();
|
|
if (m_studio)
|
|
m_studio.reset();
|
|
}
|
|
|
|
Sequencer::~Sequencer()
|
|
{
|
|
if (m_studio)
|
|
m_studio.reset();
|
|
}
|
|
|
|
Sequencer::Sequencer(Engine& engine, const AudioGroup& group, int groupId, const SongGroupIndex* songGroup, int setupId,
|
|
std::weak_ptr<Studio> studio)
|
|
: Entity(engine, group, groupId), m_songGroup(songGroup), m_studio(studio)
|
|
{
|
|
auto it = m_songGroup->m_midiSetups.find(setupId);
|
|
if (it != m_songGroup->m_midiSetups.cend())
|
|
m_midiSetup = it->second->data();
|
|
}
|
|
|
|
Sequencer::Sequencer(Engine& engine, const AudioGroup& group, int groupId, const SFXGroupIndex* sfxGroup,
|
|
std::weak_ptr<Studio> studio)
|
|
: Entity(engine, group, groupId), m_sfxGroup(sfxGroup), m_studio(studio)
|
|
{
|
|
std::map<uint16_t, const SFXGroupIndex::SFXEntry*> sortSFX;
|
|
for (const auto& sfx : sfxGroup->m_sfxEntries)
|
|
sortSFX[sfx.first] = sfx.second;
|
|
|
|
m_sfxMappings.reserve(sortSFX.size());
|
|
for (const auto& sfx : sortSFX)
|
|
m_sfxMappings.push_back(sfx.second);
|
|
}
|
|
|
|
Sequencer::ChannelState::~ChannelState() {}
|
|
|
|
Sequencer::ChannelState::ChannelState(Sequencer& parent, uint8_t chanId)
|
|
: m_parent(&parent), m_chanId(chanId)
|
|
{
|
|
if (m_parent->m_songGroup)
|
|
{
|
|
if (m_parent->m_midiSetup)
|
|
{
|
|
m_setup = &m_parent->m_midiSetup[chanId];
|
|
|
|
if (chanId == 9)
|
|
{
|
|
auto it = m_parent->m_songGroup->m_drumPages.find(m_setup->programNo);
|
|
if (it != m_parent->m_songGroup->m_drumPages.cend())
|
|
{
|
|
m_page = it->second;
|
|
m_curProgram = m_setup->programNo;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto it = m_parent->m_songGroup->m_normPages.find(m_setup->programNo);
|
|
if (it != m_parent->m_songGroup->m_normPages.cend())
|
|
{
|
|
m_page = it->second;
|
|
m_curProgram = m_setup->programNo;
|
|
}
|
|
}
|
|
|
|
m_curVol = m_setup->volume / 127.f;
|
|
m_curPan = m_setup->panning / 64.f - 1.f;
|
|
m_ctrlVals[0x5b] = m_setup->reverb;
|
|
m_ctrlVals[0x5d] = m_setup->chorus;
|
|
}
|
|
else
|
|
{
|
|
if (chanId == 9)
|
|
{
|
|
auto it = m_parent->m_songGroup->m_drumPages.find(0);
|
|
if (it != m_parent->m_songGroup->m_drumPages.cend())
|
|
m_page = it->second;
|
|
}
|
|
else
|
|
{
|
|
auto it = m_parent->m_songGroup->m_normPages.find(0);
|
|
if (it != m_parent->m_songGroup->m_normPages.cend())
|
|
m_page = it->second;
|
|
}
|
|
|
|
m_curVol = 1.f;
|
|
m_curPan = 0.f;
|
|
m_ctrlVals[0x5b] = 0;
|
|
m_ctrlVals[0x5d] = 0;
|
|
}
|
|
}
|
|
else if (m_parent->m_sfxGroup)
|
|
{
|
|
m_curVol = 1.f;
|
|
m_curPan = 0.f;
|
|
m_ctrlVals[0x5b] = 0;
|
|
m_ctrlVals[0x5d] = 0;
|
|
}
|
|
|
|
m_ctrlVals[7] = 127;
|
|
m_ctrlVals[10] = 64;
|
|
}
|
|
|
|
void Sequencer::advance(double dt)
|
|
{
|
|
if (m_state == SequencerState::Playing)
|
|
{
|
|
if (m_stopFadeTime)
|
|
{
|
|
float step = dt / m_stopFadeTime * m_stopFadeBeginVol;
|
|
float vol = std::max(0.f, m_curVol - step);
|
|
if (vol == 0.f)
|
|
{
|
|
m_arrData = nullptr;
|
|
m_state = SequencerState::Interactive;
|
|
allOff(true);
|
|
m_stopFadeTime = 0.f;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
setVolume(vol);
|
|
}
|
|
}
|
|
else if (m_volFadeTime)
|
|
{
|
|
float step = dt / m_volFadeTime * std::fabs(m_volFadeTarget - m_volFadeStart);
|
|
float vol;
|
|
if (m_curVol < m_volFadeTarget)
|
|
vol = std::min(m_volFadeTarget, m_curVol + step);
|
|
else
|
|
vol = std::max(m_volFadeTarget, m_curVol - step);
|
|
if (vol == m_volFadeTarget)
|
|
m_volFadeTime = 0.f;
|
|
else
|
|
setVolume(vol);
|
|
}
|
|
|
|
if (m_songState.advance(*this, dt))
|
|
{
|
|
m_arrData = nullptr;
|
|
m_state = SequencerState::Interactive;
|
|
allOff();
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t Sequencer::ChannelState::getVoiceCount() const
|
|
{
|
|
size_t ret = 0;
|
|
for (const auto& vox : m_chanVoxs)
|
|
ret += vox.second->getTotalVoices();
|
|
for (const auto& vox : m_keyoffVoxs)
|
|
ret += vox->getTotalVoices();
|
|
return ret;
|
|
}
|
|
|
|
size_t Sequencer::getVoiceCount() const
|
|
{
|
|
size_t ret = 0;
|
|
for (const auto& chan : m_chanStates)
|
|
if (chan)
|
|
ret += chan.getVoiceCount();
|
|
return ret;
|
|
}
|
|
|
|
std::shared_ptr<Voice> Sequencer::ChannelState::keyOn(uint8_t note, uint8_t velocity)
|
|
{
|
|
if (m_parent->m_songGroup && !m_page)
|
|
return {};
|
|
|
|
/* If portamento is enabled for voice, pre-empt spawning new voices */
|
|
if (std::shared_ptr<Voice> lastVoice = m_lastVoice.lock())
|
|
{
|
|
uint8_t lastNote = lastVoice->getLastNote();
|
|
if (lastVoice->doPortamento(note))
|
|
{
|
|
m_chanVoxs.erase(lastNote);
|
|
m_chanVoxs[note] = lastVoice;
|
|
return lastVoice;
|
|
}
|
|
}
|
|
|
|
/* Ensure keyoff sent first */
|
|
auto keySearch = m_chanVoxs.find(note);
|
|
if (keySearch != m_chanVoxs.cend())
|
|
{
|
|
if (keySearch->second == m_lastVoice.lock())
|
|
m_lastVoice.reset();
|
|
keySearch->second->keyOff();
|
|
keySearch->second->setPedal(false);
|
|
m_keyoffVoxs.emplace(std::move(keySearch->second));
|
|
m_chanVoxs.erase(keySearch);
|
|
}
|
|
|
|
std::list<std::shared_ptr<Voice>>::iterator ret = m_parent->m_engine._allocateVoice(
|
|
m_parent->m_audioGroup, m_parent->m_groupId, NativeSampleRate, true, false, m_parent->m_studio);
|
|
if (*ret)
|
|
{
|
|
m_chanVoxs[note] = *ret;
|
|
(*ret)->installCtrlValues(m_ctrlVals);
|
|
|
|
ObjectId oid;
|
|
if (m_parent->m_songGroup)
|
|
oid = (m_parent->m_audioGroup.getDataFormat() == DataFormat::PC) ? m_page->objId : SBig(m_page->objId);
|
|
else if (m_parent->m_sfxMappings.size())
|
|
{
|
|
size_t lookupIdx = note % m_parent->m_sfxMappings.size();
|
|
const SFXGroupIndex::SFXEntry* sfxEntry = m_parent->m_sfxMappings[lookupIdx];
|
|
oid = (m_parent->m_audioGroup.getDataFormat() == DataFormat::PC) ? sfxEntry->objId : SBig(sfxEntry->objId);
|
|
note = sfxEntry->defKey;
|
|
}
|
|
else
|
|
return {};
|
|
|
|
if (!(*ret)->loadSoundObject(oid, 0, m_parent->m_ticksPerSec, note, velocity, m_ctrlVals[1]))
|
|
{
|
|
m_parent->m_engine._destroyVoice(ret);
|
|
return {};
|
|
}
|
|
(*ret)->setVolume(m_parent->m_curVol * m_curVol);
|
|
(*ret)->setReverbVol(m_ctrlVals[0x5b] / 127.f);
|
|
(*ret)->setAuxBVol(m_ctrlVals[0x5d] / 127.f);
|
|
(*ret)->setPan(m_curPan);
|
|
(*ret)->setPitchWheel(m_curPitchWheel);
|
|
|
|
if (m_ctrlVals[64] > 64)
|
|
(*ret)->setPedal(true);
|
|
|
|
m_lastVoice = *ret;
|
|
}
|
|
|
|
return *ret;
|
|
}
|
|
|
|
std::shared_ptr<Voice> Sequencer::keyOn(uint8_t chan, uint8_t note, uint8_t velocity)
|
|
{
|
|
if (chan > 15)
|
|
return {};
|
|
|
|
if (!m_chanStates[chan])
|
|
m_chanStates[chan] = ChannelState(*this, chan);
|
|
|
|
return m_chanStates[chan].keyOn(note, velocity);
|
|
}
|
|
|
|
void Sequencer::ChannelState::keyOff(uint8_t note, uint8_t velocity)
|
|
{
|
|
auto keySearch = m_chanVoxs.find(note);
|
|
if (keySearch == m_chanVoxs.cend())
|
|
return;
|
|
|
|
if (keySearch->second == m_lastVoice.lock())
|
|
m_lastVoice.reset();
|
|
keySearch->second->keyOff();
|
|
m_keyoffVoxs.emplace(std::move(keySearch->second));
|
|
m_chanVoxs.erase(keySearch);
|
|
}
|
|
|
|
void Sequencer::keyOff(uint8_t chan, uint8_t note, uint8_t velocity)
|
|
{
|
|
if (chan > 15 || !m_chanStates[chan])
|
|
return;
|
|
|
|
m_chanStates[chan].keyOff(note, velocity);
|
|
}
|
|
|
|
void Sequencer::ChannelState::setCtrlValue(uint8_t ctrl, int8_t val)
|
|
{
|
|
m_ctrlVals[ctrl] = val;
|
|
for (const auto& vox : m_chanVoxs)
|
|
vox.second->_notifyCtrlChange(ctrl, val);
|
|
for (const auto& vox : m_keyoffVoxs)
|
|
vox->_notifyCtrlChange(ctrl, val);
|
|
|
|
switch (ctrl)
|
|
{
|
|
case 7:
|
|
setVolume(val / 127.f);
|
|
break;
|
|
case 10:
|
|
setPan(val / 64.f - 1.f);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool Sequencer::ChannelState::programChange(int8_t prog)
|
|
{
|
|
if (m_parent->m_songGroup)
|
|
{
|
|
if (m_chanId == 9)
|
|
{
|
|
auto it = m_parent->m_songGroup->m_drumPages.find(prog);
|
|
if (it != m_parent->m_songGroup->m_drumPages.cend())
|
|
{
|
|
m_page = it->second;
|
|
m_curProgram = prog;
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto it = m_parent->m_songGroup->m_normPages.find(prog);
|
|
if (it != m_parent->m_songGroup->m_normPages.cend())
|
|
{
|
|
m_page = it->second;
|
|
m_curProgram = prog;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Sequencer::ChannelState::nextProgram()
|
|
{
|
|
int newProg = m_curProgram;
|
|
while ((newProg += 1) <= 127)
|
|
if (programChange(newProg))
|
|
break;
|
|
}
|
|
|
|
void Sequencer::ChannelState::prevProgram()
|
|
{
|
|
int newProg = m_curProgram;
|
|
while ((newProg -= 1) >= 0)
|
|
if (programChange(newProg))
|
|
break;
|
|
}
|
|
|
|
void Sequencer::setCtrlValue(uint8_t chan, uint8_t ctrl, int8_t val)
|
|
{
|
|
if (chan > 15)
|
|
return;
|
|
|
|
if (ctrl == 0x66)
|
|
{
|
|
printf("Loop Start\n");
|
|
}
|
|
else if (ctrl == 0x67)
|
|
{
|
|
printf("Loop End\n");
|
|
}
|
|
|
|
if (!m_chanStates[chan])
|
|
m_chanStates[chan] = ChannelState(*this, chan);
|
|
|
|
m_chanStates[chan].setCtrlValue(ctrl, val);
|
|
}
|
|
|
|
void Sequencer::ChannelState::setPitchWheel(float pitchWheel)
|
|
{
|
|
m_curPitchWheel = pitchWheel;
|
|
for (const auto& vox : m_chanVoxs)
|
|
vox.second->setPitchWheel(pitchWheel);
|
|
for (const auto& vox : m_keyoffVoxs)
|
|
vox->setPitchWheel(pitchWheel);
|
|
}
|
|
|
|
void Sequencer::setPitchWheel(uint8_t chan, float pitchWheel)
|
|
{
|
|
if (chan > 15)
|
|
return;
|
|
|
|
if (!m_chanStates[chan])
|
|
m_chanStates[chan] = ChannelState(*this, chan);
|
|
|
|
m_chanStates[chan].setPitchWheel(pitchWheel);
|
|
}
|
|
|
|
void Sequencer::setTempo(double ticksPerSec) { m_ticksPerSec = ticksPerSec; }
|
|
|
|
void Sequencer::ChannelState::allOff()
|
|
{
|
|
for (auto it = m_chanVoxs.begin(); it != m_chanVoxs.end();)
|
|
{
|
|
if (it->second == m_lastVoice.lock())
|
|
m_lastVoice.reset();
|
|
it->second->keyOff();
|
|
m_keyoffVoxs.emplace(std::move(it->second));
|
|
it = m_chanVoxs.erase(it);
|
|
}
|
|
}
|
|
|
|
void Sequencer::allOff(bool now)
|
|
{
|
|
if (now)
|
|
for (auto& chan : m_chanStates)
|
|
{
|
|
if (chan)
|
|
{
|
|
for (const auto& vox : chan.m_chanVoxs)
|
|
vox.second->kill();
|
|
for (const auto& vox : chan.m_keyoffVoxs)
|
|
vox->kill();
|
|
chan.m_chanVoxs.clear();
|
|
chan.m_keyoffVoxs.clear();
|
|
}
|
|
}
|
|
else
|
|
for (auto& chan : m_chanStates)
|
|
if (chan)
|
|
chan.allOff();
|
|
}
|
|
|
|
void Sequencer::allOff(uint8_t chan, bool now)
|
|
{
|
|
if (chan > 15 || !m_chanStates[chan])
|
|
return;
|
|
|
|
if (now)
|
|
{
|
|
for (const auto& vox : m_chanStates[chan].m_chanVoxs)
|
|
vox.second->kill();
|
|
for (const auto& vox : m_chanStates[chan].m_keyoffVoxs)
|
|
vox->kill();
|
|
m_chanStates[chan].m_chanVoxs.clear();
|
|
m_chanStates[chan].m_keyoffVoxs.clear();
|
|
}
|
|
else
|
|
m_chanStates[chan].allOff();
|
|
}
|
|
|
|
void Sequencer::ChannelState::killKeygroup(uint8_t kg, bool now)
|
|
{
|
|
for (auto it = m_chanVoxs.begin(); it != m_chanVoxs.end();)
|
|
{
|
|
Voice* vox = it->second.get();
|
|
if (vox->m_keygroup == kg)
|
|
{
|
|
if (it->second == m_lastVoice.lock())
|
|
m_lastVoice.reset();
|
|
if (now)
|
|
{
|
|
it = m_chanVoxs.erase(it);
|
|
continue;
|
|
}
|
|
vox->keyOff();
|
|
m_keyoffVoxs.emplace(std::move(it->second));
|
|
it = m_chanVoxs.erase(it);
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
if (now)
|
|
{
|
|
for (auto it = m_keyoffVoxs.begin(); it != m_keyoffVoxs.end();)
|
|
{
|
|
Voice* vox = it->get();
|
|
if (vox->m_keygroup == kg)
|
|
{
|
|
it = m_keyoffVoxs.erase(it);
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Sequencer::killKeygroup(uint8_t kg, bool now)
|
|
{
|
|
for (auto& chan : m_chanStates)
|
|
if (chan)
|
|
chan.killKeygroup(kg, now);
|
|
}
|
|
|
|
std::shared_ptr<Voice> Sequencer::ChannelState::findVoice(int vid)
|
|
{
|
|
for (const auto& vox : m_chanVoxs)
|
|
if (vox.second->vid() == vid)
|
|
return vox.second;
|
|
for (const auto& vox : m_keyoffVoxs)
|
|
if (vox->vid() == vid)
|
|
return vox;
|
|
return {};
|
|
}
|
|
|
|
std::shared_ptr<Voice> Sequencer::findVoice(int vid)
|
|
{
|
|
for (auto& chan : m_chanStates)
|
|
{
|
|
if (chan)
|
|
{
|
|
std::shared_ptr<Voice> ret = chan.findVoice(vid);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void Sequencer::ChannelState::sendMacroMessage(ObjectId macroId, int32_t val)
|
|
{
|
|
for (const auto& v : m_chanVoxs)
|
|
{
|
|
Voice* vox = v.second.get();
|
|
if (vox->getObjectId() == macroId)
|
|
vox->message(val);
|
|
}
|
|
for (const auto& v : m_keyoffVoxs)
|
|
{
|
|
Voice* vox = v.get();
|
|
if (vox->getObjectId() == macroId)
|
|
vox->message(val);
|
|
}
|
|
}
|
|
|
|
void Sequencer::sendMacroMessage(ObjectId macroId, int32_t val)
|
|
{
|
|
for (auto& chan : m_chanStates)
|
|
if (chan)
|
|
chan.sendMacroMessage(macroId, val);
|
|
}
|
|
|
|
void Sequencer::playSong(const unsigned char* arrData, bool dieOnEnd)
|
|
{
|
|
m_arrData = arrData;
|
|
m_dieOnEnd = dieOnEnd;
|
|
m_songState.initialize(arrData);
|
|
setTempo(m_songState.getTempo() * 384 / 60);
|
|
m_state = SequencerState::Playing;
|
|
}
|
|
|
|
void Sequencer::stopSong(float fadeTime, bool now)
|
|
{
|
|
if (fadeTime == 0.f)
|
|
{
|
|
allOff(now);
|
|
m_arrData = nullptr;
|
|
m_state = SequencerState::Interactive;
|
|
}
|
|
else
|
|
{
|
|
m_stopFadeTime = fadeTime;
|
|
m_stopFadeBeginVol = m_curVol;
|
|
}
|
|
}
|
|
|
|
void Sequencer::ChannelState::setVolume(float vol)
|
|
{
|
|
m_curVol = vol;
|
|
float voxVol = m_parent->m_curVol * m_curVol;
|
|
for (const auto& v : m_chanVoxs)
|
|
{
|
|
Voice* vox = v.second.get();
|
|
vox->setVolume(voxVol);
|
|
}
|
|
for (const auto& v : m_keyoffVoxs)
|
|
{
|
|
Voice* vox = v.get();
|
|
vox->setVolume(voxVol);
|
|
}
|
|
}
|
|
|
|
void Sequencer::ChannelState::setPan(float pan)
|
|
{
|
|
m_curPan = pan;
|
|
for (const auto& v : m_chanVoxs)
|
|
{
|
|
Voice* vox = v.second.get();
|
|
vox->setPan(m_curPan);
|
|
}
|
|
for (const auto& v : m_keyoffVoxs)
|
|
{
|
|
Voice* vox = v.get();
|
|
vox->setPan(m_curPan);
|
|
}
|
|
}
|
|
|
|
void Sequencer::setVolume(float vol, float fadeTime)
|
|
{
|
|
if (fadeTime == 0.f)
|
|
{
|
|
m_curVol = vol;
|
|
for (auto& chan : m_chanStates)
|
|
if (chan)
|
|
chan.setVolume(chan.m_curVol);
|
|
}
|
|
else
|
|
{
|
|
m_volFadeTime = fadeTime;
|
|
m_volFadeTarget = vol;
|
|
m_volFadeStart = m_curVol;
|
|
}
|
|
}
|
|
|
|
int8_t Sequencer::getChanProgram(int8_t chanId) const
|
|
{
|
|
if (chanId > 15)
|
|
return 0;
|
|
|
|
if (!m_chanStates[chanId])
|
|
{
|
|
if (!m_midiSetup)
|
|
return 0;
|
|
return m_midiSetup[chanId].programNo;
|
|
}
|
|
|
|
return m_chanStates[chanId].m_curProgram;
|
|
}
|
|
|
|
bool Sequencer::setChanProgram(int8_t chanId, int8_t prog)
|
|
{
|
|
if (chanId > 15)
|
|
return false;
|
|
|
|
if (!m_chanStates[chanId])
|
|
m_chanStates[chanId] = ChannelState(*this, chanId);
|
|
|
|
return m_chanStates[chanId].programChange(prog);
|
|
}
|
|
|
|
void Sequencer::nextChanProgram(int8_t chanId)
|
|
{
|
|
if (chanId > 15)
|
|
return;
|
|
|
|
if (!m_chanStates[chanId])
|
|
m_chanStates[chanId] = ChannelState(*this, chanId);
|
|
|
|
return m_chanStates[chanId].nextProgram();
|
|
}
|
|
|
|
void Sequencer::prevChanProgram(int8_t chanId)
|
|
{
|
|
if (chanId > 15)
|
|
return;
|
|
|
|
if (!m_chanStates[chanId])
|
|
m_chanStates[chanId] = ChannelState(*this, chanId);
|
|
|
|
return m_chanStates[chanId].prevProgram();
|
|
}
|
|
}
|