Working SongGroup player, DLS envelopes

This commit is contained in:
Jack Andersen 2016-05-16 10:20:29 -10:00
parent 44bb7a155b
commit e9213ab179
12 changed files with 371 additions and 111 deletions

View File

@ -143,10 +143,7 @@ public:
m_tracking = true;
}
void mouseUp(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey)
{
m_tracking = false;
}
void mouseUp(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey);
void mouseMove(const boo::SWindowCoord& coord);
@ -188,15 +185,20 @@ struct AppCallback : boo::IApplicationCallback
bool m_running = true;
bool m_wantsNext = false;
bool m_wantsPrev = false;
int m_panicCount = 0;
void UpdateSongDisplay()
{
size_t voxCount = 0;
int program = 0;
if (m_seq)
{
voxCount = m_seq->getVoiceCount();
program = m_seq->getChanProgram(m_chanId);
}
printf("\r "
"\r %" PRISize " Setup %d, Chan %d, Octave: %d, Vel: %d, VOL: %d%%\r", voxCount,
m_setupId, m_chanId, m_octave, m_velocity, int(std::rint(m_volume * 100)));
"\r %" PRISize " Setup %d, Chan %d, Prog %d, Octave: %d, Vel: %d, VOL: %d%%\r", voxCount,
m_setupId, m_chanId, program, m_octave, m_velocity, int(std::rint(m_volume * 100)));
fflush(stdout);
}
@ -219,9 +221,9 @@ struct AppCallback : boo::IApplicationCallback
"░░░ │ │ ┃ │ │ │ ┃ │ │ ░░░\n"
"░░░ A │ S │ D ┃ F │ G │ H │ J ┃ K │ L │ ; ░░░\n"
"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n"
"<left/right>: cycle MIDI setup / channel, <up/down>: volume\n"
"<left/right>: cycle MIDI setup / channel, <up/down>: volume, <space>: PANIC\n"
"<tab>: sustain pedal, <window-Y>: pitch wheel, <window-X>: mod wheel\n"
"<Z/X>: octave, <C/V>: velocity, <Q>: quit\n");
"<Z/X>: octave, <C/V>: velocity, <B/N>: channel, <,/.>: program, <Q>: quit\n");
std::map<int, const std::array<amuse::SongGroupIndex::MIDISetup, 16>*> sortEntries
(index.m_midiSetups.cbegin(), index.m_midiSetups.cend());
@ -257,6 +259,18 @@ struct AppCallback : boo::IApplicationCallback
}
}
if (m_seq && m_panicCount)
{
if (m_panicCount > 1)
{
m_seq->allOff(true);
m_panicCount = 0;
}
else
m_seq->allOff(false);
m_updateDisp = true;
}
if (m_updateDisp)
{
m_updateDisp = false;
@ -355,6 +369,8 @@ struct AppCallback : boo::IApplicationCallback
void charKeyDownRepeat(unsigned long charCode)
{
charCode = tolower(charCode);
if (m_seq && m_chanId != -1)
{
switch (charCode)
@ -375,6 +391,22 @@ struct AppCallback : boo::IApplicationCallback
m_velocity = amuse::clamp(0, m_velocity + 1, 127);
m_updateDisp = true;
break;
case 'b':
m_chanId = amuse::clamp(0, m_chanId - 1, 15);
m_updateDisp = true;
break;
case 'n':
m_chanId = amuse::clamp(0, m_chanId + 1, 15);
m_updateDisp = true;
break;
case ',':
m_seq->prevChanProgram(m_chanId);
m_updateDisp = true;
break;
case '.':
m_seq->nextChanProgram(m_chanId);
m_updateDisp = true;
break;
}
}
}
@ -403,8 +435,14 @@ struct AppCallback : boo::IApplicationCallback
}
else if (m_seq && m_chanId != -1)
{
bool setPanic = false;
switch (charCode)
{
case ' ':
++m_panicCount;
setPanic = true;
break;
case 'z':
m_octave = amuse::clamp(-1, m_octave - 1, 8);
m_updateDisp = true;
@ -421,6 +459,22 @@ struct AppCallback : boo::IApplicationCallback
m_velocity = amuse::clamp(0, m_velocity + 1, 127);
m_updateDisp = true;
break;
case 'b':
m_chanId = amuse::clamp(0, m_chanId - 1, 15);
m_updateDisp = true;
break;
case 'n':
m_chanId = amuse::clamp(0, m_chanId + 1, 15);
m_updateDisp = true;
break;
case ',':
m_seq->prevChanProgram(m_chanId);
m_updateDisp = true;
break;
case '.':
m_seq->nextChanProgram(m_chanId);
m_updateDisp = true;
break;
case '\t':
m_seq->setCtrlValue(m_chanId, 64, 127);
break;
@ -478,6 +532,9 @@ struct AppCallback : boo::IApplicationCallback
break;
default: break;
}
if (!setPanic)
m_panicCount = 0;
}
}
@ -713,6 +770,14 @@ void EventCallback::specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods)
{
}
void EventCallback::mouseUp(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey)
{
m_tracking = false;
m_app.m_pitchBend = 0.f;
if (m_app.m_seq && m_app.m_chanId != -1)
m_app.m_seq->setPitchWheel(m_app.m_chanId, m_app.m_pitchBend);
}
void EventCallback::mouseMove(const boo::SWindowCoord& coord)
{
if (m_tracking)

View File

@ -5,10 +5,19 @@
#include <vector>
#include <unordered_map>
#include "Entity.hpp"
#include "Common.hpp"
namespace amuse
{
/** Converts time-cents representation to seconds */
static inline double TimeCentsToSeconds(int32_t tc)
{
if (tc == 0x80000000)
return 0.0;
return std::exp2(tc / (1200.0 * 65536.0));
}
/** Defines phase-based volume curve for macro volume control */
struct ADSR
{
@ -20,6 +29,39 @@ struct ADSR
uint8_t sustainCoarse; /* multiply by 6.25 for percentage */
uint8_t releaseFine; /* 0-255ms */
uint8_t releaseCoarse; /* 0-65280ms */
double getAttack() const {return (attackCoarse * 255 + attackFine) / 1000.0;}
double getDecay() const {return decayCoarse == 128 ? 0.0 : ((decayCoarse * 255 + decayFine) / 1000.0);}
double getSustain() const {return decayCoarse == 128 ? 1.0 : ((sustainCoarse * 6.25 + sustainFine * 0.0244) / 100.0);}
double getRelease() const {return (releaseCoarse * 255 + releaseFine) / 1000.0;}
};
/** Defines phase-based volume curve for macro volume control (modified DLS standard) */
struct ADSRDLS
{
uint32_t attack; /* 16.16 Time-cents */
uint32_t decay; /* 16.16 Time-cents */
uint16_t sustain; /* 0x1000 == 100% */
uint16_t release; /* milliseconds */
uint32_t velToAttack; /* 16.16, 1000.0 == 100%; attack = <attack> + (vel/128) * <velToAttack> */
uint32_t keyToDecay; /* 16.16, 1000.0 == 100%; decay = <decay> + (note/128) * <keyToDecay> */
double getAttack() const {return TimeCentsToSeconds(attack);}
double getDecay() const {return TimeCentsToSeconds(decay);}
double getSustain() const {return sustain / double(0x1000);}
double getRelease() const {return release / double(1000);}
double getVelToAttack(int8_t vel) const
{
if (velToAttack == 0x80000000)
return getAttack();
return getAttack() + vel * (velToAttack / 65536.0 / 1000.0) / 128.0;
}
double getKeyToDecay(int8_t note) const
{
if (keyToDecay == 0x80000000)
return getDecay();
return getDecay() + note * (keyToDecay / 65536.0 / 1000.0) / 128.0;
}
};
/** Maps individual MIDI keys to sound-entity as indexed in table
@ -59,6 +101,8 @@ public:
const Keymap* keymap(ObjectId id) const;
const std::vector<const LayerMapping*>* layer(ObjectId id) const;
const ADSR* tableAsAdsr(ObjectId id) const;
const ADSRDLS* tableAsAdsrDLS(ObjectId id) const
{return reinterpret_cast<const ADSRDLS*>(tableAsAdsr(id));}
const Curve* tableAsCurves(ObjectId id) const
{return reinterpret_cast<const Curve*>(tableAsAdsr(id));}
};

View File

@ -24,6 +24,7 @@ class Engine
{
friend class Voice;
friend class Emitter;
friend class Sequencer;
friend class Sequencer::ChannelState;
IBackendVoiceAllocator& m_backend;
@ -32,7 +33,7 @@ class Engine
std::list<std::shared_ptr<Emitter>> m_activeEmitters;
std::list<std::shared_ptr<Sequencer>> m_activeSequencers;
std::list<Submix> m_activeSubmixes;
std::unordered_map<uint16_t, std::tuple<AudioGroup*, int, ObjectId>> m_sfxLookup;
std::unordered_map<uint16_t, std::tuple<AudioGroup*, int, const SFXGroupIndex::SFXEntry*>> m_sfxLookup;
std::linear_congruential_engine<uint32_t, 0x41c64e6d, 0x3039, UINT32_MAX> m_random;
int m_nextVid = 0;

View File

@ -20,12 +20,15 @@ public:
};
private:
State m_phase = State::Attack; /**< Current envelope state */
const ADSR* m_curADSR = nullptr; /**< Current timing envelope */
double m_sustainFactor; /**< Evaluated sustain percentage as a double */
double m_attackTime = 0.0; /**< Time of attack in seconds */
double m_decayTime = 0.0; /**< Time of decay in seconds */
double m_sustainFactor = 1.0; /**< Evaluated sustain percentage */
double m_releaseTime = 0.0; /**< Time of release in seconds */
double m_releaseStartFactor; /**< Level at whenever release event occurs */
double m_curMs; /**< Current time of envelope stage */
double m_curTime; /**< Current time of envelope stage in seconds */
public:
void reset(const ADSR* adsr);
void reset(const ADSRDLS* adsr, int8_t note, int8_t vel);
void keyOff();
float nextSample(double sampleRate);
bool isComplete() const {return m_phase == State::Complete;}

View File

@ -40,6 +40,7 @@ class Sequencer : public Entity
struct ChannelState
{
Sequencer& m_parent;
uint8_t m_chanId;
const SongGroupIndex::MIDISetup& m_setup;
const SongGroupIndex::PageEntry* m_page = nullptr;
Submix* m_submix = nullptr;
@ -50,12 +51,17 @@ class Sequencer : public Entity
std::unordered_map<uint8_t, std::shared_ptr<Voice>> m_chanVoxs;
std::unordered_set<std::shared_ptr<Voice>> m_keyoffVoxs;
int8_t m_ctrlVals[128]; /**< MIDI controller values */
float m_curPitchWheel = 0.f; /**< MIDI pitch-wheel */
int8_t m_curProgram = 0; /**< MIDI program number */
void _bringOutYourDead();
size_t getVoiceCount() const;
std::shared_ptr<Voice> keyOn(uint8_t note, uint8_t velocity);
void keyOff(uint8_t note, uint8_t velocity);
void setCtrlValue(uint8_t ctrl, int8_t val);
bool programChange(int8_t prog);
void nextProgram();
void prevProgram();
void setPitchWheel(float pitchWheel);
void setVolume(float vol);
void allOff();
@ -114,6 +120,18 @@ public:
/** Set total volume of sequencer */
void setVolume(float vol);
/** Get current program number of channel */
int8_t getChanProgram(int8_t chanId) const;
/** Set current program number of channel */
bool setChanProgram(int8_t chanId, int8_t prog);
/** Advance to next program in channel */
void nextChanProgram(int8_t chanId);
/** Advance to prev program in channel */
void prevChanProgram(int8_t chanId);
/** Manually kill sequencer for deferred release from engine */
void kill() {m_state = SequencerState::Dead;}
};

View File

@ -67,6 +67,7 @@ class Voice : public Entity
bool m_sustainKeyOff = false; /**< Keyoff event occured while sustained */
uint8_t m_curAftertouch = 0; /**< Aftertouch value (key pressure when 'bottoming out') */
float m_userVol = 1.f; /**< User volume of voice */
float m_curVol; /**< Current volume of voice */
float m_curReverbVol; /**< Current reverb volume of voice */
float m_curPan; /**< Current pan of voice */
@ -124,7 +125,7 @@ class Voice : public Entity
void _doKeyOff();
void _macroKeyOff();
void _macroSampleEnd();
bool _advanceSample(int16_t& samp);
bool _advanceSample(int16_t& samp, int32_t& curPitch);
void _setTotalPitch(int32_t cents);
bool _isRecursivelyDead();
void _bringOutYourDead();
@ -238,7 +239,7 @@ public:
void setReverbVol(float rvol);
/** Set envelope for voice */
void setAdsr(ObjectId adsrId);
void setAdsr(ObjectId adsrId, bool dls);
/** Set pitch in absolute hertz */
void setPitchFrequency(uint32_t hz, uint16_t fine);
@ -261,6 +262,8 @@ public:
/** Get note played on voice */
uint8_t getLastNote() const {return m_state.m_initKey;}
void notifyCtrlChange(uint8_t ctrl, int8_t val);
/** Get MIDI Controller value on voice */
int8_t getCtrlValue(uint8_t ctrl) const
{
@ -283,6 +286,7 @@ public:
}
else
m_extCtrlVals[ctrl] = val;
notifyCtrlChange(ctrl, val);
}
/** Get ModWheel value on voice */

View File

@ -79,7 +79,7 @@ AudioGroupProject::AudioGroupProject(const unsigned char* data)
const uint8_t* setupEnd = data + header.groupEndOff;
while (setupData < setupEnd)
{
uint32_t songId = SBig(*reinterpret_cast<const uint32_t*>(setupData));
uint16_t songId = SBig(*reinterpret_cast<const uint16_t*>(setupData));
idx.m_midiSetups[songId] =
reinterpret_cast<const std::array<SongGroupIndex::MIDISetup, 16>*>(setupData + 4);
setupData += 5 * 16 + 4;

View File

@ -102,7 +102,7 @@ void Engine::_bringOutYourDead()
for (auto it = m_activeEmitters.begin() ; it != m_activeEmitters.end() ;)
{
Emitter* emitter = it->get();
if (emitter->getVoice()->m_voxState == VoiceState::Dead)
if (emitter->getVoice()->_isRecursivelyDead())
{
emitter->_destroy();
it = m_activeEmitters.erase(it);
@ -115,7 +115,7 @@ void Engine::_bringOutYourDead()
{
Voice* vox = it->get();
vox->_bringOutYourDead();
if (vox->m_voxState == VoiceState::Dead)
if (vox->_isRecursivelyDead())
{
it = _destroyVoice(vox);
continue;
@ -166,7 +166,7 @@ const AudioGroup* Engine::addAudioGroup(const AudioGroupData& data)
const SFXGroupIndex& sfxGroup = grp.second;
m_sfxLookup.reserve(m_sfxLookup.size() + sfxGroup.m_sfxEntries.size());
for (const auto& ent : sfxGroup.m_sfxEntries)
m_sfxLookup[ent.first] = std::make_tuple(ret, grp.first, SBig(ent.second->objId));
m_sfxLookup[ent.first] = std::make_tuple(ret, grp.first, ent.second);
}
return ret;
@ -292,11 +292,12 @@ std::shared_ptr<Voice> Engine::fxStart(int sfxId, float vol, float pan, Submix*
return nullptr;
AudioGroup* grp = std::get<0>(search->second);
const SFXGroupIndex::SFXEntry* entry = std::get<2>(search->second);
if (!grp)
return nullptr;
std::shared_ptr<Voice> ret = _allocateVoice(*grp, std::get<1>(search->second), 32000.0, true, false, smx);
if (!ret->loadSoundObject(std::get<2>(search->second), 0, 1000.f, 0x3c, 0, 0))
if (!ret->loadSoundObject(SBig(entry->objId), 0, 1000.f, entry->defKey, entry->defVel, 0))
{
_destroyVoice(ret.get());
return {};
@ -315,18 +316,20 @@ std::shared_ptr<Emitter> Engine::addEmitter(const Vector3f& pos, const Vector3f&
return nullptr;
AudioGroup* grp = std::get<0>(search->second);
const SFXGroupIndex::SFXEntry* entry = std::get<2>(search->second);
if (!grp)
return nullptr;
std::shared_ptr<Voice> vox = _allocateVoice(*grp, std::get<1>(search->second), 32000.0, true, true, smx);
m_activeEmitters.emplace(m_activeEmitters.end(), new Emitter(*this, *grp, std::move(vox)));
Emitter& ret = *m_activeEmitters.back();
if (!ret.getVoice()->loadSoundObject(std::get<2>(search->second), 0, 1000.f, 0x3c, 0, 0))
if (!ret.getVoice()->loadSoundObject(entry->objId, 0, 1000.f, entry->defKey, entry->defVel, 0))
{
ret._destroy();
m_activeEmitters.pop_back();
return {};
}
vox->setPan(entry->panning);
ret.setPos(pos);
ret.setDir(dir);
ret.setMaxDist(maxDist);

View File

@ -6,55 +6,51 @@ namespace amuse
void Envelope::reset(const ADSR* adsr)
{
m_phase = State::Attack;
m_curADSR = adsr;
m_curMs = 0.0;
if (m_curADSR->decayCoarse == 128)
m_sustainFactor = 1.f;
else
m_sustainFactor = (adsr->sustainCoarse * 6.25 + adsr->sustainFine * 0.0244) / 100.0;
m_curTime = 0.0;
m_attackTime = adsr->getAttack();
m_decayTime = adsr->getDecay();
m_sustainFactor = adsr->getSustain();
m_releaseTime = adsr->getRelease();
m_releaseStartFactor = 0.0;
}
void Envelope::reset(const ADSRDLS* adsr, int8_t note, int8_t vel)
{
m_phase = State::Attack;
m_curTime = 0.0;
m_attackTime = adsr->getVelToAttack(vel);
m_decayTime = adsr->getKeyToDecay(note);
m_sustainFactor = adsr->getSustain();
m_releaseTime = adsr->getRelease();
m_releaseStartFactor = 0.0;
}
void Envelope::keyOff()
{
m_phase = State::Release;
m_curMs = 0.0;
m_phase = (m_releaseTime != 0.0) ? State::Release : State::Complete;
m_curTime = 0.0;
}
float Envelope::nextSample(double sampleRate)
{
if (!m_curADSR)
{
if (m_phase == State::Release || m_phase == State::Complete)
return 0.f;
return 1.f;
}
m_curMs += 1.0 / (sampleRate / 1000.0);
m_curTime += 1.0 / sampleRate;
switch (m_phase)
{
case State::Attack:
{
uint16_t attack = m_curADSR->attackCoarse * 255 + m_curADSR->attackFine;
if (attack == 0)
if (m_attackTime == 0.0)
{
if (m_curADSR->decayCoarse == 128)
m_phase = State::Sustain;
else
m_phase = State::Decay;
m_curMs = 0.0;
m_curTime = 0.0;
m_releaseStartFactor = 1.f;
return 1.f;
}
double attackFac = m_curMs / double(attack);
double attackFac = m_curTime / m_attackTime;
if (attackFac >= 1.0)
{
if (m_curADSR->decayCoarse == 128)
m_phase = State::Sustain;
else
m_phase = State::Decay;
m_curMs = 0.0;
m_curTime = 0.0;
m_releaseStartFactor = 1.f;
return 1.f;
}
@ -63,19 +59,18 @@ float Envelope::nextSample(double sampleRate)
}
case State::Decay:
{
uint16_t decay = m_curADSR->decayCoarse * 255 + m_curADSR->decayFine;
if (decay == 0)
if (m_decayTime == 0.0)
{
m_phase = State::Sustain;
m_curMs = 0.0;
m_curTime = 0.0;
m_releaseStartFactor = m_sustainFactor;
return m_sustainFactor;
}
double decayFac = m_curMs / double(decay);
double decayFac = m_curTime / m_decayTime;
if (decayFac >= 1.0)
{
m_phase = State::Sustain;
m_curMs = 0.0;
m_curTime = 0.0;
m_releaseStartFactor = m_sustainFactor;
return m_sustainFactor;
}
@ -88,19 +83,18 @@ float Envelope::nextSample(double sampleRate)
}
case State::Release:
{
uint16_t release = m_curADSR->releaseCoarse * 255 + m_curADSR->releaseFine;
if (release == 0)
if (m_releaseTime == 0.0)
{
m_phase = State::Complete;
return 0.f;
}
double releaseFac = m_curMs / double(release);
double releaseFac = m_curTime / m_releaseTime;
if (releaseFac >= 1.0)
{
m_phase = State::Complete;
return 0.f;
}
return (1.0 - releaseFac) * m_releaseStartFactor;
return std::min(m_releaseStartFactor, 1.0 - releaseFac);
}
case State::Complete:
return 0.f;

View File

@ -69,9 +69,9 @@ Sequencer::ChannelState::~ChannelState()
}
Sequencer::ChannelState::ChannelState(Sequencer& parent, uint8_t chanId)
: m_parent(parent), m_setup(m_parent.m_midiSetup[chanId])
: m_parent(parent), m_chanId(chanId), m_setup(m_parent.m_midiSetup[chanId])
{
if (chanId == 10)
if (chanId == 9)
{
auto it = m_parent.m_songGroup.m_drumPages.find(m_setup.programNo);
if (it != m_parent.m_songGroup.m_drumPages.cend())
@ -126,6 +126,11 @@ std::shared_ptr<Voice> Sequencer::ChannelState::keyOn(uint8_t note, uint8_t velo
}
ret->setVolume(m_parent.m_curVol * m_setup.volume / 127.f);
ret->setPan(m_setup.panning / 64.f - 127.f);
ret->setPitchWheel(m_curPitchWheel);
if (m_ctrlVals[64] > 64)
ret->setPedal(true);
return ret;
}
@ -164,6 +169,51 @@ void Sequencer::keyOff(uint8_t chan, uint8_t note, uint8_t 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);
}
bool Sequencer::ChannelState::programChange(int8_t prog)
{
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)
@ -177,6 +227,7 @@ void Sequencer::setCtrlValue(uint8_t chan, uint8_t ctrl, int8_t 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)
@ -207,7 +258,14 @@ void Sequencer::allOff(bool now)
{
if (now)
for (auto& chan : m_chanStates)
{
for (const auto& vox : chan.second->m_chanVoxs)
m_engine._destroyVoice(vox.second.get());
for (const auto& vox : chan.second->m_keyoffVoxs)
m_engine._destroyVoice(vox.get());
chan.second->m_chanVoxs.clear();
chan.second->m_keyoffVoxs.clear();
}
else
for (auto& chan : m_chanStates)
chan.second->allOff();
@ -324,4 +382,40 @@ void Sequencer::setVolume(float vol)
chan.second->setVolume(vol);
}
int8_t Sequencer::getChanProgram(int8_t chanId) const
{
auto chanSearch = m_chanStates.find(chanId);
if (chanSearch == m_chanStates.cend())
return 0;
return chanSearch->second->m_curProgram;
}
bool Sequencer::setChanProgram(int8_t chanId, int8_t prog)
{
auto chanSearch = m_chanStates.find(chanId);
if (chanSearch == m_chanStates.cend())
return false;
return chanSearch->second->programChange(prog);
}
void Sequencer::nextChanProgram(int8_t chanId)
{
auto chanSearch = m_chanStates.find(chanId);
if (chanSearch == m_chanStates.cend())
return;
return chanSearch->second->nextProgram();
}
void Sequencer::prevChanProgram(int8_t chanId)
{
auto chanSearch = m_chanStates.find(chanId);
if (chanSearch == m_chanStates.cend())
return;
return chanSearch->second->prevProgram();
}
}

View File

@ -405,7 +405,8 @@ bool SoundMacroState::advance(Voice& vox, double dt)
case Op::SetAdsr:
{
ObjectId tableId = *reinterpret_cast<ObjectId*>(&cmd.m_data[0]);
vox.setAdsr(tableId);
bool dlsMode = cmd.m_data[2];
vox.setAdsr(tableId, dlsMode);
break;
}
case Op::ScaleVolume:
@ -423,12 +424,12 @@ bool SoundMacroState::advance(Voice& vox, double dt)
const Curve* curveData = vox.getAudioGroup().getPool().tableAsCurves(curve);
if (curveData)
{
vox.setVolume((*curveData)[eval] / 127.f);
vox.m_curVol = (*curveData)[eval] / 127.f;
break;
}
}
vox.setVolume(eval / 127.f);
vox.m_curVol = eval / 127.f;
break;
}
case Op::Panning:
@ -723,7 +724,7 @@ bool SoundMacroState::advance(Voice& vox, double dt)
{
int16_t scale = *reinterpret_cast<int16_t*>(&cmd.m_data[0]);
bool orgVel = cmd.m_data[2];
vox.setVolume(int32_t(orgVel ? m_initVel : m_curVel) * scale / 4096.f / 127.f);
vox.m_curVol = int32_t(orgVel ? m_initVel : m_curVel) * scale / 4096.f / 127.f;
break;
}
case Op::Mod2Vibrange:

View File

@ -24,13 +24,13 @@ void Voice::_destroy()
Voice::~Voice()
{
fprintf(stderr, "DEALLOC %p\n", this);
//fprintf(stderr, "DEALLOC %d\n", m_vid);
}
Voice::Voice(Engine& engine, const AudioGroup& group, int groupId, int vid, bool emitter, Submix* smx)
: Entity(engine, group, groupId), m_vid(vid), m_emitter(emitter), m_submix(smx)
{
fprintf(stderr, "ALLOC %p\n", this);
//fprintf(stderr, "ALLOC %d\n", m_vid);
if (m_submix)
m_submix->m_activeVoices.insert(this);
}
@ -38,7 +38,7 @@ Voice::Voice(Engine& engine, const AudioGroup& group, int groupId, int vid, bool
Voice::Voice(Engine& engine, const AudioGroup& group, int groupId, ObjectId oid, int vid, bool emitter, Submix* smx)
: Entity(engine, group, groupId, oid), m_vid(vid), m_emitter(emitter), m_submix(smx)
{
fprintf(stderr, "ALLOC %p\n", this);
//fprintf(stderr, "ALLOC %d\n", m_vid);
if (m_submix)
m_submix->m_activeVoices.insert(this);
}
@ -49,7 +49,6 @@ void Voice::_reset()
m_curReverbVol = 0.f;
m_curPan = 0.f;
m_curSpan = 0.f;
m_curPitchWheel = 0.f;
m_curAftertouch = 0;
m_pitchWheelUp = 6;
m_pitchWheelDown = 6;
@ -67,7 +66,6 @@ void Voice::_reset()
m_tremoloModScale = 0.f;
m_lfoPeriods[0] = 0.f;
m_lfoPeriods[1] = 0.f;
memset(m_extCtrlVals, 0, 128);
}
void Voice::_macroSampleEnd()
@ -90,6 +88,9 @@ void Voice::_macroSampleEnd()
bool Voice::_checkSamplePos()
{
if (!m_curSample)
return true;
if (m_curSamplePos >= m_lastSamplePos)
{
if (m_curSample->first.m_loopLengthSamples)
@ -128,7 +129,7 @@ void Voice::_doKeyOff()
void Voice::_setTotalPitch(int32_t cents)
{
fprintf(stderr, "PITCH %d\n", cents);
//fprintf(stderr, "PITCH %d\n", cents);
int32_t interval = cents - m_curSample->first.m_pitch * 100;
double ratio = std::exp2(interval / 1200.0);
m_sampleRate = m_curSample->first.m_sampleRate * ratio;
@ -200,7 +201,7 @@ std::list<std::shared_ptr<Voice>>::iterator Voice::_destroyVoice(Voice* voice)
return m_childVoices.erase(voice->m_engineIt);
}
bool Voice::_advanceSample(int16_t& samp)
bool Voice::_advanceSample(int16_t& samp, int32_t& newPitch)
{
double dt = 1.0 / m_sampleRate;
m_voiceTime += dt;
@ -223,7 +224,7 @@ bool Voice::_advanceSample(int16_t& samp)
}
/* Factor in ADSR envelope state */
float totalVol = m_curVol * m_volAdsr.nextSample(m_sampleRate);
float totalVol = m_userVol * m_curVol * m_volAdsr.nextSample(m_sampleRate) /* (m_state.m_curVel / 127.f)*/;
/* Apply tremolo */
if (m_state.m_tremoloSel && (m_tremoloScale || m_tremoloModScale))
@ -283,13 +284,13 @@ bool Voice::_advanceSample(int16_t& samp)
}
/* Calculate total pitch */
int32_t totalPitch = m_curPitch;
bool pitchDirty = m_pitchDirty;
newPitch = m_curPitch;
refresh |= m_pitchDirty;
m_pitchDirty = false;
if (m_pitchEnv)
{
totalPitch = m_curPitch * m_pitchAdsr.nextSample(m_sampleRate);
pitchDirty = true;
newPitch = m_curPitch * m_pitchAdsr.nextSample(m_sampleRate);
refresh = true;
}
/* Process pitch sweep 1 */
@ -297,7 +298,7 @@ bool Voice::_advanceSample(int16_t& samp)
{
m_pitchSweep1 += m_pitchSweep1Add;
--m_pitchSweep1Times;
pitchDirty = true;
refresh = true;
}
/* Process pitch sweep 2 */
@ -305,13 +306,6 @@ bool Voice::_advanceSample(int16_t& samp)
{
m_pitchSweep2 += m_pitchSweep2Add;
--m_pitchSweep2Times;
pitchDirty = true;
}
/* Apply total pitch */
if (pitchDirty)
{
_setTotalPitch(totalPitch + m_pitchSweep1 + m_pitchSweep2 + m_pitchWheelVal);
refresh = true;
}
@ -327,7 +321,14 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
/* Attempt to load stopped sample for immediate decoding */
if (!m_curSample)
{
dead = m_state.advance(*this, 0.0);
if (!dead)
{
memset(data, 0, sizeof(int16_t) * samples);
return samples;
}
}
if (m_curSample)
{
@ -335,6 +336,9 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
uint32_t block = m_curSamplePos / 14;
uint32_t rem = m_curSamplePos % 14;
bool refresh = false;
int32_t curPitch = m_curPitch;
if (rem)
{
uint32_t remCount = std::min(samplesRem, m_lastSamplePos - block * 14);
@ -352,12 +356,15 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
case SampleFormat::PCM:
{
const int16_t* pcm = reinterpret_cast<const int16_t*>(m_curSampleData);
remCount = std::min(samplesRem, m_lastSamplePos - m_curSamplePos);
for (uint32_t i=0 ; i<remCount ; ++i)
data[i] = SBig(pcm[m_curSamplePos+i]);
decSamples = remCount;
break;
}
default: return 0;
default:
memset(data, 0, sizeof(int16_t) * samples);
return samples;
}
/* Per-sample processing */
@ -365,8 +372,7 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
{
++samplesProc;
++m_curSamplePos;
if (_advanceSample(data[i]))
return samplesProc;
refresh |= _advanceSample(data[i], curPitch);
}
samplesRem -= decSamples;
@ -398,12 +404,15 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
case SampleFormat::PCM:
{
const int16_t* pcm = reinterpret_cast<const int16_t*>(m_curSampleData);
remCount = std::min(samplesRem, m_lastSamplePos - m_curSamplePos);
for (uint32_t i=0 ; i<remCount ; ++i)
data[i] = SBig(pcm[m_curSamplePos+i]);
decSamples = remCount;
break;
}
default: return 0;
default:
memset(data, 0, sizeof(int16_t) * samples);
return samples;
}
/* Per-sample processing */
@ -411,8 +420,7 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
{
++samplesProc;
++m_curSamplePos;
if (_advanceSample(data[i]))
return samplesProc;
refresh |= _advanceSample(data[i], curPitch);
}
samplesRem -= decSamples;
@ -425,6 +433,9 @@ size_t Voice::supplyAudio(size_t samples, int16_t* data)
return samples;
}
}
if (refresh)
_setTotalPitch(curPitch + m_pitchSweep1 + m_pitchSweep2 + m_pitchWheelVal);
}
else
memset(data, 0, sizeof(int16_t) * samples);
@ -535,15 +546,17 @@ bool Voice::loadSoundObject(ObjectId objectId, int macroStep, double ticksPerSec
void Voice::_macroKeyOff()
{
if (m_voxState == VoiceState::Playing)
{
if (m_sustained)
m_sustainKeyOff = true;
else
_doKeyOff();
m_voxState = VoiceState::KeyOff;
}
for (const std::shared_ptr<Voice>& vox : m_childVoices)
vox->keyOff();
m_voxState = VoiceState::KeyOff;
}
void Voice::keyOff()
@ -588,7 +601,7 @@ void Voice::startSample(int16_t sampId, int32_t offset)
_reset();
m_sampleRate = m_curSample->first.m_sampleRate;
m_curPitch = m_curSample->first.m_pitch;
m_pitchDirty = true;
setPitchWheel(m_curPitchWheel);
m_backendVoice->resetSampleRate(m_curSample->first.m_sampleRate);
m_curSamplePos = offset;
m_curSampleData = m_audioGroup.getSampleData(m_curSample->first.m_sampleOff);
@ -630,25 +643,25 @@ void Voice::stopSample()
void Voice::setVolume(float vol)
{
m_curVol = vol;
m_userVol = clamp(0.f, vol, 1.f);
}
void Voice::setPan(float pan)
{
m_curPan = pan;
m_curPan = clamp(-1.f, pan, 1.f);
}
void Voice::setSurroundPan(float span)
{
m_curSpan = span;
m_curSpan = clamp(-1.f, span, 1.f);
}
void Voice::startEnvelope(double dur, float vol, const Curve* envCurve)
{
m_envelopeTime = m_voiceTime;
m_envelopeDur = dur;
m_envelopeStart = m_curVol;
m_envelopeEnd = vol;
m_envelopeStart = clamp(0.f, m_curVol, 1.f);
m_envelopeEnd = clamp(0.f, vol, 1.f);
m_envelopeCurve = envCurve;
}
@ -657,7 +670,7 @@ void Voice::startFadeIn(double dur, float vol, const Curve* envCurve)
m_envelopeTime = m_voiceTime;
m_envelopeDur = dur;
m_envelopeStart = 0.f;
m_envelopeEnd = m_curVol;
m_envelopeEnd = clamp(0.f, m_curVol, 1.f);
m_envelopeCurve = envCurve;
}
@ -737,11 +750,20 @@ void Voice::setReverbVol(float rvol)
m_curReverbVol = rvol;
}
void Voice::setAdsr(ObjectId adsrId)
void Voice::setAdsr(ObjectId adsrId, bool dls)
{
if (dls)
{
const ADSRDLS* adsr = m_audioGroup.getPool().tableAsAdsrDLS(adsrId);
if (adsr)
m_volAdsr.reset(adsr, m_state.m_initKey, m_state.m_initVel);
}
else
{
const ADSR* adsr = m_audioGroup.getPool().tableAsAdsr(adsrId);
if (adsr)
m_volAdsr.reset(adsr);
}
}
void Voice::setPitchFrequency(uint32_t hz, uint16_t fine)
@ -753,10 +775,10 @@ void Voice::setPitchFrequency(uint32_t hz, uint16_t fine)
void Voice::setPitchAdsr(ObjectId adsrId, int32_t cents)
{
const ADSR* adsr = m_audioGroup.getPool().tableAsAdsr(adsrId);
const ADSRDLS* adsr = m_audioGroup.getPool().tableAsAdsrDLS(adsrId);
if (adsr)
{
m_pitchAdsr.reset(adsr);
m_pitchAdsr.reset(adsr, m_state.m_initKey, m_state.m_initVel);
m_pitchEnvRange = cents;
m_pitchEnv = true;
}
@ -766,9 +788,9 @@ void Voice::setPitchWheel(float pitchWheel)
{
m_curPitchWheel = amuse::clamp(-1.f, pitchWheel, 1.f);
if (pitchWheel > 0.f)
m_pitchWheelVal = m_pitchWheelUp * m_curPitchWheel;
m_pitchWheelVal = m_pitchWheelUp * m_curPitchWheel * 100;
else if (pitchWheel < 0.f)
m_pitchWheelVal = m_pitchWheelDown * -m_curPitchWheel;
m_pitchWheelVal = m_pitchWheelDown * m_curPitchWheel * 100;
else
m_pitchWheelVal = 0;
m_pitchDirty = true;
@ -786,6 +808,17 @@ void Voice::setAftertouch(uint8_t aftertouch)
m_curAftertouch = aftertouch;
}
void Voice::notifyCtrlChange(uint8_t ctrl, int8_t val)
{
if (ctrl == 64)
{
if (val >= 64)
setPedal(true);
else
setPedal(false);
}
}
size_t Voice::getTotalVoices() const
{
size_t ret = 1;