X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fgeneric_midi%2Fmidicontrollable.cc;h=d99f319f65f73146c6d62b16cf55924d543de876;hb=24f64b3ea7386ace6d584503fe1397eb4f611dfe;hp=a26617fd676d276d89ffdf823dcef6936b27cb7e;hpb=4861eca97483128e5febb575b94688581abb0154;p=ardour.git diff --git a/libs/surfaces/generic_midi/midicontrollable.cc b/libs/surfaces/generic_midi/midicontrollable.cc index a26617fd67..d99f319f65 100644 --- a/libs/surfaces/generic_midi/midicontrollable.cc +++ b/libs/surfaces/generic_midi/midicontrollable.cc @@ -23,9 +23,9 @@ #include #include "pbd/error.h" -#include "pbd/controllable_descriptor.h" #include "pbd/xml++.h" #include "pbd/stacktrace.h" +#include "pbd/compose.h" #include "midi++/types.h" // Added by JE - 06-01-2009. All instances of 'byte' changed to 'MIDI::byte' (for clarification) #include "midi++/port.h" @@ -33,8 +33,10 @@ #include "ardour/async_midi_port.h" #include "ardour/automation_control.h" +#include "ardour/controllable_descriptor.h" #include "ardour/midi_ui.h" #include "ardour/utils.h" +#include "ardour/debug.h" #include "midicontrollable.h" #include "generic_midi_control_protocol.h" @@ -52,10 +54,13 @@ MIDIControllable::MIDIControllable (GenericMidiControlProtocol* s, MIDI::Parser& , _momentary (m) { _learned = false; /* from URI */ + _encoder = No_enc; setting = false; last_value = 0; // got a better idea ? last_controllable_value = 0.0f; control_type = none; + control_rpn = -1; + control_nrpn = -1; _control_description = "MIDI Control: none"; control_additional = (MIDI::byte) -1; feedback = true; // for now @@ -68,12 +73,15 @@ MIDIControllable::MIDIControllable (GenericMidiControlProtocol* s, MIDI::Parser& , _momentary (m) { set_controllable (&c); - + _learned = true; /* from controllable */ + _encoder = No_enc; setting = false; last_value = 0; // got a better idea ? last_controllable_value = 0.0f; control_type = none; + control_rpn = -1; + control_nrpn = -1; _control_description = "MIDI Control: none"; control_additional = (MIDI::byte) -1; feedback = true; // for now @@ -109,6 +117,8 @@ void MIDIControllable::drop_external_control () { midi_forget (); + control_rpn = -1; + control_nrpn = -1; control_type = none; control_additional = (MIDI::byte) -1; } @@ -119,7 +129,7 @@ MIDIControllable::set_controllable (Controllable* c) if (c == controllable) { return; } - + controllable_death_connection.disconnect (); controllable = c; @@ -132,7 +142,7 @@ MIDIControllable::set_controllable (Controllable* c) if (controllable) { controllable->Destroyed.connect (controllable_death_connection, MISSING_INVALIDATOR, - boost::bind (&MIDIControllable::drop_controllable, this), + boost::bind (&MIDIControllable::drop_controllable, this, _1), MidiControlUI::instance()); } } @@ -169,7 +179,7 @@ MIDIControllable::control_to_midi (float val) float control_min = controllable->lower (); float control_max = controllable->upper (); - const float control_range = control_max - control_min; + float control_range = control_max - control_min; if (controllable->is_toggle()) { if (val >= (control_min + (control_range/2.0f))) { @@ -177,29 +187,49 @@ MIDIControllable::control_to_midi (float val) } else { return 0; } + } else { + AutomationControl *actl = dynamic_cast (controllable); + if (actl) { + control_min = actl->internal_to_interface(control_min); + control_max = actl->internal_to_interface(control_max); + control_range = control_max - control_min; + val = actl->internal_to_interface(val); + } } - - return (val - control_min) / control_range * max_value_for_type (); + // fiddle value of max so value doesn't jump from 125 to 127 for 1.0 + // otherwise decrement won't work. + return (val - control_min) / control_range * (max_value_for_type () - 1); } float MIDIControllable::midi_to_control (int val) { - /* fiddle with MIDI value so that we get an odd number of integer steps - and can thus represent "middle" precisely as 0.5. this maps to - the range 0..+1.0 - */ + /* fiddle with MIDI value so that we get an odd number of integer steps + and can thus represent "middle" precisely as 0.5. this maps to + the range 0..+1.0 (0 to 126) + */ - float fv = (val == 0 ? 0 : float (val - 1) / (max_value_for_type() - 1)); + float fv = (val == 0 ? 0 : float (val - 1) / (max_value_for_type() - 1)); - if (controllable->is_gain_like()) { - return slider_position_to_gain (fv); - } + if (controllable->is_gain_like()) { + return controllable->interface_to_internal (fv); + } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Raw value %1 float %2\n", val, fv)); float control_min = controllable->lower (); float control_max = controllable->upper (); - const float control_range = control_max - control_min; - + float control_range = control_max - control_min; + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Min %1 Max %2 Range %3\n", control_min, control_max, control_range)); + + AutomationControl *actl = dynamic_cast (controllable); + if (actl) { + if (fv == 0.f) return control_min; + if (fv == 1.f) return control_max; + control_min = actl->internal_to_interface(control_min); + control_max = actl->internal_to_interface(control_max); + control_range = control_max - control_min; + return actl->interface_to_internal((fv * control_range) + control_min); + } return (fv * control_range) + control_min; } @@ -234,15 +264,17 @@ MIDIControllable::lookup_controllable() } void -MIDIControllable::drop_controllable () +MIDIControllable::drop_controllable (Controllable* c) { - set_controllable (0); + if (c == controllable) { + set_controllable (0); + } } void MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool /*is_on*/) { - if (!controllable) { + if (!controllable) { if (lookup_controllable()) { return; } @@ -250,11 +282,14 @@ MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool /*is_on*/) if (!controllable->is_toggle()) { if (control_additional == msg->note_number) { - controllable->set_value (midi_to_control (msg->velocity)); + controllable->set_value (midi_to_control (msg->velocity), Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Note %1 value %2 %3\n", (int) msg->note_number, (float) midi_to_control (msg->velocity), current_uri() )); } } else { if (control_additional == msg->note_number) { - controllable->set_value (controllable->get_value() > 0.5f ? 0.0f : 1.0f); + float new_value = controllable->get_value() > 0.5f ? 0.0f : 1.0f; + controllable->set_value (new_value, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Note %1 Value %2 %3\n", (int) msg->note_number, (float) new_value, current_uri())); } } @@ -264,7 +299,7 @@ MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool /*is_on*/) void MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg) { - if (!controllable) { + if (!controllable) { if (lookup_controllable ()) { return; } @@ -279,34 +314,88 @@ MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg) if (control_additional == msg->controller_number) { if (!controllable->is_toggle()) { + if (get_encoder() == No_enc) { + float new_value = msg->value; + float max_value = max(last_controllable_value, new_value); + float min_value = min(last_controllable_value, new_value); + float range = max_value - min_value; + float threshold = (float) _surface->threshold (); + + bool const in_sync = ( + range < threshold && + controllable->get_value() <= midi_to_control(max_value) && + controllable->get_value() >= midi_to_control(min_value) + ); + + /* If the surface is not motorised, we try to prevent jumps when + the MIDI controller and controllable are out of sync. + There might be a better way of doing this. + */ + + if (in_sync || _surface->motorised ()) { + controllable->set_value (midi_to_control (new_value), Controllable::NoGroup); + } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI CC %1 value %2 %3\n", (int) msg->controller_number, (float) midi_to_control(new_value), current_uri() )); + + last_controllable_value = new_value; + } else { + int offset = (msg->value & 0x3f); + switch (get_encoder()) { + case Enc_L: + if (msg->value > 0x40) { + controllable->set_value (midi_to_control (last_value - offset + 1), Controllable::NoGroup); + } else { + controllable->set_value (midi_to_control (last_value + offset + 1), Controllable::NoGroup); + } + break; + case Enc_R: + if (msg->value > 0x40) { + controllable->set_value (midi_to_control (last_value + offset + 1), Controllable::NoGroup); + } else { + controllable->set_value (midi_to_control (last_value - offset + 1), Controllable::NoGroup); + } + break; + case Enc_2: + if (msg->value > 0x40) { + controllable->set_value (midi_to_control (last_value - (0x7f - msg->value) + 1), Controllable::NoGroup); + } else { + controllable->set_value (midi_to_control (last_value + offset + 1), Controllable::NoGroup); + } + break; + case Enc_B: + if (msg->value > 0x40) { + controllable->set_value (midi_to_control (last_value + offset + 1), Controllable::NoGroup); + } else { + controllable->set_value (midi_to_control (last_value - (0x40 - offset)), Controllable::NoGroup); + } + break; + default: + break; + } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI CC %1 value %2 %3\n", (int) msg->controller_number, (int) last_value, current_uri() )); - float new_value = msg->value; - float max_value = max(last_controllable_value, new_value); - float min_value = min(last_controllable_value, new_value); - float range = max_value - min_value; - float threshold = (float) _surface->threshold (); - - bool const in_sync = ( - range < threshold && - controllable->get_value() <= midi_to_control(max_value) && - controllable->get_value() >= midi_to_control(min_value) - ); - - /* If the surface is not motorised, we try to prevent jumps when - the MIDI controller and controllable are out of sync. - There might be a better way of doing this. - */ - - if (in_sync || _surface->motorised ()) { - controllable->set_value (midi_to_control (new_value)); } - - last_controllable_value = new_value; } else { - if (msg->value > 64.0f) { - controllable->set_value (1); - } else { - controllable->set_value (0); + + /* toggle control: make the toggle flip only if the + * incoming control value exceeds 0.5 (0x40), so that + * the typical button which sends "CC N=0x7f" on press + * and "CC N=0x0" on release can be used to drive + * toggles on press. + * + * No other arrangement really makes sense for a toggle + * controllable. Acting on the press+release makes the + * action momentary, which is almost never + * desirable. If the physical button only sends a + * message on press (or release), then it will be + * expected to send a controller value >= 0.5 + * (0x40). It is hard to imagine why anyone would make + * a MIDI controller button that sent 0x0 when pressed. + */ + + if (msg->value >= 0x40) { + controllable->set_value (controllable->get_value() >= 0.5 ? 0.0 : 1.0, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Midi CC %1 value 1 %2\n", (int) msg->controller_number, current_uri())); } } @@ -317,16 +406,21 @@ MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg) void MIDIControllable::midi_sense_program_change (Parser &, MIDI::byte msg) { - if (!controllable) { + if (!controllable) { if (lookup_controllable ()) { return; } } + if (msg == control_additional) { - if (!controllable->is_toggle()) { - controllable->set_value (midi_to_control (msg)); - } else if (msg == control_additional) { - controllable->set_value (controllable->get_value() > 0.5f ? 0.0f : 1.0f); + if (!controllable->is_toggle()) { + controllable->set_value (1.0, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI program %1 value 1.0 %3\n", (int) msg, current_uri() )); + } else { + float new_value = controllable->get_value() > 0.5f ? 0.0f : 1.0f; + controllable->set_value (new_value, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI program %1 value %2 %3\n", (int) msg, (float) new_value, current_uri())); + } } last_value = (MIDI::byte) (controllable->get_value() * 127.0); // to prevent feedback fights @@ -335,16 +429,23 @@ MIDIControllable::midi_sense_program_change (Parser &, MIDI::byte msg) void MIDIControllable::midi_sense_pitchbend (Parser &, pitchbend_t pb) { - if (!controllable) { + if (!controllable) { if (lookup_controllable ()) { return; } } if (!controllable->is_toggle()) { - controllable->set_value (midi_to_control (pb)); + controllable->set_value (midi_to_control (pb), Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI pitchbend %1 value %2 %3\n", (int) control_channel, (float) midi_to_control (pb), current_uri() )); } else { - controllable->set_value (controllable->get_value() > 0.5f ? 0.0f : 1.0f); + if (pb > 8065.0f) { + controllable->set_value (1, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Midi pitchbend %1 value 1 %2\n", (int) control_channel, current_uri())); + } else { + controllable->set_value (0, Controllable::NoGroup); + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Midi pitchbend %1 value 0 %2\n", (int) control_channel, current_uri())); + } } last_value = control_to_midi (controllable->get_value ()); @@ -359,6 +460,7 @@ MIDIControllable::midi_receiver (Parser &, MIDI::byte *msg, size_t /*len*/) return; } + _surface->check_used_event(msg[0], msg[1]); bind_midi ((channel_t) (msg[0] & 0xf), eventType (msg[0] & 0xF0), msg[1]); if (controllable) { @@ -366,6 +468,88 @@ MIDIControllable::midi_receiver (Parser &, MIDI::byte *msg, size_t /*len*/) } } +void +MIDIControllable::rpn_value_change (Parser&, uint16_t rpn, float val) +{ + if (control_rpn == rpn) { + if (controllable) { + controllable->set_value (val, Controllable::NoGroup); + } + } +} + +void +MIDIControllable::nrpn_value_change (Parser&, uint16_t nrpn, float val) +{ + if (control_nrpn == nrpn) { + if (controllable) { + controllable->set_value (val, Controllable::NoGroup); + } + } +} + +void +MIDIControllable::rpn_change (Parser&, uint16_t rpn, int dir) +{ + if (control_rpn == rpn) { + if (controllable) { + /* XXX how to increment/decrement ? */ + // controllable->set_value (val); + } + } +} + +void +MIDIControllable::nrpn_change (Parser&, uint16_t nrpn, int dir) +{ + if (control_nrpn == nrpn) { + if (controllable) { + /* XXX how to increment/decrement ? */ + // controllable->set_value (val); + } + } +} + +void +MIDIControllable::bind_rpn_value (channel_t chn, uint16_t rpn) +{ + int chn_i = chn; + drop_external_control (); + control_rpn = rpn; + control_channel = chn; + _parser.channel_rpn[chn_i].connect_same_thread (midi_sense_connection[0], boost::bind (&MIDIControllable::rpn_value_change, this, _1, _2, _3)); +} + +void +MIDIControllable::bind_nrpn_value (channel_t chn, uint16_t nrpn) +{ + int chn_i = chn; + drop_external_control (); + control_nrpn = nrpn; + control_channel = chn; + _parser.channel_nrpn[chn_i].connect_same_thread (midi_sense_connection[0], boost::bind (&MIDIControllable::rpn_value_change, this, _1, _2, _3)); +} + +void +MIDIControllable::bind_nrpn_change (channel_t chn, uint16_t nrpn) +{ + int chn_i = chn; + drop_external_control (); + control_nrpn = nrpn; + control_channel = chn; + _parser.channel_nrpn_change[chn_i].connect_same_thread (midi_sense_connection[0], boost::bind (&MIDIControllable::rpn_change, this, _1, _2, _3)); +} + +void +MIDIControllable::bind_rpn_change (channel_t chn, uint16_t rpn) +{ + int chn_i = chn; + drop_external_control (); + control_rpn = rpn; + control_channel = chn; + _parser.channel_rpn_change[chn_i].connect_same_thread (midi_sense_connection[0], boost::bind (&MIDIControllable::nrpn_change, this, _1, _2, _3)); +} + void MIDIControllable::bind_midi (channel_t chn, eventType ev, MIDI::byte additional) { @@ -388,7 +572,7 @@ MIDIControllable::bind_midi (channel_t chn, eventType ev, MIDI::byte additional) if (_momentary) { _parser.channel_note_on[chn_i].connect_same_thread (midi_sense_connection[1], boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2)); - } + } _control_description = "MIDI control: NoteOff"; break; @@ -400,7 +584,7 @@ MIDIControllable::bind_midi (channel_t chn, eventType ev, MIDI::byte additional) } _control_description = "MIDI control: NoteOn"; break; - + case MIDI::controller: _parser.channel_controller[chn_i].connect_same_thread (midi_sense_connection[0], boost::bind (&MIDIControllable::midi_sense_controller, this, _1, _2)); snprintf (buf, sizeof (buf), "MIDI control: Controller %d", control_additional); @@ -420,36 +604,109 @@ MIDIControllable::bind_midi (channel_t chn, eventType ev, MIDI::byte additional) default: break; } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Controlable: bind_midi: %1 on Channel %2 value %3 \n", _control_description, chn_i + 1, (int) additional)); } MIDI::byte* MIDIControllable::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool /*force*/) { - if (!controllable || control_type == none || !feedback || bufsize <= 2) { + if (!controllable || !feedback) { + return buf; + } + + float val = controllable->get_value (); + + /* Note that when sending RPN/NPRN we do two things: + * + * always send MSB first, then LSB + * null/reset the parameter ID after sending. + * + * this follows recommendations found online, eg. http://www.philrees.co.uk/nrpnq.htm + */ + + if (control_rpn >= 0) { + if (bufsize < 13) { + return buf; + } + int rpn_val = (int) lrintf (val * 16384.0); + if (last_value == rpn_val) { + return buf; + } + *buf++ = (0xb0) | control_channel; + *buf++ = 0x62; + *buf++ = (int) ((control_rpn) >> 7); + *buf++ = 0x63; + *buf++ = (int) (control_rpn & 0x7f); + *buf++ = 0x06; + *buf++ = (int) (rpn_val >> 7); + *buf++ = 0x26; + *buf++ = (int) (rpn_val & 0x7f); + *buf++ = 0x62; + *buf++ = 0x7f; + *buf++ = 0x63; + *buf++ = 0x7f; + bufsize -= 13; + last_value = rpn_val; + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI out: RPN %1 Channel %2 Value %3\n", control_rpn, (int) control_channel, val)); return buf; } - - int const gm = control_to_midi (controllable->get_value()); + + if (control_nrpn >= 0) { + int rpn_val = (int) lrintf (val * 16384.0); + if (last_value == rpn_val) { + return buf; + } + *buf++ = (0xb0) | control_channel; + *buf++ = 0x64; + *buf++ = (int) ((control_rpn) >> 7); + *buf++ = 0x65; + *buf++ = (int) (control_rpn & 0x7f); + *buf++ = 0x06; + *buf++ = (int) (rpn_val >> 7); + *buf++ = 0x26; + *buf++ = (int) (rpn_val & 0x7f); + *buf++ = 0x64; + *buf++ = 0x7f; + *buf++ = 0x65; + *buf++ = 0x7f; + last_value = rpn_val; + bufsize -= 13; + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI out: NRPN %1 Channel %2 Value %3\n", control_nrpn, (int) control_channel, val)); + return buf; + } + + if (control_type == none || bufsize <= 2) { + return buf; + } + + int const gm = control_to_midi (val); if (gm == last_value) { return buf; } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Feedback: %1 %2\n", control_description(), current_uri())); + *buf++ = (0xF0 & control_type) | (0xF & control_channel); - + int ev_size = 3; switch (control_type) { case MIDI::pitchbend: *buf++ = int (gm) & 127; *buf++ = (int (gm) >> 7) & 127; break; + case MIDI::program: + *buf++ = control_additional; /* program number */ + ev_size = 2; + break; default: *buf++ = control_additional; /* controller number */ *buf++ = gm; break; } + DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("MIDI out: Type %1 Channel %2 Bytes %3 %4\n", (int) control_type, (int) control_channel , (int) *(buf - 2), (int) *(buf - 1))); last_value = gm; - bufsize -= 3; + bufsize -= ev_size; return buf; } @@ -525,7 +782,7 @@ int MIDIControllable::max_value_for_type () const { /* XXX: this is not complete */ - + if (control_type == MIDI::pitchbend) { return 16383; }