libs/ardour/event_type_map.cc

   1 /*
   2     Copyright (C) 2008 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <cstdio>
  22 #include "ardour/types.h"
  23 #include "ardour/event_type_map.h"
  24 #include "evoral/Parameter.hpp"
  25 #include "evoral/midi_events.h"
  26 #include "evoral/MIDIParameters.hpp"
  27 #include "pbd/error.h"
  28 #include "pbd/compose.h"
  29
  30 using namespace std;
  31
  32 namespace ARDOUR {
  33
  34 EventTypeMap EventTypeMap::event_type_map;
  35
  36 bool
  37 EventTypeMap::type_is_midi(uint32_t type) const
  38 {
  39         return (type >= MidiCCAutomation) && (type <= MidiChannelPressureAutomation);
  40 }
  41
  42 bool
  43 EventTypeMap::is_midi_parameter(const Evoral::Parameter& param)
  44 {
  45                 return type_is_midi(param.type());
  46 }
  47
  48 uint8_t
  49 EventTypeMap::parameter_midi_type(const Evoral::Parameter& param) const
  50 {
  51         switch (param.type()) {
  52         case MidiCCAutomation:              return MIDI_CMD_CONTROL; break;
  53         case MidiPgmChangeAutomation:       return MIDI_CMD_PGM_CHANGE; break;
  54         case MidiChannelPressureAutomation: return MIDI_CMD_CHANNEL_PRESSURE; break;
  55         case MidiPitchBenderAutomation:     return MIDI_CMD_BENDER; break;
  56         case MidiSystemExclusiveAutomation: return MIDI_CMD_COMMON_SYSEX; break;
  57         default: return 0;
  58         }
  59 }
  60
  61 uint32_t
  62 EventTypeMap::midi_event_type(uint8_t status) const
  63 {
  64         switch (status & 0xF0) {
  65         case MIDI_CMD_CONTROL:          return MidiCCAutomation; break;
  66         case MIDI_CMD_PGM_CHANGE:       return MidiPgmChangeAutomation; break;
  67         case MIDI_CMD_CHANNEL_PRESSURE: return MidiChannelPressureAutomation; break;
  68         case MIDI_CMD_BENDER:           return MidiPitchBenderAutomation; break;
  69         case MIDI_CMD_COMMON_SYSEX:     return MidiSystemExclusiveAutomation; break;
  70         default: return 0;
  71         }
  72 }
  73
  74 bool
  75 EventTypeMap::is_integer(const Evoral::Parameter& param) const
  76 {
  77         return (   param.type() >= MidiCCAutomation
  78                         && param.type() <= MidiChannelPressureAutomation);
  79 }
  80
  81 Evoral::ControlList::InterpolationStyle
  82 EventTypeMap::interpolation_of(const Evoral::Parameter& param)
  83 {
  84         switch (param.type()) {
  85         case MidiCCAutomation:
  86                 switch (param.id()) {
  87                 case MIDI_CTL_LSB_BANK:
  88                 case MIDI_CTL_MSB_BANK:
  89                 case MIDI_CTL_LSB_EFFECT1:
  90                 case MIDI_CTL_LSB_EFFECT2:
  91                 case MIDI_CTL_MSB_EFFECT1:
  92                 case MIDI_CTL_MSB_EFFECT2:
  93                 case MIDI_CTL_MSB_GENERAL_PURPOSE1:
  94                 case MIDI_CTL_MSB_GENERAL_PURPOSE2:
  95                 case MIDI_CTL_MSB_GENERAL_PURPOSE3:
  96                 case MIDI_CTL_MSB_GENERAL_PURPOSE4:
  97                 case MIDI_CTL_SUSTAIN:
  98                 case MIDI_CTL_PORTAMENTO:
  99                 case MIDI_CTL_SOSTENUTO:
 100                 case MIDI_CTL_SOFT_PEDAL:
 101                 case MIDI_CTL_LEGATO_FOOTSWITCH:
 102                 case MIDI_CTL_HOLD2:
 103                 case MIDI_CTL_GENERAL_PURPOSE5:
 104                 case MIDI_CTL_GENERAL_PURPOSE6:
 105                 case MIDI_CTL_GENERAL_PURPOSE7:
 106                 case MIDI_CTL_GENERAL_PURPOSE8:
 107                 case MIDI_CTL_DATA_INCREMENT:
 108                 case MIDI_CTL_DATA_DECREMENT:
 109                 case MIDI_CTL_NONREG_PARM_NUM_LSB:
 110                 case MIDI_CTL_NONREG_PARM_NUM_MSB:
 111                 case MIDI_CTL_REGIST_PARM_NUM_LSB:
 112                 case MIDI_CTL_REGIST_PARM_NUM_MSB:
 113                 case MIDI_CTL_ALL_SOUNDS_OFF:
 114                 case MIDI_CTL_RESET_CONTROLLERS:
 115                 case MIDI_CTL_LOCAL_CONTROL_SWITCH:
 116                 case MIDI_CTL_ALL_NOTES_OFF:
 117                 case MIDI_CTL_OMNI_OFF:
 118                 case MIDI_CTL_OMNI_ON:
 119                 case MIDI_CTL_MONO:
 120                 case MIDI_CTL_POLY:
 121                         return Evoral::ControlList::Discrete; break;
 122                 default:
 123                         return Evoral::ControlList::Linear; break;
 124                 }
 125                 break;
 126         case MidiPgmChangeAutomation:       return Evoral::ControlList::Discrete; break;
 127         case MidiChannelPressureAutomation: return Evoral::ControlList::Linear; break;
 128         case MidiPitchBenderAutomation:     return Evoral::ControlList::Linear; break;
 129         default: assert(false);
 130         }
 131         return Evoral::ControlList::Linear; // Not reached, suppress warnings
 132 }
 133
 134
 135 Evoral::Parameter
 136 EventTypeMap::new_parameter(uint32_t type, uint8_t channel, uint32_t id) const
 137 {
 138         Evoral::Parameter p(type, channel, id);
 139
 140         double min    = 0.0f;
 141         double max    = 1.0f;
 142         double normal = 0.0f;
 143
 144         switch((AutomationType)type) {
 145         case NullAutomation:
 146         case GainAutomation:
 147                 max = 2.0f;
 148                 normal = 1.0f;
 149                 break;
 150         case PanAzimuthAutomation:
 151                 normal = 0.5f; // there really is no normal but this works for stereo, sort of
 152                 break;
 153         case PanWidthAutomation:
 154                 min = -1.0;
 155                 max = 1.0;
 156                 normal = 0.0f;
 157                 break;
 158         case PanElevationAutomation:
 159         case PanFrontBackAutomation:
 160         case PanLFEAutomation:
 161                 break;
 162         case PluginAutomation:
 163         case SoloAutomation:
 164         case MuteAutomation:
 165         case FadeInAutomation:
 166         case FadeOutAutomation:
 167         case EnvelopeAutomation:
 168                 max = 2.0f;
 169                 normal = 1.0f;
 170                 break;
 171         case MidiCCAutomation:
 172         case MidiPgmChangeAutomation:
 173         case MidiChannelPressureAutomation:
 174                 Evoral::MIDI::controller_range(min, max, normal); break;
 175         case MidiPitchBenderAutomation:
 176                 Evoral::MIDI::bender_range(min, max, normal); break;
 177         case MidiSystemExclusiveAutomation:
 178                 return p;
 179         }
 180
 181         p.set_range(type, min, max, normal, false);
 182         return p;
 183 }
 184
 185 Evoral::Parameter
 186 EventTypeMap::new_parameter(const string& str) const
 187 {
 188         AutomationType p_type    = NullAutomation;
 189         uint8_t        p_channel = 0;
 190         uint32_t       p_id      = 0;
 191
 192         if (str == "gain") {
 193                 p_type = GainAutomation;
 194         } else if (str == "solo") {
 195                 p_type = SoloAutomation;
 196         } else if (str == "mute") {
 197                 p_type = MuteAutomation;
 198         } else if (str == "fadein") {
 199                 p_type = FadeInAutomation;
 200         } else if (str == "fadeout") {
 201                 p_type = FadeOutAutomation;
 202         } else if (str == "envelope") {
 203                 p_type = EnvelopeAutomation;
 204         } else if (str == "pan-azimuth") {
 205                 p_type = PanAzimuthAutomation;
 206         } else if (str == "pan-width") {
 207                 p_type = PanWidthAutomation;
 208         } else if (str == "pan-elevation") {
 209                 p_type = PanElevationAutomation;
 210         } else if (str == "pan-frontback") {
 211                 p_type = PanFrontBackAutomation;
 212         } else if (str == "pan-lfe") {
 213                 p_type = PanLFEAutomation;
 214         } else if (str.length() > 10 && str.substr(0, 10) == "parameter-") {
 215                 p_type = PluginAutomation;
 216                 p_id = atoi(str.c_str()+10);
 217         } else if (str.length() > 7 && str.substr(0, 7) == "midicc-") {
 218                 p_type = MidiCCAutomation;
 219                 uint32_t channel = 0;
 220                 sscanf(str.c_str(), "midicc-%d-%d", &channel, &p_id);
 221                 assert(channel < 16);
 222                 p_channel = channel;
 223         } else if (str.length() > 16 && str.substr(0, 16) == "midi-pgm-change-") {
 224                 p_type = MidiPgmChangeAutomation;
 225                 uint32_t channel = 0;
 226                 sscanf(str.c_str(), "midi-pgm-change-%d", &channel);
 227                 assert(channel < 16);
 228                 p_id = 0;
 229                 p_channel = channel;
 230         } else if (str.length() > 18 && str.substr(0, 18) == "midi-pitch-bender-") {
 231                 p_type = MidiPitchBenderAutomation;
 232                 uint32_t channel = 0;
 233                 sscanf(str.c_str(), "midi-pitch-bender-%d", &channel);
 234                 assert(channel < 16);
 235                 p_id = 0;
 236                 p_channel = channel;
 237         } else if (str.length() > 22 && str.substr(0, 22) == "midi-channel-pressure-") {
 238                 p_type = MidiChannelPressureAutomation;
 239                 uint32_t channel = 0;
 240                 sscanf(str.c_str(), "midi-channel-pressure-%d", &channel);
 241                 assert(channel < 16);
 242                 p_id = 0;
 243                 p_channel = channel;
 244         } else {
 245                 PBD::warning << "Unknown Parameter '" << str << "'" << endmsg;
 246         }
 247
 248         return new_parameter(p_type, p_channel, p_id);
 249 }
 250
 251 /** Unique string representation, suitable as an XML property value.
 252  * e.g. <AutomationList automation-id="whatthisreturns">
 253  */
 254 std::string
 255 EventTypeMap::to_symbol(const Evoral::Parameter& param) const
 256 {
 257         AutomationType t = (AutomationType)param.type();
 258
 259         if (t == GainAutomation) {
 260                 return "gain";
 261         } else if (t == PanAzimuthAutomation) {
 262                 return "pan-azimuth";
 263         } else if (t == PanElevationAutomation) {
 264                 return "pan-elevation";
 265         } else if (t == PanWidthAutomation) {
 266                 return "pan-width";
 267         } else if (t == PanFrontBackAutomation) {
 268                 return "pan-frontback";
 269         } else if (t == PanLFEAutomation) {
 270                 return "pan-lfe";
 271         } else if (t == SoloAutomation) {
 272                 return "solo";
 273         } else if (t == MuteAutomation) {
 274                 return "mute";
 275         } else if (t == FadeInAutomation) {
 276                 return "fadein";
 277         } else if (t == FadeOutAutomation) {
 278                 return "fadeout";
 279         } else if (t == EnvelopeAutomation) {
 280                 return "envelope";
 281         } else if (t == PluginAutomation) {
 282                 return string_compose("parameter-%1", param.id());
 283         } else if (t == MidiCCAutomation) {
 284                 return string_compose("midicc-%1-%2", int(param.channel()), param.id());
 285         } else if (t == MidiPgmChangeAutomation) {
 286                 return string_compose("midi-pgm-change-%1", int(param.channel()));
 287         } else if (t == MidiPitchBenderAutomation) {
 288                 return string_compose("midi-pitch-bender-%1", int(param.channel()));
 289         } else if (t == MidiChannelPressureAutomation) {
 290                 return string_compose("midi-channel-pressure-%1", int(param.channel()));
 291         } else {
 292                 PBD::warning << "Uninitialized Parameter symbol() called." << endmsg;
 293                 return "";
 294         }
 295 }
 296
 297 } // namespace ARDOUR
 298