X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fsurfaces%2Fmackie%2Fstrip.cc;h=4def2bc6ec15c3ac281ebd2cad1d0393e2694b00;hb=84d44eb5a3fd95f20f9c5e33ff8c05199dcccc38;hp=70a7cb90fd5eb0efd9ae980b52a25672769ea8b8;hpb=0fdb846625d6b047b8cef0db58e3f91c0fad2aac;p=ardour.git diff --git a/libs/surfaces/mackie/strip.cc b/libs/surfaces/mackie/strip.cc index 70a7cb90fd..4def2bc6ec 100644 --- a/libs/surfaces/mackie/strip.cc +++ b/libs/surfaces/mackie/strip.cc @@ -43,6 +43,7 @@ #include "ardour/session.h" #include "ardour/send.h" #include "ardour/track.h" +#include "ardour/midi_track.h" #include "ardour/user_bundle.h" #include "mackie_control_protocol.h" @@ -55,10 +56,11 @@ #include "jog.h" #include "meter.h" -using namespace Mackie; using namespace std; using namespace ARDOUR; using namespace PBD; +using namespace ArdourSurface; +using namespace Mackie; #ifndef timeradd /// only avail with __USE_BSD #define timeradd(a,b,result) \ @@ -91,10 +93,15 @@ Strip::Strip (Surface& s, const std::string& name, int index, const map (Fader::factory (*_surface, index, "fader", *this)); _vpot = dynamic_cast (Pot::factory (*_surface, Pot::ID + index, "vpot", *this)); @@ -106,17 +113,17 @@ Strip::Strip (Surface& s, const std::string& name, int index, const map::const_iterator b = strip_buttons.begin(); b != strip_buttons.end(); ++b) { Button* bb = dynamic_cast (Button::factory (*_surface, b->first, b->second.base_id + index, b->second.name, *this)); DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface %1 strip %2 new button BID %3 id %4 from base %5\n", - _surface->number(), index, Button::id_to_name (bb->bid()), + _surface->number(), index, Button::id_to_name (bb->bid()), bb->id(), b->second.base_id)); } -} +} Strip::~Strip () { /* surface is responsible for deleting all controls */ } -void +void Strip::add (Control & control) { Button* button; @@ -159,7 +166,7 @@ Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) } route_connections.drop_connections (); - + _solo->set_control (boost::shared_ptr()); _mute->set_control (boost::shared_ptr()); _select->set_control (boost::shared_ptr()); @@ -170,6 +177,16 @@ Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) _route = r; control_by_parameter.clear (); + + control_by_parameter[PanAzimuthAutomation] = (Control*) 0; + control_by_parameter[PanWidthAutomation] = (Control*) 0; + control_by_parameter[PanElevationAutomation] = (Control*) 0; + control_by_parameter[PanFrontBackAutomation] = (Control*) 0; + control_by_parameter[PanLFEAutomation] = (Control*) 0; + control_by_parameter[GainAutomation] = (Control*) 0; + control_by_parameter[TrimAutomation] = (Control*) 0; + control_by_parameter[PhaseAutomation] = (Control*) 0; + reset_saved_values (); if (!r) { @@ -179,17 +196,24 @@ Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now mapping route %3\n", _surface->number(), _index, _route->name())); - + _solo->set_control (_route->solo_control()); _mute->set_control (_route->mute_control()); - set_vpot_parameter (PanAzimuthAutomation); - _route->solo_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_solo_changed, this), ui_context()); _route->listen_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_solo_changed, this), ui_context()); _route->mute_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_mute_changed, this), ui_context()); + if (_route->trim() && route()->trim()->active()) { + _route->trim_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trim_changed, this, false), ui_context()); + } + + if (_route->phase_invert().size()) { + _route->phase_invert_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_phase_changed, this, false), ui_context()); + _route->phase_control()->set_channel(0); + } + boost::shared_ptr pannable = _route->pannable(); if (pannable && _route->panner()) { @@ -198,30 +222,23 @@ Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) } _route->gain_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_gain_changed, this, false), ui_context()); _route->PropertyChanged.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_property_changed, this, _1), ui_context()); - + boost::shared_ptr trk = boost::dynamic_pointer_cast(_route); - + if (trk) { _recenable->set_control (trk->rec_enable_control()); trk->rec_enable_control()->Changed .connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_record_enable_changed, this), ui_context()); - + } - + // TODO this works when a currently-banked route is made inactive, but not // when a route is activated which should be currently banked. - + _route->active_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_active_changed, this), ui_context()); _route->DropReferences.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_route_deleted, this), ui_context()); - - /* Update */ - - notify_all (); /* setup legal VPot modes for this route */ - - build_input_list (_route->input()->n_ports()); - build_output_list (_route->output()->n_ports()); possible_pot_parameters.clear(); @@ -230,19 +247,43 @@ Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) if (panner) { set automatable = panner->what_can_be_automated (); set::iterator a; - + if ((a = automatable.find (PanAzimuthAutomation)) != automatable.end()) { possible_pot_parameters.push_back (PanAzimuthAutomation); } - + if ((a = automatable.find (PanWidthAutomation)) != automatable.end()) { possible_pot_parameters.push_back (PanWidthAutomation); } } } + + if (_route->trim() && route()->trim()->active()) { + possible_pot_parameters.push_back (TrimAutomation); + } + + possible_trim_parameters.clear(); + + if (_route->trim() && route()->trim()->active()) { + possible_trim_parameters.push_back (TrimAutomation); + _trim_mode = TrimAutomation; + } + + if (_route->phase_invert().size()) { + possible_trim_parameters.push_back (PhaseAutomation); + if (_trim_mode != TrimAutomation) { + _trim_mode = PhaseAutomation; + } + } + + /* Update */ + _pan_mode = PanAzimuthAutomation; + potmode_changed (false); + notify_all (); + } -void +void Strip::notify_all() { if (!_route) { @@ -257,9 +298,11 @@ Strip::notify_all() notify_panner_azi_changed (); notify_panner_width_changed (); notify_record_enable_changed (); + notify_trim_changed (); + notify_phase_changed (); } -void +void Strip::notify_solo_changed () { if (_route && _solo) { @@ -267,7 +310,7 @@ Strip::notify_solo_changed () } } -void +void Strip::notify_mute_changed () { DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Strip %1 mute changed\n", _index)); @@ -279,7 +322,7 @@ Strip::notify_mute_changed () } } -void +void Strip::notify_record_enable_changed () { if (_route && _recenable) { @@ -287,23 +330,23 @@ Strip::notify_record_enable_changed () } } -void +void Strip::notify_active_changed () { _surface->mcp().refresh_current_bank(); } -void +void Strip::notify_route_deleted () { _surface->mcp().refresh_current_bank(); } -void +void Strip::notify_gain_changed (bool force_update) { if (_route) { - + Control* control; if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { @@ -313,52 +356,129 @@ Strip::notify_gain_changed (bool force_update) } boost::shared_ptr ac = _route->gain_control(); - + float gain_coefficient = ac->get_value(); float normalized_position = ac->internal_to_interface (gain_coefficient); + if (force_update || normalized_position != _last_gain_position_written) { - + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { if (!control->in_use()) { _surface->write (_vpot->set (normalized_position, true, Pot::wrap)); } - do_parameter_display (GainAutomation, gain_coefficient); + queue_parameter_display (GainAutomation, gain_coefficient); } else { if (!control->in_use()) { _surface->write (_fader->set_position (normalized_position)); } - do_parameter_display (GainAutomation, gain_coefficient); + queue_parameter_display (GainAutomation, gain_coefficient); } - queue_display_reset (2000); _last_gain_position_written = normalized_position; } } } -void +void +Strip::notify_trim_changed (bool force_update) +{ + if (_route) { + + if (!_route->trim() || !route()->trim()->active()) { + _surface->write (_vpot->zero()); + return; + } + Control* control = 0; + ControlParameterMap::iterator i = control_by_parameter.find (TrimAutomation); + + if (i == control_by_parameter.end()) { + return; + } + + control = i->second; + + boost::shared_ptr ac = _route->trim_control(); + + float gain_coefficient = ac->get_value(); + float normalized_position = ac->internal_to_interface (gain_coefficient); + + if (force_update || normalized_position != _last_trim_position_written) { + if (control == _fader) { + if (!_fader->in_use()) { + _surface->write (_fader->set_position (normalized_position)); + queue_parameter_display (TrimAutomation, gain_coefficient); + } + } else if (control == _vpot) { + _surface->write (_vpot->set (normalized_position, true, Pot::dot)); + queue_parameter_display (TrimAutomation, gain_coefficient); + } + _last_trim_position_written = normalized_position; + } + } +} + +void +Strip::notify_phase_changed (bool force_update) +{ + if (_route) { + if (!_route->phase_invert().size()) { + _surface->write (_vpot->zero()); + return; + } + + Control* control = 0; + ControlParameterMap::iterator i = control_by_parameter.find (PhaseAutomation); + + if (i == control_by_parameter.end()) { + return; + } + + control = i->second; + + float normalized_position = _route->phase_control()->get_value(); + + if (control == _fader) { + if (!_fader->in_use()) { + _surface->write (_fader->set_position (normalized_position)); + queue_parameter_display (PhaseAutomation, normalized_position); + } + } else if (control == _vpot) { + _surface->write (_vpot->set (normalized_position, true, Pot::wrap)); + queue_parameter_display (PhaseAutomation, normalized_position); + } + } +} + +void Strip::notify_property_changed (const PropertyChange& what_changed) { if (!what_changed.contains (ARDOUR::Properties::name)) { return; } - if (_route) { - string line1; - string fullname = _route->name(); - - if (fullname.length() <= 6) { - line1 = fullname; - } else { - line1 = PBD::short_version (fullname, 6); - } - - _surface->write (display (0, line1)); + show_route_name (); +} + +void +Strip::show_route_name () +{ + if (!_route) { + return; + } + string line1; + string fullname = _route->name(); + + if (fullname.length() <= 6) { + line1 = fullname; + } else { + line1 = PBD::short_version (fullname, 6); } + + _surface->write (display (0, line1)); } -void +void Strip::notify_panner_azi_changed (bool force_update) { if (_route) { @@ -372,32 +492,35 @@ Strip::notify_panner_azi_changed (bool force_update) return; } - Control* control = control_by_parameter[PanAzimuthAutomation]; + Control* control = 0; + ControlParameterMap::iterator i = control_by_parameter.find (PanAzimuthAutomation); - if (!control) { + if (i == control_by_parameter.end()) { return; } + control = i->second; + double pos = pannable->pan_azimuth_control->internal_to_interface (pannable->pan_azimuth_control->get_value()); - + if (force_update || pos != _last_pan_azi_position_written) { if (control == _fader) { if (!_fader->in_use()) { _surface->write (_fader->set_position (pos)); + queue_parameter_display (PanAzimuthAutomation, pos); } } else if (control == _vpot) { _surface->write (_vpot->set (pos, true, Pot::dot)); + queue_parameter_display (PanAzimuthAutomation, pos); } - - do_parameter_display (PanAzimuthAutomation, pos); - queue_display_reset (2000); + _last_pan_azi_position_written = pos; } } } -void +void Strip::notify_panner_width_changed (bool force_update) { if (_route) { @@ -411,31 +534,33 @@ Strip::notify_panner_width_changed (bool force_update) return; } + Control* control = 0; + ControlParameterMap::iterator i = control_by_parameter.find (PanWidthAutomation); - Control* control = control_by_parameter[PanWidthAutomation]; - - if (!control) { + if (i == control_by_parameter.end()) { return; - } - + } + + control = i->second; + double pos = pannable->pan_width_control->internal_to_interface (pannable->pan_width_control->get_value()); - + if (force_update || pos != _last_pan_azi_position_written) { - + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { if (control == _fader) { if (!control->in_use()) { _surface->write (_fader->set_position (pos)); + queue_parameter_display (PanWidthAutomation, pos); } } } else if (control == _vpot) { _surface->write (_vpot->set (pos, true, Pot::spread)); + queue_parameter_display (PanWidthAutomation, pos); } - - do_parameter_display (PanWidthAutomation, pos); - queue_display_reset (2000); + _last_pan_azi_position_written = pos; } } @@ -445,18 +570,18 @@ void Strip::select_event (Button&, ButtonState bs) { DEBUG_TRACE (DEBUG::MackieControl, "select button\n"); - + if (bs == press) { - - int ms = _surface->mcp().modifier_state(); + + int ms = _surface->mcp().main_modifier_state(); if (ms & MackieControlProtocol::MODIFIER_CMDALT) { _controls_locked = !_controls_locked; _surface->write (display (1,_controls_locked ? "Locked" : "Unlock")); - queue_display_reset (1000); + block_vpot_mode_display_for (1000); return; } - + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { /* reset to default */ boost::shared_ptr ac = _fader->control (); @@ -465,14 +590,14 @@ Strip::select_event (Button&, ButtonState bs) } return; } - + DEBUG_TRACE (DEBUG::MackieControl, "add select button on press\n"); - _surface->mcp().add_down_select_button (_surface->number(), _index); + _surface->mcp().add_down_select_button (_surface->number(), _index); _surface->mcp().select_range (); - + } else { DEBUG_TRACE (DEBUG::MackieControl, "remove select button on release\n"); - _surface->mcp().remove_down_select_button (_surface->number(), _index); + _surface->mcp().remove_down_select_button (_surface->number(), _index); } } @@ -481,14 +606,14 @@ Strip::vselect_event (Button&, ButtonState bs) { if (bs == press) { - int ms = _surface->mcp().modifier_state(); - + int ms = _surface->mcp().main_modifier_state(); + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { boost::shared_ptr ac = _vpot->control (); - + if (ac) { - + /* reset to default/normal value */ ac->set_value (ac->normal()); } @@ -506,33 +631,32 @@ void Strip::fader_touch_event (Button&, ButtonState bs) { DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader touch, press ? %1\n", (bs == press))); - + if (bs == press) { boost::shared_ptr ac = _fader->control (); - if (_surface->mcp().modifier_state() == MackieControlProtocol::MODIFIER_SHIFT) { + if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) { if (ac) { ac->set_value (ac->normal()); } } else { - + _fader->set_in_use (true); _fader->start_touch (_surface->mcp().transport_frame()); - + if (ac) { - do_parameter_display ((AutomationType) ac->parameter().type(), ac->internal_to_interface (ac->get_value())); - queue_display_reset (2000); + queue_parameter_display ((AutomationType) ac->parameter().type(), ac->get_value()); } } - + } else { - + _fader->set_in_use (false); _fader->stop_touch (_surface->mcp().transport_frame(), true); - + } -} +} void @@ -547,12 +671,12 @@ Strip::handle_button (Button& button, ButtonState bs) } DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip %1 handling button %2 press ? %3\n", _index, button.bid(), (bs == press))); - + switch (button.bid()) { case Button::Select: select_event (button, bs); break; - + case Button::VSelect: vselect_event (button, bs); break; @@ -566,34 +690,34 @@ Strip::handle_button (Button& button, ButtonState bs) if (bs == press) { DEBUG_TRACE (DEBUG::MackieControl, "add button on press\n"); _surface->mcp().add_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); - + float new_value; - int ms = _surface->mcp().modifier_state(); - + int ms = _surface->mcp().main_modifier_state(); + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { /* reset to default/normal value */ new_value = control->normal(); } else { new_value = control->get_value() ? 0.0 : 1.0; } - + /* get all controls that either have their * button down or are within a range of * several down buttons */ - + MackieControlProtocol::ControlList controls = _surface->mcp().down_controls ((AutomationType) control->parameter().type()); - - + + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("there are %1 buttons down for control type %2, new value = %3\n", controls.size(), control->parameter().type(), new_value)); /* apply change */ - + for (MackieControlProtocol::ControlList::iterator c = controls.begin(); c != controls.end(); ++c) { (*c)->set_value (new_value); } - + } else { DEBUG_TRACE (DEBUG::MackieControl, "remove button on release\n"); _surface->mcp().remove_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); @@ -603,9 +727,22 @@ Strip::handle_button (Button& button, ButtonState bs) } } +void +Strip::queue_parameter_display (AutomationType type, float val) +{ + RedisplayRequest req; + + req.type = type; + req.val = val; + + redisplay_requests.write (&req, 1); +} + void Strip::do_parameter_display (AutomationType type, float val) { + bool screen_hold = false; + switch (type) { case GainAutomation: if (val == 0.0) { @@ -615,7 +752,8 @@ Strip::do_parameter_display (AutomationType type, float val) float dB = accurate_coefficient_to_dB (val); snprintf (buf, sizeof (buf), "%6.1f", dB); _surface->write (display (1, buf)); - } + screen_hold = true; + } break; case PanAzimuthAutomation: @@ -624,6 +762,7 @@ Strip::do_parameter_display (AutomationType type, float val) if (p && _route->panner()) { string str =_route->panner()->value_as_string (p->pan_azimuth_control); _surface->write (display (1, str)); + screen_hold = true; } } break; @@ -631,14 +770,40 @@ Strip::do_parameter_display (AutomationType type, float val) case PanWidthAutomation: if (_route) { char buf[16]; - snprintf (buf, sizeof (buf), "%5ld%%", lrintf (val * 100.0)); + snprintf (buf, sizeof (buf), "%5ld%%", lrintf ((val * 200.0)-100)); + _surface->write (display (1, buf)); + screen_hold = true; + } + break; + + case TrimAutomation: + if (_route) { + char buf[16]; + float dB = accurate_coefficient_to_dB (val); + snprintf (buf, sizeof (buf), "%6.1f", dB); _surface->write (display (1, buf)); + screen_hold = true; + } + break; + + case PhaseAutomation: + if (_route) { + if (_route->phase_control()->get_value() < 0.5) { + _surface->write (display (1, "Normal")); + } else { + _surface->write (display (1, "Invert")); + } + screen_hold = true; } break; default: break; } + + if (screen_hold) { + block_vpot_mode_display_for (1000); + } } void @@ -655,13 +820,22 @@ void Strip::handle_fader (Fader& fader, float position) { DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader to %1\n", position)); + boost::shared_ptr ac = fader.control(); + if (!ac) { + return; + } fader.set_value (position); - queue_display_reset (2000); - // must echo bytes back to slider now, because - // the notifier only works if the fader is not being - // touched. Which it is if we're getting input. + /* From the Mackie Control MIDI implementation docs: + + In order to ensure absolute synchronization with the host software, + Mackie Control uses a closed-loop servo system for the faders, + meaning the faders will always move to their last received position. + When a host receives a Fader Position Message, it must then + re-transmit that message to the Mackie Control or else the faders + will return to their last position. + */ _surface->write (fader.set_position (position)); } @@ -672,8 +846,11 @@ Strip::handle_pot (Pot& pot, float delta) /* Pots only emit events when they move, not when they stop moving. So to get a stop event, we need to use a timeout. */ - + boost::shared_ptr ac = pot.control(); + if (!ac) { + return; + } double p = pot.get_value (); p += delta; p = max (ac->lower(), p); @@ -682,21 +859,78 @@ Strip::handle_pot (Pot& pot, float delta) } void -Strip::periodic (uint64_t usecs) +Strip::periodic (ARDOUR::microseconds_t now) { + bool reshow_vpot_mode = false; + bool reshow_name = false; + if (!_route) { return; } - update_automation (); + if (_block_screen_redisplay_until >= now) { + if (_surface->mcp().device_info().has_separate_meters()) { + goto meters; + } + /* no drawing here, for now */ + return; + + } else if (_block_screen_redisplay_until) { + + /* timeout reached, reset */ + + _block_screen_redisplay_until = 0; + reshow_vpot_mode = true; + reshow_name = true; + } + + if (_block_vpot_mode_redisplay_until >= now) { + return; + } else if (_block_vpot_mode_redisplay_until) { + + /* timeout reached, reset */ + + _block_vpot_mode_redisplay_until = 0; + reshow_vpot_mode = true; + } + + if (reshow_name) { + show_route_name (); + } + + if (reshow_vpot_mode) { + return_to_vpot_mode_display (); + } else { + /* no point doing this if we just switched back to vpot mode + display */ + update_automation (); + } + + meters: update_meter (); +} + +void +Strip::redisplay (ARDOUR::microseconds_t now) +{ + RedisplayRequest req; + bool have_request = false; + + while (redisplay_requests.read (&req, 1) == 1) { + /* read them all */ + have_request = true; + } - if (_reset_display_at && _reset_display_at < usecs) { - reset_display (); + if (_block_screen_redisplay_until >= now) { + return; + } + + if (have_request) { + do_parameter_display (req.type, req.val); } } -void +void Strip::update_automation () { ARDOUR::AutoState gain_state = _route->gain_control()->automation_state(); @@ -712,13 +946,19 @@ Strip::update_automation () notify_panner_width_changed (false); } } + if (_route->trim() && route()->trim()->active()) { + ARDOUR::AutoState trim_state = _route->trim_control()->automation_state(); + if (trim_state == Touch || trim_state == Play) { + notify_trim_changed (false); + } + } } void Strip::update_meter () { if (_meter && _transport_is_rolling && _metering_active) { - float dB = const_cast (_route->peak_meter()).peak_power (0); + float dB = const_cast (_route->peak_meter()).meter_level (0, MeterMCP); _meter->send_update (*_surface, dB); } } @@ -751,12 +991,12 @@ Strip::display (uint32_t line_number, const std::string& line) // sysex header retval << _surface->sysex_hdr(); - + // code for display retval << 0x12; // offset (0 to 0x37 first line, 0x38 to 0x6f for second line) retval << (_index * 7 + (line_number * 0x38)); - + // ascii data to display. @param line is UTF-8 string ascii = Glib::convert_with_fallback (line, "UTF-8", "ISO-8859-1", "_"); string::size_type len = ascii.length(); @@ -769,7 +1009,7 @@ Strip::display (uint32_t line_number, const std::string& line) for (int i = len; i < 6; ++i) { retval << ' '; } - + // column spacer, unless it's the right-hand column if (_index < 7) { retval << ' '; @@ -777,7 +1017,7 @@ Strip::display (uint32_t line_number, const std::string& line) // sysex trailer retval << MIDI::eox; - + return retval; } @@ -810,7 +1050,7 @@ string Strip::vpot_mode_string () const { boost::shared_ptr ac = _vpot->control(); - + if (!ac) { return string(); } @@ -818,6 +1058,10 @@ Strip::vpot_mode_string () const switch (ac->parameter().type()) { case GainAutomation: return "Fader"; + case TrimAutomation: + return "Trim"; + case PhaseAutomation: + return string_compose ("Phase%1", _route->phase_control()->channel() + 1); case PanAzimuthAutomation: return "Pan"; case PanWidthAutomation: @@ -833,25 +1077,30 @@ Strip::vpot_mode_string () const return "???"; } -void -Strip::flip_mode_changed (bool notify) + void +Strip::potmode_changed (bool notify) { if (!_route) { return; } - reset_saved_values (); - - boost::shared_ptr fader_controllable = _fader->control (); - boost::shared_ptr vpot_controllable = _vpot->control (); - - _fader->set_control (vpot_controllable); - _vpot->set_control (fader_controllable); - - control_by_parameter[fader_controllable->parameter()] = _vpot; - control_by_parameter[vpot_controllable->parameter()] = _fader; - - _surface->write (display (1, vpot_mode_string ())); + // WIP + int pm = _surface->mcp().pot_mode(); + switch (pm) { + case MackieControlProtocol::Pan: + // This needs to set current pan mode (azimuth or width... or whatever) + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Assign pot to Pan mode %1\n", enum_2_string (_pan_mode))); + set_vpot_parameter (_pan_mode); + break; + case MackieControlProtocol::Trim: + DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Trim mode.\n"); + set_vpot_parameter (_trim_mode); + break; + case MackieControlProtocol::Send: + DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Send mode.\n"); + set_vpot_parameter (SendAutomation); + break; + } if (notify) { notify_all (); @@ -859,114 +1108,29 @@ Strip::flip_mode_changed (bool notify) } void -Strip::queue_display_reset (uint32_t msecs) +Strip::block_screen_display_for (uint32_t msecs) { - struct timeval now; - struct timeval delta; - struct timeval when; - gettimeofday (&now, 0); - - delta.tv_sec = msecs/1000; - delta.tv_usec = (msecs - ((msecs/1000) * 1000)) * 1000; - - timeradd (&now, &delta, &when); - - _reset_display_at = (when.tv_sec * 1000000) + when.tv_usec; + _block_screen_redisplay_until = ARDOUR::get_microseconds() + (msecs * 1000); } void -Strip::clear_display_reset () +Strip::block_vpot_mode_display_for (uint32_t msecs) { - _reset_display_at = 0; + _block_vpot_mode_redisplay_until = ARDOUR::get_microseconds() + (msecs * 1000); } void -Strip::reset_display () +Strip::return_to_vpot_mode_display () { + /* returns the second line of the two-line per-strip display + back the mode where it shows what the VPot controls. + */ + if (_route) { _surface->write (display (1, vpot_mode_string())); } else { _surface->write (blank_display (1)); } - - clear_display_reset (); -} - -struct RouteCompareByName { - bool operator() (boost::shared_ptr a, boost::shared_ptr b) { - return a->name().compare (b->name()) < 0; - } -}; - -void -Strip::maybe_add_to_bundle_map (BundleMap& bm, boost::shared_ptr b, bool for_input, const ChanCount& channels) -{ - if (b->ports_are_outputs() == !for_input || b->nchannels() != channels) { - return; - } - - bm[b->name()] = b; -} - -void -Strip::build_input_list (const ChanCount& channels) -{ - boost::shared_ptr b = _surface->mcp().get_session().bundles (); - - input_bundles.clear (); - - /* give user bundles first chance at being in the menu */ - - for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { - if (boost::dynamic_pointer_cast (*i)) { - maybe_add_to_bundle_map (input_bundles, *i, true, channels); - } - } - - for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { - if (boost::dynamic_pointer_cast (*i) == 0) { - maybe_add_to_bundle_map (input_bundles, *i, true, channels); - } - } - - boost::shared_ptr routes = _surface->mcp().get_session().get_routes (); - RouteList copy = *routes; - copy.sort (RouteCompareByName ()); - - for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) { - maybe_add_to_bundle_map (input_bundles, (*i)->output()->bundle(), true, channels); - } - -} - -void -Strip::build_output_list (const ChanCount& channels) -{ - boost::shared_ptr b = _surface->mcp().get_session().bundles (); - - output_bundles.clear (); - - /* give user bundles first chance at being in the menu */ - - for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { - if (boost::dynamic_pointer_cast (*i)) { - maybe_add_to_bundle_map (output_bundles, *i, false, channels); - } - } - - for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { - if (boost::dynamic_pointer_cast (*i) == 0) { - maybe_add_to_bundle_map (output_bundles, *i, false, channels); - } - } - - boost::shared_ptr routes = _surface->mcp().get_session().get_routes (); - RouteList copy = *routes; - copy.sort (RouteCompareByName ()); - - for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) { - maybe_add_to_bundle_map (output_bundles, (*i)->input()->bundle(), false, channels); - } } void @@ -978,7 +1142,7 @@ Strip::next_pot_mode () /* do not change vpot mode while in flipped mode */ DEBUG_TRACE (DEBUG::MackieControl, "not stepping pot mode - in flip mode\n"); _surface->write (display (1, "Flip")); - queue_display_reset (1000); + block_vpot_mode_display_for (1000); return; } @@ -988,30 +1152,63 @@ Strip::next_pot_mode () if (!ac) { return; } + if (_surface->mcp().pot_mode() == MackieControlProtocol::Pan) { + if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter())) { + return; + } - if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter())) { - return; - } + for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) { + if ((*i) == ac->parameter()) { + break; + } + } - for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) { - if ((*i) == ac->parameter()) { - break; + /* move to the next mode in the list, or back to the start (which will + also happen if the current mode is not in the current pot mode list) + */ + + if (i != possible_pot_parameters.end()) { + ++i; } - } - /* move to the next mode in the list, or back to the start (which will - also happen if the current mode is not in the current pot mode list) - */ + if (i == possible_pot_parameters.end()) { + i = possible_pot_parameters.begin(); + } + set_vpot_parameter (*i); + } else if (_surface->mcp().pot_mode() == MackieControlProtocol::Trim) { + if (possible_trim_parameters.empty() || (possible_trim_parameters.size() == 1 && possible_trim_parameters.front() == ac->parameter())) { + return; + } - if (i != possible_pot_parameters.end()) { - ++i; - } + for (i = possible_trim_parameters.begin(); i != possible_trim_parameters.end(); ++i) { + if ((*i) == ac->parameter()) { + break; + } + } + if ((*i).type() == PhaseAutomation && _route->phase_invert().size() > 1) { + // There are more than one channel of phase + if ((_route->phase_control()->channel() + 1) < _route->phase_invert().size()) { + _route->phase_control()->set_channel(_route->phase_control()->channel() + 1); + set_vpot_parameter (*i); + return; + } else { + _route->phase_control()->set_channel(0); + } + } + /* move to the next mode in the list, or back to the start (which will + also happen if the current mode is not in the current pot mode list) + */ + + if (i != possible_trim_parameters.end()) { + ++i; + } - if (i == possible_pot_parameters.end()) { - i = possible_pot_parameters.begin(); + if (i == possible_trim_parameters.end()) { + i = possible_trim_parameters.begin(); + } + set_vpot_parameter (*i); } - set_vpot_parameter (*i); } void @@ -1019,64 +1216,71 @@ Strip::set_vpot_parameter (Evoral::Parameter p) { boost::shared_ptr pannable; - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", p)); + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", p.type())); reset_saved_values (); + /* unset any mapping between the vpot and any existing parameters */ + + for (ControlParameterMap::iterator i = control_by_parameter.begin(); i != control_by_parameter.end(); ++i) { + + if (i != control_by_parameter.end() && i->second == _vpot) { + i->second = 0; + } + } + switch (p.type()) { case PanAzimuthAutomation: + _pan_mode = PanAzimuthAutomation; pannable = _route->pannable (); - if (pannable) { - if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { - /* gain to vpot, pan azi to fader */ - _vpot->set_control (_route->gain_control()); - control_by_parameter[GainAutomation] = _vpot; - if (pannable) { - _fader->set_control (pannable->pan_azimuth_control); - control_by_parameter[PanAzimuthAutomation] = _fader; - } else { - _fader->set_control (boost::shared_ptr()); - control_by_parameter[PanAzimuthAutomation] = 0; - } + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + /* gain to vpot, pan azi to fader */ + _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; + if (pannable) { + _fader->set_control (pannable->pan_azimuth_control); + control_by_parameter[PanAzimuthAutomation] = _fader; } else { - /* gain to fader, pan azi to vpot */ - _fader->set_control (_route->gain_control()); - control_by_parameter[GainAutomation] = _fader; - if (pannable) { - _vpot->set_control (pannable->pan_azimuth_control); - control_by_parameter[PanAzimuthAutomation] = _vpot; - } else { - _vpot->set_control (boost::shared_ptr()); - control_by_parameter[PanAzimuthAutomation] = 0; - } + _fader->set_control (boost::shared_ptr()); + control_by_parameter[PanAzimuthAutomation] = 0; + } + } else { + /* gain to fader, pan azi to vpot */ + _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; + if (pannable) { + _vpot->set_control (pannable->pan_azimuth_control); + control_by_parameter[PanAzimuthAutomation] = _vpot; + } else { + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[PanAzimuthAutomation] = 0; } } break; case PanWidthAutomation: + _pan_mode = PanWidthAutomation; pannable = _route->pannable (); - if (pannable) { - if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { - /* gain to vpot, pan width to fader */ - _vpot->set_control (_route->gain_control()); - control_by_parameter[GainAutomation] = _vpot; - if (pannable) { - _fader->set_control (pannable->pan_width_control); - control_by_parameter[PanWidthAutomation] = _fader; - } else { - _fader->set_control (boost::shared_ptr()); - control_by_parameter[PanWidthAutomation] = 0; - } + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + /* gain to vpot, pan width to fader */ + _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; + if (pannable) { + _fader->set_control (pannable->pan_width_control); + control_by_parameter[PanWidthAutomation] = _fader; } else { - /* gain to fader, pan width to vpot */ - _fader->set_control (_route->gain_control()); - control_by_parameter[GainAutomation] = _fader; - if (pannable) { - _vpot->set_control (pannable->pan_width_control); - control_by_parameter[PanWidthAutomation] = _vpot; - } else { - _vpot->set_control (boost::shared_ptr()); - control_by_parameter[PanWidthAutomation] = 0; - } + _fader->set_control (boost::shared_ptr()); + control_by_parameter[PanWidthAutomation] = 0; + } + } else { + /* gain to fader, pan width to vpot */ + _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; + if (pannable) { + _vpot->set_control (pannable->pan_width_control); + control_by_parameter[PanWidthAutomation] = _vpot; + } else { + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[PanWidthAutomation] = 0; } } break; @@ -1086,41 +1290,118 @@ Strip::set_vpot_parameter (Evoral::Parameter p) break; case PanLFEAutomation: break; + case TrimAutomation: + _trim_mode = TrimAutomation; + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + /* gain to vpot, trim to fader */ + _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; + if (_route->trim() && route()->trim()->active()) { + _fader->set_control (_route->trim_control()); + control_by_parameter[TrimAutomation] = _fader; + } else { + _fader->set_control (boost::shared_ptr()); + control_by_parameter[TrimAutomation] = 0; + } + } else { + /* gain to fader, trim to vpot */ + _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; + if (_route->trim() && route()->trim()->active()) { + _vpot->set_control (_route->trim_control()); + control_by_parameter[TrimAutomation] = _vpot; + } else { + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[TrimAutomation] = 0; + } + } + break; + case PhaseAutomation: + _trim_mode = PhaseAutomation; + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + /* gain to vpot, phase to fader */ + _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; + if (_route->phase_invert().size()) { + _fader->set_control (_route->phase_control()); + control_by_parameter[PhaseAutomation] = _fader; + } else { + _fader->set_control (boost::shared_ptr()); + control_by_parameter[PhaseAutomation] = 0; + } + } else { + /* gain to fader, phase to vpot */ + _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; + if (_route->phase_invert().size()) { + _vpot->set_control (_route->phase_control()); + control_by_parameter[PhaseAutomation] = _vpot; + } else { + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[PhaseAutomation] = 0; + } + } + break; + case SendAutomation: + // deal with sends ... needs sends yet :) + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + // gain to vpot, trim to fader + _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; + _fader->set_control (boost::shared_ptr()); + } else { + // gain to fader, trim to vpot + _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; + _vpot->set_control (boost::shared_ptr()); + } + break; + default: + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("vpot mode %1 not known.\n", p)); + break; + } _surface->write (display (1, vpot_mode_string())); } +bool +Strip::is_midi_track () const +{ + return boost::dynamic_pointer_cast(_route) != 0; +} + void Strip::reset_saved_values () { _last_pan_azi_position_written = -1.0; _last_pan_width_position_written = -1.0; _last_gain_position_written = -1.0; + _last_trim_position_written = -1.0; } -void +void Strip::notify_metering_state_changed() { if (!_route || !_meter) { return; } - + bool transport_is_rolling = (_surface->mcp().get_transport_speed () != 0.0f); bool metering_active = _surface->mcp().metering_active (); - + if ((_transport_is_rolling == transport_is_rolling) && (_metering_active == metering_active)) { return; } - + _meter->notify_metering_state_changed (*_surface, transport_is_rolling, metering_active); - + if (!transport_is_rolling || !metering_active) { notify_property_changed (PBD::PropertyChange (ARDOUR::Properties::name)); notify_panner_azi_changed (true); } - + _transport_is_rolling = transport_is_rolling; _metering_active = metering_active; }