DISTRHO
/
DISTRHO-Ports
mirror of https://github.com/DISTRHO/DISTRHO-Ports
1
0
Fork 0
Code Releases 5 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
547 Commits
6 Branches
135MB
Tree: 60228728e7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '60228728e7'
${ noResults }
DISTRHO-Ports/ports/vitalium/source/common/midi_manager.cpp

325 lines
12KB
Raw Blame History 

  1. /* Copyright 2013-2019 Matt Tytel

  2.  *

  3.  * vital is free software: you can redistribute it and/or modify

  4.  * it under the terms of the GNU General Public License as published by

  5.  * the Free Software Foundation, either version 3 of the License, or

  6.  * (at your option) any later version.

  7.  *

  8.  * vital is distributed in the hope that it will be useful,

  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11.  * GNU General Public License for more details.

  12.  *

  13.  * You should have received a copy of the GNU General Public License

  14.  * along with vital.  If not, see <http://www.gnu.org/licenses/>.

  15.  */

  16. 

  17. #include "midi_manager.h"

  18. #include "sound_engine.h"

  19. #include "synth_types.h"

  20. #include "load_save.h"

  21. #include "synth_base.h"

  22. 

  23. namespace {

  24.   constexpr int kMidiControlBits = 7;

  25.   constexpr float kHighResolutionMax = (1 << (2 * kMidiControlBits)) - 1.0f;

  26.   constexpr float kControlMax = (1 << kMidiControlBits) - 1.0f;

  27. 

  28.   force_inline vital::mono_float toHighResolutionValue(int msb, int lsb) {

  29.     if (lsb < 0)

  30.       return msb / kControlMax;

  31. 

  32.     return ((msb << kMidiControlBits) + lsb) / kHighResolutionMax;

  33.   }

  34. } // namespace

  35. 

  36. MidiManager::MidiManager(SynthBase* synth, MidiKeyboardState* keyboard_state,

  37.                          std::map<std::string, String>* gui_state, Listener* listener) :

  38.     synth_(synth), keyboard_state_(keyboard_state), gui_state_(gui_state),

  39.     listener_(listener), armed_value_(nullptr),

  40.     msb_pressure_values_(), msb_slide_values_() {

  41.   engine_ = synth_->getEngine();

  42.   current_bank_ = -1;

  43.   current_folder_ = -1;

  44.   current_preset_ = -1;

  45.   

  46.   for (int i = 0; i < vital::kNumMidiChannels; ++i) {

  47.     lsb_slide_values_[i] = -1;

  48.     lsb_pressure_values_[i] = -1;

  49.   }

  50. 

  51.   mpe_enabled_ = false;

  52.   mpe_zone_layout_.setLowerZone(vital::kNumMidiChannels - 1);

  53. }

  54. 

  55. MidiManager::~MidiManager() {

  56. }

  57. 

  58. void MidiManager::armMidiLearn(std::string name) {

  59.   current_bank_ = -1;

  60.   current_folder_ = -1;

  61.   current_preset_ = -1;

  62.   armed_value_ = &vital::Parameters::getDetails(name);

  63. }

  64. 

  65. void MidiManager::cancelMidiLearn() {

  66.   armed_value_ = nullptr;

  67. }

  68. 

  69. void MidiManager::clearMidiLearn(const std::string& name) {

  70.   for (auto& controls : midi_learn_map_) {

  71.     if (controls.second.count(name)) {

  72.       midi_learn_map_[controls.first].erase(name);

  73.       LoadSave::saveMidiMapConfig(this);

  74.     }

  75.   }

  76. }

  77. 

  78. void MidiManager::midiInput(int midi_id, vital::mono_float value) {

  79.   if (armed_value_) {

  80.     midi_learn_map_[midi_id][armed_value_->name] = armed_value_;

  81.     armed_value_ = nullptr;

  82. 

  83.     // TODO: Probably shouldn't write this config on the audio thread.

  84.     LoadSave::saveMidiMapConfig(this);

  85.   }

  86. 

  87.   if (midi_learn_map_.count(midi_id)) {

  88.     for (auto& control : midi_learn_map_[midi_id]) {

  89.       const vital::ValueDetails* details = control.second;

  90.       vital::mono_float percent = value / kControlMax;

  91.       vital::mono_float range = details->max - details->min;

  92.       vital::mono_float translated = percent * range + details->min;

  93. 

  94.       if (details->value_scale == vital::ValueDetails::kIndexed)

  95.         translated = std::round(translated);

  96.       listener_->valueChangedThroughMidi(control.first, translated);

  97.     }

  98.   }

  99. }

  100. 

  101. bool MidiManager::isMidiMapped(const std::string& name) const {

  102.   for (auto& controls : midi_learn_map_) {

  103.     if (controls.second.count(name))

  104.       return true;

  105.   }

  106.   return false;

  107. }

  108. 

  109. void MidiManager::setSampleRate(double sample_rate) {

  110.   midi_collector_.reset(sample_rate);

  111. }

  112. 

  113. void MidiManager::removeNextBlockOfMessages(MidiBuffer& buffer, int num_samples) {

  114.   midi_collector_.removeNextBlockOfMessages(buffer, num_samples);

  115. }

  116. 

  117. void MidiManager::readMpeMessage(const MidiMessage& message) {

  118.   mpe_zone_layout_.processNextMidiEvent(message);

  119. }

  120. 

  121. void MidiManager::processAllNotesOff(const MidiMessage& midi_message, int sample_position, int channel) {

  122.   if (isMpeChannelMasterLowerZone(channel))

  123.     engine_->allNotesOffRange(sample_position, lowerZoneStartChannel(), lowerZoneEndChannel());

  124.   else if (isMpeChannelMasterUpperZone(channel))

  125.     engine_->allNotesOffRange(sample_position, upperZoneStartChannel(), upperZoneEndChannel());

  126.   else

  127.     engine_->allNotesOff(sample_position, channel);

  128. }

  129. 

  130. void MidiManager::processAllSoundsOff() {

  131.   engine_->allSoundsOff();

  132. }

  133. 

  134. void MidiManager::processSustain(const MidiMessage& midi_message, int sample_position, int channel) {

  135.   bool on = midi_message.isSustainPedalOn();

  136.   if (isMpeChannelMasterLowerZone(channel)) {

  137.     if (on)

  138.       engine_->sustainOnRange(lowerZoneStartChannel(), lowerZoneEndChannel());

  139.     else

  140.       engine_->sustainOffRange(sample_position, lowerZoneStartChannel(), lowerZoneEndChannel());

  141.   }

  142.   else if (isMpeChannelMasterUpperZone(channel)) {

  143.     if (on)

  144.       engine_->sustainOnRange(upperZoneStartChannel(), upperZoneEndChannel());

  145.     else

  146.       engine_->sustainOffRange(sample_position, upperZoneStartChannel(), upperZoneEndChannel());

  147.   }

  148.   else {

  149.     if (on)

  150.       engine_->sustainOn(channel);

  151.     else

  152.       engine_->sustainOff(sample_position, channel);

  153.   }

  154. }

  155. 

  156. void MidiManager::processSostenuto(const MidiMessage& midi_message, int sample_position, int channel) {

  157.   bool on = midi_message.isSostenutoPedalOn();

  158.   if (isMpeChannelMasterLowerZone(channel)) {

  159.     if (on)

  160.       engine_->sostenutoOnRange(lowerZoneStartChannel(), lowerZoneEndChannel());

  161.     else

  162.       engine_->sostenutoOffRange(sample_position, lowerZoneStartChannel(), lowerZoneEndChannel());

  163.   }

  164.   else if (isMpeChannelMasterUpperZone(channel)) {

  165.     if (on)

  166.       engine_->sostenutoOnRange(upperZoneStartChannel(), upperZoneEndChannel());

  167.     else

  168.       engine_->sostenutoOffRange(sample_position, upperZoneStartChannel(), upperZoneEndChannel());

  169.   }

  170.   else {

  171.     if (on)

  172.       engine_->sostenutoOn(channel);

  173.     else

  174.       engine_->sostenutoOff(sample_position, channel);

  175.   }

  176. }

  177. 

  178. void MidiManager::processPitchBend(const MidiMessage& midi_message, int sample_position, int channel) {

  179.   vital::mono_float percent = midi_message.getPitchWheelValue() / kHighResolutionMax;

  180.   vital::mono_float value = 2 * percent - 1.0f;

  181. 

  182.   if (isMpeChannelMasterLowerZone(channel)) {

  183.     engine_->setZonedPitchWheel(value, lowerMasterChannel(), lowerMasterChannel() + 1);

  184.     engine_->setZonedPitchWheel(value, lowerZoneStartChannel(), lowerZoneEndChannel());

  185.     listener_->pitchWheelMidiChanged(value);

  186.   }

  187.   else if (isMpeChannelMasterUpperZone(channel)) {

  188.     engine_->setZonedPitchWheel(value, upperMasterChannel(), upperMasterChannel() + 1);

  189.     engine_->setZonedPitchWheel(value, upperZoneStartChannel(), upperZoneEndChannel());

  190.     listener_->pitchWheelMidiChanged(value);

  191.   }

  192.   else if (mpe_enabled_)

  193.     engine_->setPitchWheel(value, channel);

  194.   else {

  195.     engine_->setZonedPitchWheel(value, channel, channel);

  196.     listener_->pitchWheelMidiChanged(value);

  197.   }

  198. }

  199. 

  200. void MidiManager::processPressure(const MidiMessage& midi_message, int sample_position, int channel) {

  201.   vital::mono_float value = toHighResolutionValue(msb_pressure_values_[channel], lsb_pressure_values_[channel]);

  202.   if (isMpeChannelMasterLowerZone(channel))

  203.     engine_->setChannelRangeAftertouch(lowerZoneStartChannel(), lowerZoneEndChannel(), value, 0);

  204.   else if (isMpeChannelMasterUpperZone(channel))

  205.     engine_->setChannelRangeAftertouch(upperZoneStartChannel(), upperZoneEndChannel(), value, 0);

  206.   else

  207.     engine_->setChannelAftertouch(channel, value, sample_position);

  208. }

  209. 

  210. void MidiManager::processSlide(const MidiMessage& midi_message, int sample_position, int channel) {

  211.   vital::mono_float value = toHighResolutionValue(msb_slide_values_[channel], lsb_slide_values_[channel]);

  212.   if (isMpeChannelMasterLowerZone(channel))

  213.     engine_->setChannelRangeSlide(value, lowerZoneStartChannel(), lowerZoneEndChannel(), 0);

  214.   else if (isMpeChannelMasterUpperZone(channel))

  215.     engine_->setChannelRangeSlide(value, upperZoneStartChannel(), upperZoneEndChannel(), 0);

  216.   else

  217.     engine_->setChannelSlide(channel, value, sample_position);

  218. }

  219. 

  220. force_inline bool MidiManager::isMpeChannelMasterLowerZone(int channel) {

  221.   return mpe_enabled_ && mpe_zone_layout_.getLowerZone().isActive() && lowerMasterChannel() == channel;

  222. }

  223. 

  224. force_inline bool MidiManager::isMpeChannelMasterUpperZone(int channel) {

  225.   return mpe_enabled_ && mpe_zone_layout_.getUpperZone().isActive() && upperMasterChannel() == channel;

  226. }

  227. 

  228. void MidiManager::processMidiMessage(const MidiMessage& midi_message, int sample_position) {

  229.   if (midi_message.isController())

  230.     readMpeMessage(midi_message);

  231. 

  232.   int channel = midi_message.getChannel() - 1;

  233.   MidiMainType type = static_cast<MidiMainType>(midi_message.getRawData()[0] & 0xf0);

  234.   switch (type) {

  235.     case kProgramChange:

  236.       return;

  237.     case kNoteOn: {

  238.       uint8 velocity = midi_message.getVelocity();

  239.       if (velocity)

  240.         engine_->noteOn(midi_message.getNoteNumber(), velocity / kControlMax, sample_position, channel);

  241.       else

  242.         engine_->noteOff(midi_message.getNoteNumber(), velocity / kControlMax, sample_position, channel);

  243.       return;

  244.     }

  245.     case kNoteOff: {

  246.       vital::mono_float velocity = midi_message.getVelocity() / kControlMax;

  247.       engine_->noteOff(midi_message.getNoteNumber(), velocity, sample_position, channel);

  248.       return;

  249.     }

  250.     case kAftertouch: {

  251.       int note = midi_message.getNoteNumber();

  252.       vital::mono_float value = midi_message.getAfterTouchValue() / kControlMax;

  253.       engine_->setAftertouch(note, value, sample_position, channel);

  254.       return;

  255.     }

  256.     case kChannelPressure: {

  257.       msb_pressure_values_[channel] = midi_message.getChannelPressureValue();

  258.       processPressure(midi_message, sample_position, channel);

  259.       return;

  260.     }

  261.     case kPitchWheel: {

  262.       processPitchBend(midi_message, sample_position, channel);

  263.       return;

  264.     }

  265.     case kController: {

  266.       MidiSecondaryType secondary_type = static_cast<MidiSecondaryType>(midi_message.getControllerNumber());

  267.       switch (secondary_type) {

  268.         case kSlide: {

  269.           msb_slide_values_[channel] = midi_message.getControllerValue();

  270.           processSlide(midi_message, sample_position, channel);

  271.           break;

  272.         }

  273.         case kLsbPressure: {

  274.           lsb_pressure_values_[channel] = midi_message.getControllerValue();

  275.           processPressure(midi_message, sample_position, channel);

  276.           break;

  277.         }

  278.         case kLsbSlide: {

  279.           lsb_slide_values_[channel] = midi_message.getControllerValue();

  280.           processSlide(midi_message, sample_position, channel);

  281.           break;

  282.         }

  283.         case kSustainPedal: {

  284.           processSustain(midi_message, sample_position, channel);

  285.           break;

  286.         }

  287.         case kSostenutoPedal: {

  288.           processSostenuto(midi_message, sample_position, channel);

  289.           break;

  290.         }

  291.         case kSoftPedalOn: // TODO

  292.           break;

  293.         case kModWheel: {

  294.           vital::mono_float percent = (1.0f * midi_message.getControllerValue()) / kControlMax;

  295.           engine_->setModWheel(percent, channel);

  296.           listener_->modWheelMidiChanged(percent);

  297.           break;

  298.         }

  299.         case kAllNotesOff:

  300.         case kAllControllersOff:

  301.           processAllNotesOff(midi_message, sample_position, channel);

  302.           return;

  303.         case kAllSoundsOff:

  304.           processAllSoundsOff();

  305.           break;

  306.         case kBankSelect:

  307.           current_bank_ = midi_message.getControllerValue();

  308.           return;

  309.         case kFolderSelect:

  310.           current_folder_ = midi_message.getControllerValue();

  311.           return;

  312.       }

  313.       midiInput(midi_message.getControllerNumber(), midi_message.getControllerValue());

  314.     }

  315.   }

  316. }

  317. 

  318. void MidiManager::handleIncomingMidiMessage(MidiInput* source, const MidiMessage &midi_message) {

  319.   midi_collector_.addMessageToQueue(midi_message);

  320. }

  321. 

  322. void MidiManager::replaceKeyboardMessages(MidiBuffer& buffer, int num_samples) {

  323.   keyboard_state_->processNextMidiBuffer(buffer, 0, num_samples, true);

  324. }