2 * Copyright (C) 2017 Robin Gareus <robin@gareus.org>
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 #include "ardour/automation_control.h"
20 #include "ardour/gain_control.h"
21 #include "ardour/meter.h"
22 #include "ardour/plugin_insert.h"
23 #include "ardour/session.h"
24 #include "ardour/stripable.h"
25 #include "ardour/track.h"
26 #include "ardour/value_as_string.h"
28 #include "control_protocol/control_protocol.h"
30 #include "fp8_strip.h"
32 using namespace ARDOUR;
33 using namespace ArdourSurface::FP_NAMESPACE;
34 using namespace ArdourSurface::FP_NAMESPACE::FP8Types;
37 FP8Strip::midi_ctrl_id (CtrlElement type, uint8_t id)
39 assert (id < N_STRIPS);
67 if (id == 0) { // strip 8
88 FP8Strip::FP8Strip (FP8Base& b, uint8_t id)
91 , _solo (b, midi_ctrl_id (BtnSolo, id))
92 , _mute (b, midi_ctrl_id (BtnMute, id))
93 , _selrec (b, midi_ctrl_id (BtnSelect, id), true)
97 , _displaymode (Stripables)
99 assert (id < N_STRIPS);
102 _last_meter = _last_redux = _last_barpos = 0xff;
104 _mute.StateChange.connect_same_thread (_button_connections, boost::bind (&FP8Strip::set_mute, this, _1));
105 _solo.StateChange.connect_same_thread (_button_connections, boost::bind (&FP8Strip::set_solo, this, _1));
106 select_button ().released.connect_same_thread (_button_connections, boost::bind (&FP8Strip::set_select, this));
107 recarm_button ().released.connect_same_thread (_button_connections, boost::bind (&FP8Strip::set_recarm, this));
108 b.Periodic.connect_same_thread (_base_connection, boost::bind (&FP8Strip::periodic, this));
111 FP8Strip::~FP8Strip ()
113 drop_automation_controls ();
114 _base_connection.disconnect ();
115 _button_connections.drop_connections ();
119 FP8Strip::drop_automation_controls ()
121 _fader_connection.disconnect ();
122 _mute_connection.disconnect ();
123 _solo_connection.disconnect ();
124 _rec_connection.disconnect ();
125 _pan_connection.disconnect ();
126 _x_select_connection.disconnect ();
128 _fader_ctrl.reset ();
133 _x_select_ctrl.reset ();
134 _peak_meter.reset ();
135 _redux_ctrl.reset ();
136 _select_plugin_functor.clear ();
140 FP8Strip::initialize ()
142 /* this is called once midi transmission is possible,
143 * ie from FaderPort8::connected()
145 _solo.set_active (false);
146 _solo.set_blinking (false);
147 _mute.set_active (false);
149 /* reset momentary button state */
153 drop_automation_controls ();
155 select_button ().set_color (0xffffffff);
156 select_button ().set_active (false);
157 select_button ().set_blinking (false);
159 recarm_button ().set_active (false);
160 recarm_button ().set_color (0xffffffff);
162 set_strip_mode (0, true);
165 _last_line[0].clear ();
166 _last_line[1].clear ();
167 _last_line[2].clear ();
168 _last_line[3].clear ();
169 _base.tx_sysex (4, 0x12, _id, 0x00, 0x00);
170 _base.tx_sysex (4, 0x12, _id, 0x01, 0x00);
171 _base.tx_sysex (4, 0x12, _id, 0x02, 0x00);
172 _base.tx_sysex (4, 0x12, _id, 0x03, 0x00);
174 set_bar_mode (4); // off
176 _base.tx_midi2 (midi_ctrl_id (Meter, _id), 0); // reset meter
177 _base.tx_midi2 (midi_ctrl_id (Redux, _id), 0); // reset redux
179 _base.tx_midi3 (midi_ctrl_id (Fader, _id), 0, 0); // fader
181 /* clear cached values */
183 _last_meter = _last_redux = _last_barpos = 0xff;
187 #define GENERATE_SET_CTRL_FUNCTION(NAME) \
189 FP8Strip::set_ ##NAME##_controllable (boost::shared_ptr<AutomationControl> ac) \
191 if (_##NAME##_ctrl == ac) { \
194 _##NAME##_connection.disconnect(); \
195 _##NAME##_ctrl = ac; \
198 ac->Changed.connect (_##NAME##_connection, MISSING_INVALIDATOR, \
199 boost::bind (&FP8Strip::notify_##NAME##_changed, this), fp8_context()); \
201 notify_##NAME##_changed (); \
205 GENERATE_SET_CTRL_FUNCTION (fader)
206 GENERATE_SET_CTRL_FUNCTION (mute)
207 GENERATE_SET_CTRL_FUNCTION (solo)
208 GENERATE_SET_CTRL_FUNCTION (rec)
209 GENERATE_SET_CTRL_FUNCTION (pan)
210 GENERATE_SET_CTRL_FUNCTION (x_select)
212 #undef GENERATE_SET_CTRL_FUNCTION
214 // special case -- w/_select_plugin_functor
216 FP8Strip::set_select_controllable (boost::shared_ptr<AutomationControl> ac)
218 _select_plugin_functor.clear ();
219 set_x_select_controllable (ac);
223 FP8Strip::set_select_cb (boost::function<void ()>& functor)
225 set_select_controllable (boost::shared_ptr<AutomationControl>());
226 _select_plugin_functor = functor;
230 FP8Strip::unset_controllables (int which)
232 _peak_meter = boost::shared_ptr<ARDOUR::PeakMeter>();
233 _redux_ctrl = boost::shared_ptr<ARDOUR::ReadOnlyControl>();
234 _stripable_name.clear ();
236 if (which & CTRL_FADER) {
237 set_fader_controllable (boost::shared_ptr<AutomationControl>());
239 if (which & CTRL_MUTE) {
240 set_mute_controllable (boost::shared_ptr<AutomationControl>());
242 if (which & CTRL_SOLO) {
243 set_solo_controllable (boost::shared_ptr<AutomationControl>());
245 if (which & CTRL_REC) {
246 set_rec_controllable (boost::shared_ptr<AutomationControl>());
248 if (which & CTRL_PAN) {
249 set_pan_controllable (boost::shared_ptr<AutomationControl>());
251 if (which & CTRL_SELECT) {
252 set_select_controllable (boost::shared_ptr<AutomationControl>());
253 select_button ().set_color (0xffffffff);
254 select_button ().set_active (false);
255 select_button ().set_blinking (false);
257 if (which & CTRL_TEXT0) {
258 set_text_line (0, "");
260 if (which & CTRL_TEXT1) {
261 set_text_line (1, "");
263 if (which & CTRL_TEXT2) {
264 set_text_line (2, "");
266 if (which & CTRL_TEXT3) {
267 set_text_line (3, "");
269 set_bar_mode (4); // Off
273 FP8Strip::set_strip_name ()
275 size_t lb = _base.show_meters () ? 6 : 9;
276 set_text_line (0, _stripable_name.substr (0, lb));
277 set_text_line (1, _stripable_name.length() > lb ? _stripable_name.substr (lb) : "");
281 FP8Strip::set_stripable (boost::shared_ptr<Stripable> s, bool panmode)
285 if (_base.show_meters () && _base.show_panner ()) {
286 set_strip_mode (5, true);
287 } else if (_base.show_meters ()) {
288 set_strip_mode (4, true);
290 set_strip_mode (0, true);
292 if (!_base.show_panner ()) {
293 set_bar_mode (4, true); // Off
297 set_fader_controllable (s->pan_azimuth_control ());
299 set_fader_controllable (s->gain_control ());
301 set_pan_controllable (s->pan_azimuth_control ());
303 if (s->is_monitor ()) {
304 set_mute_controllable (boost::shared_ptr<AutomationControl>());
306 set_mute_controllable (s->mute_control ());
308 set_solo_controllable (s->solo_control ());
310 if (boost::dynamic_pointer_cast<Track> (s)) {
311 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(s);
312 set_rec_controllable (t->rec_enable_control ());
313 recarm_button ().set_color (0xff0000ff);
315 set_rec_controllable (boost::shared_ptr<AutomationControl>());
316 recarm_button ().set_color (0xffffffff);
317 recarm_button ().set_active (false);
319 _peak_meter = s->peak_meter ();
320 _redux_ctrl = s->comp_redux_controllable ();
322 set_select_controllable (boost::shared_ptr<AutomationControl>());
323 select_button ().set_active (s->is_selected ());
324 select_button ().set_color (s->presentation_info ().color());
325 //select_button ().set_blinking (false);
327 _stripable_name = s->name ();
329 if (_base.twolinetext ()) {
332 set_text_line (0, s->name ());
333 set_text_line (1, _pan_ctrl ? _pan_ctrl->get_user_string () : "");
335 set_text_line (2, "");
336 set_text_line (3, "");
339 /* *****************************************************************************
340 * Parse Strip Specifig MIDI Events
344 FP8Strip::midi_touch (bool t)
347 boost::shared_ptr<AutomationControl> ac = _fader_ctrl;
352 ac->start_touch (ac->session().transport_sample());
354 ac->stop_touch (ac->session().transport_sample());
360 FP8Strip::midi_fader (float val)
362 assert (val >= 0.f && val <= 1.f);
366 boost::shared_ptr<AutomationControl> ac = _fader_ctrl;
370 ac->start_touch (ac->session().transport_sample());
371 ac->set_value (ac->interface_to_internal (val), group_mode ());
375 /* *****************************************************************************
376 * Actions from Controller, Update Model
379 PBD::Controllable::GroupControlDisposition
380 FP8Strip::group_mode () const
382 if (_base.shift_mod ()) {
383 return PBD::Controllable::InverseGroup;
385 return PBD::Controllable::UseGroup;
390 FP8Strip::set_mute (bool on)
395 _mute_ctrl->start_touch (_mute_ctrl->session().transport_sample());
396 _mute_ctrl->set_value (on ? 1.0 : 0.0, group_mode ());
400 FP8Strip::set_solo (bool on)
405 _solo_ctrl->start_touch (_solo_ctrl->session().transport_sample());
406 _solo_ctrl->set_value (on ? 1.0 : 0.0, group_mode ());
410 FP8Strip::set_recarm ()
415 const bool on = !recarm_button ().is_active();
416 _rec_ctrl->set_value (on ? 1.0 : 0.0, group_mode ());
420 FP8Strip::set_select ()
422 if (!_select_plugin_functor.empty ()) {
423 assert (!_x_select_ctrl);
424 _select_plugin_functor ();
425 } else if (_x_select_ctrl) {
426 _x_select_ctrl->start_touch (_x_select_ctrl->session().transport_sample());
427 const bool on = !select_button ().is_active();
428 _x_select_ctrl->set_value (on ? 1.0 : 0.0, group_mode ());
432 /* *****************************************************************************
433 * Callbacks from Stripable, Update View
437 FP8Strip::notify_fader_changed ()
439 boost::shared_ptr<AutomationControl> ac = _fader_ctrl;
445 val = ac->internal_to_interface (ac->get_value());
446 val = std::max (0.f, std::min (1.f, val)) * 16368.f; /* 16 * 1023 */
448 unsigned short mv = lrintf (val);
449 if (mv == _last_fader) {
453 _base.tx_midi3 (midi_ctrl_id (Fader, _id), (mv & 0x7f), (mv >> 7) & 0x7f);
457 FP8Strip::notify_solo_changed ()
460 boost::shared_ptr<SoloControl> sc = boost::dynamic_pointer_cast<SoloControl> (_solo_ctrl);
462 _solo.set_blinking (sc->soloed_by_others () && !sc->self_soloed ());
463 _solo.set_active (sc->self_soloed ());
465 _solo.set_blinking (false);
466 _solo.set_active (_solo_ctrl->get_value () > 0);
469 _solo.set_blinking (false);
470 _solo.set_active (false);
475 FP8Strip::notify_mute_changed ()
478 _mute.set_active (_mute_ctrl->get_value () > 0);
480 _mute.set_active (false);
485 FP8Strip::notify_rec_changed ()
488 recarm_button ().set_active (_rec_ctrl->get_value() > 0.);
490 recarm_button ().set_active (false);
495 FP8Strip::notify_pan_changed ()
501 FP8Strip::notify_x_select_changed ()
503 if (!_select_plugin_functor.empty ()) {
504 assert (!_x_select_ctrl);
508 if (_x_select_ctrl) {
509 assert (_select_plugin_functor.empty ());
510 select_button ().set_active (_x_select_ctrl->get_value() > 0.);
511 select_button ().set_color (0xffff00ff);
512 select_button ().set_blinking (false);
516 /* *****************************************************************************
517 * Periodic View Updates
521 FP8Strip::periodic_update_fader ()
523 boost::shared_ptr<AutomationControl> ac = _fader_ctrl;
524 if (!ac || _touching) {
528 if (!ac->automation_playback ()) {
531 notify_fader_changed ();
535 FP8Strip::set_periodic_display_mode (DisplayMode m) {
537 if (_displaymode == SendDisplay || _displaymode == PluginParam) {
538 // need to change to 4 lines before calling set_text()
539 set_strip_mode (2); // 4 lines of small text
544 FP8Strip::periodic_update_meter ()
546 bool show_meters = _base.show_meters ();
547 bool have_meter = false;
548 bool have_panner = false;
550 if (_peak_meter && show_meters) {
552 float dB = _peak_meter->meter_level (0, MeterMCP);
553 // TODO: deflect meter
554 int val = std::min (127.f, std::max (0.f, 2.f * dB + 127.f));
555 if (val != _last_meter || val > 0) {
556 _base.tx_midi2 (midi_ctrl_id (Meter, _id), val & 0x7f); // falls off automatically
560 } else if (show_meters) {
561 if (0 != _last_meter) {
562 _base.tx_midi2 (midi_ctrl_id (Meter, _id), 0);
567 // show redux only if there's a meter, too (strip display mode 5)
568 if (_peak_meter && _redux_ctrl && show_meters) {
569 float rx = (1.f - _redux_ctrl->get_parameter ()) * 127.f;
570 // TODO: deflect redux
571 int val = std::min (127.f, std::max (0.f, rx));
572 if (val != _last_redux) {
573 _base.tx_midi2 (midi_ctrl_id (Redux, _id), val & 0x7f);
576 } else if (show_meters) {
577 if (0 != _last_redux) {
578 _base.tx_midi2 (midi_ctrl_id (Redux, _id), 0);
583 if (_displaymode == PluginParam) {
585 set_bar_mode (2); // Fill
586 set_text_line (2, value_as_string(_fader_ctrl->desc(), _fader_ctrl->get_value()));
587 float barpos = _fader_ctrl->internal_to_interface (_fader_ctrl->get_value());
588 int val = std::min (127.f, std::max (0.f, barpos * 128.f));
589 if (val != _last_barpos) {
590 _base.tx_midi3 (0xb0, midi_ctrl_id (BarVal, _id), val & 0x7f);
594 set_bar_mode (4); // Off
595 set_text_line (2, "");
598 else if (_displaymode == PluginSelect) {
599 set_bar_mode (4); // Off
601 else if (_displaymode == SendDisplay) {
602 set_bar_mode (4); // Off
604 set_text_line (1, value_as_string(_fader_ctrl->desc(), _fader_ctrl->get_value()));
606 set_text_line (1, "");
608 } else if (_pan_ctrl) {
609 have_panner = _base.show_panner ();
610 float panpos = _pan_ctrl->internal_to_interface (_pan_ctrl->get_value());
611 int val = std::min (127.f, std::max (0.f, panpos * 128.f));
612 set_bar_mode (have_panner ? 1 : 4); // Bipolar or Off
613 if (val != _last_barpos && have_panner) {
614 _base.tx_midi3 (0xb0, midi_ctrl_id (BarVal, _id), val & 0x7f);
617 if (_base.twolinetext ()) {
620 set_text_line (1, _pan_ctrl->get_user_string ());
623 set_bar_mode (4); // Off
624 if (_base.twolinetext ()) {
627 set_text_line (1, "");
631 if (_displaymode == SendDisplay || _displaymode == PluginParam) {
632 set_strip_mode (2); // 4 lines of small text + value-bar
634 else if (have_meter && have_panner) {
635 set_strip_mode (5); // small meters + 3 lines of text (3rd is large) + value-bar
637 else if (have_meter) {
638 set_strip_mode (4); // big meters + 3 lines of text (3rd line is large)
640 else if (have_panner) {
641 set_strip_mode (0); // 3 lines of text (3rd line is large + long) + value-bar
643 set_strip_mode (0); // 3 lines of text (3rd line is large + long) + value-bar
648 FP8Strip::set_strip_mode (uint8_t strip_mode, bool clear)
650 if (strip_mode == _strip_mode && !clear) {
654 _strip_mode = strip_mode;
655 _base.tx_sysex (3, 0x13, _id, (_strip_mode & 0x07) | (clear ? 0x10 : 0));
658 /* work-around, when swiching modes, the FP8 may not
659 * properly redraw long lines. Only update lines 0, 1
660 * (line 2 is timecode, line 3 may be inverted)
662 _base.tx_text (_id, 0, 0x00, _last_line[0]);
663 _base.tx_text (_id, 1, 0x00, _last_line[1]);
668 FP8Strip::set_bar_mode (uint8_t bar_mode, bool force)
670 if (bar_mode == _bar_mode && !force) {
675 _base.tx_midi3 (0xb0, midi_ctrl_id (BarVal, _id), 0);
679 _bar_mode = bar_mode;
680 _base.tx_midi3 (0xb0, midi_ctrl_id (BarMode, _id), bar_mode);
684 FP8Strip::set_text_line (uint8_t line, std::string const& txt, bool inv)
687 if (_last_line[line] == txt) {
690 _base.tx_text (_id, line, inv ? 0x04 : 0x00, txt);
691 _last_line[line] = txt;
695 FP8Strip::periodic_update_timecode (uint32_t m)
702 std::string const& tc = mc ? _base.musical_time () : _base.timecode();
704 if (tc.size () == 12) {
705 t = tc.substr (1 + (_id - (mc ? 4 : 0)) * 3, 2);
707 set_text_line (2, t);
708 } else if (_id >= 2 && _id < 6) {
709 std::string const& tc = (m == 2) ? _base.musical_time () : _base.timecode();
710 //" HH:MM:SS:FF" or " BR|BT|TI|CK"
712 if (tc.size () == 12) {
713 t = tc.substr (1 + (_id - 2) * 3, 2);
715 set_text_line (2, t);
717 set_text_line (2, "");
722 FP8Strip::periodic ()
724 periodic_update_fader ();
725 periodic_update_meter ();
726 if (_displaymode != PluginSelect && _displaymode != PluginParam) {
727 periodic_update_timecode (_base.clock_mode ());