ardour/livetrax
13
0
Fork 0
Code

convert faderport to use Stripable instead of Route

Browse Source
This commit is contained in:
Paul Davis 2016-05-17 11:42:31 -04:00
parent 7eb2d1d16d
commit cefd3ac8be
3 changed files with 115 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
libs/surfaces/faderport/faderport.cc
View File

@ -47,7 +47,7 @@
#include "ardour/monitor_processor.h"
#include "ardour/profile.h"
#include "ardour/rc_configuration.h"
#include "ardour/route.h"
#include "ardour/stripable.h"
#include "ardour/session.h"
#include "ardour/session_configuration.h"
#include "ardour/track.h"
@ -108,7 +108,7 @@ FaderPort::FaderPort (Session& s)
);
TrackSelectionChanged.connect (selection_connection, MISSING_INVALIDATOR, boost::bind (&FaderPort::gui_track_selection_changed, this, _1), this);
StripableSelectionChanged.connect (selection_connection, MISSING_INVALIDATOR, boost::bind (&FaderPort::gui_track_selection_changed, this, _1), this);
/* Catch port connections and disconnections */
ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR, boost::bind (&FaderPort::connection_handler, this, _1, _2, _3, _4, _5), this);
@ -372,8 +372,8 @@ FaderPort::button_handler (MIDI::Parser &, MIDI::EventTwoBytes* tb)
break;
case FaderTouch:
fader_is_touched = tb->value;
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
framepos_t now = session->engine().sample_time();
if (tb->value) {
@ -443,7 +443,7 @@ FaderPort::encoder_handler (MIDI::Parser &, MIDI::pitchbend_t pb)
last_good_encoder_delta = delta;
}
if (_current_route) {
if (_current_stripable) {
ButtonState trim_modifier;
ButtonState width_modifier;
@ -457,7 +457,7 @@ FaderPort::encoder_handler (MIDI::Parser &, MIDI::pitchbend_t pb)
}
if ((button_state & trim_modifier) == trim_modifier ) { // mod+encoder = input trim
boost::shared_ptr<AutomationControl> trim = _current_route->trim()->gain_control ();
boost::shared_ptr<AutomationControl> trim = _current_stripable->trim_control ();
if (trim) {
float val = trim->get_user(); //for gain elements, the "user" value is in dB
val += delta;
@ -498,16 +498,16 @@ FaderPort::fader_handler (MIDI::Parser &, MIDI::EventTwoBytes* tb)
}
if (was_fader) {
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
int ival = (fader_msb << 7) | fader_lsb;
float val = gain->interface_to_internal (ival/16384.0);
/* even though the faderport only controls a
single route at a time, allow the fader to
single stripable at a time, allow the fader to
modify the group, if appropriate.
*/
_current_route->gain_control()->set_value (val, Controllable::UseGroup);
_current_stripable->gain_control()->set_value (val, Controllable::UseGroup);
}
}
}
@ -601,11 +601,11 @@ FaderPort::set_active (bool yn)
bool
FaderPort::periodic ()
{
if (!_current_route) {
if (!_current_stripable) {
return true;
}
ARDOUR::AutoState gain_state = _current_route->gain_control()->automation_state();
ARDOUR::AutoState gain_state = _current_stripable->gain_control()->automation_state();
if (gain_state == ARDOUR::Touch || gain_state == ARDOUR::Play) {
map_gain ();
@ -652,10 +652,10 @@ FaderPort::close ()
port_connection.disconnect ();
blink_connection.disconnect ();
selection_connection.disconnect ();
route_connections.drop_connections ();
stripable_connections.drop_connections ();
#if 0
route_connections.drop_connections ();
stripable_connections.drop_connections ();
#endif
}
@ -1104,67 +1104,67 @@ FaderPort::Button::get_state () const
}
void
FaderPort::gui_track_selection_changed (RouteNotificationListPtr routes)
FaderPort::gui_track_selection_changed (StripableNotificationListPtr stripables)
{
boost::shared_ptr<Route> r;
boost::shared_ptr<Stripable> r;
if (!routes->empty()) {
r = routes->front().lock();
if (!stripables->empty()) {
r = stripables->front().lock();
}
set_current_route (r);
set_current_stripable (r);
}
void
FaderPort::drop_current_route ()
FaderPort::drop_current_stripable ()
{
if (_current_route) {
if (_current_route == session->monitor_out()) {
set_current_route (session->master_out());
if (_current_stripable) {
if (_current_stripable == session->monitor_out()) {
set_current_stripable (session->master_out());
} else {
set_current_route (boost::shared_ptr<Route>());
set_current_stripable (boost::shared_ptr<Stripable>());
}
}
}
void
FaderPort::set_current_route (boost::shared_ptr<Route> r)
FaderPort::set_current_stripable (boost::shared_ptr<Stripable> r)
{
route_connections.drop_connections ();
stripable_connections.drop_connections ();
_current_route = r;
_current_stripable = r;
/* turn this off. It will be turned on back on in use_master() or
use_monitor() as appropriate.
*/
get_button(Output).set_led_state (_output_port, false);
if (_current_route) {
_current_route->DropReferences.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::drop_current_route, this), this);
if (_current_stripable) {
_current_stripable->DropReferences.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::drop_current_stripable, this), this);
_current_route->mute_control()->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_mute, this), this);
_current_route->solo_control()->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_solo, this), this);
_current_stripable->mute_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_mute, this), this);
_current_stripable->solo_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_solo, this), this);
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_route);
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_stripable);
if (t) {
t->rec_enable_control()->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_recenable, this), this);
t->rec_enable_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_recenable, this), this);
}
boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
boost::shared_ptr<AutomationControl> control = _current_stripable->gain_control ();
if (control) {
control->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_gain, this), this);
control->alist()->automation_state_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_auto, this), this);
control->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_gain, this), this);
control->alist()->automation_state_changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_auto, this), this);
}
boost::shared_ptr<MonitorProcessor> mp = _current_route->monitor_control();
boost::shared_ptr<MonitorProcessor> mp = _current_stripable->monitor_control();
if (mp) {
mp->cut_control()->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_cut, this), this);
mp->cut_control()->Changed.connect (stripable_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_cut, this), this);
}
}
//ToDo: subscribe to the fader automation modes so we can light the LEDs
map_route_state ();
map_stripable_state ();
}
void
@ -1174,7 +1174,7 @@ FaderPort::map_auto ()
* the Off button, because this will disable the fader.
*/
boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
boost::shared_ptr<AutomationControl> control = _current_stripable->gain_control ();
const AutoState as = control->automation_state ();
switch (as) {
@ -1206,7 +1206,7 @@ FaderPort::map_auto ()
void
FaderPort::map_cut ()
{
boost::shared_ptr<MonitorProcessor> mp = _current_route->monitor_control();
boost::shared_ptr<MonitorProcessor> mp = _current_stripable->monitor_control();
if (mp) {
bool yn = mp->cut_all ();
@ -1223,11 +1223,11 @@ FaderPort::map_cut ()
void
FaderPort::map_mute ()
{
if (_current_route) {
if (_current_route->muted()) {
if (_current_stripable) {
if (_current_stripable->mute_control()->muted()) {
stop_blinking (Mute);
get_button (Mute).set_led_state (_output_port, true);
} else if (_current_route->muted_by_others_soloing () || _current_route->muted_by_masters()) {
} else if (_current_stripable->mute_control()->muted_by_others_soloing () || _current_stripable->mute_control()->muted_by_masters()) {
start_blinking (Mute);
} else {
stop_blinking (Mute);
@ -1240,8 +1240,8 @@ FaderPort::map_mute ()
void
FaderPort::map_solo ()
{
if (_current_route) {
get_button (Solo).set_led_state (_output_port, _current_route->soloed());
if (_current_stripable) {
get_button (Solo).set_led_state (_output_port, _current_stripable->solo_control()->soloed());
} else {
get_button (Solo).set_led_state (_output_port, false);
}
@ -1250,7 +1250,7 @@ FaderPort::map_solo ()
void
FaderPort::map_recenable ()
{
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_route);
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_stripable);
if (t) {
get_button (Rec).set_led_state (_output_port, t->rec_enable_control()->get_value());
} else {
@ -1266,11 +1266,11 @@ FaderPort::map_gain ()
return;
}
if (!_current_route) {
if (!_current_stripable) {
return;
}
boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
boost::shared_ptr<AutomationControl> control = _current_stripable->gain_control ();
double val;
if (!control) {
@ -1309,9 +1309,9 @@ FaderPort::map_gain ()
}
void
FaderPort::map_route_state ()
FaderPort::map_stripable_state ()
{
if (!_current_route) {
if (!_current_stripable) {
stop_blinking (Mute);
stop_blinking (Solo);
get_button (Rec).set_led_state (_output_port, false);
@ -1321,7 +1321,7 @@ FaderPort::map_route_state ()
map_gain ();
map_auto ();
if (_current_route == session->monitor_out()) {
if (_current_stripable == session->monitor_out()) {
map_cut ();
} else {
map_mute ();

16
libs/surfaces/faderport/faderport.h
View File

@ -164,9 +164,9 @@ class FaderPort : public ARDOUR::ControlProtocol, public AbstractUI<FaderPortReq
std::list<boost::shared_ptr<ARDOUR::Bundle> > bundles ();
private:
boost::shared_ptr<ARDOUR::Route> _current_route;
boost::weak_ptr<ARDOUR::Route> pre_master_route;
boost::weak_ptr<ARDOUR::Route> pre_monitor_route;
boost::shared_ptr<ARDOUR::Stripable> _current_stripable;
boost::weak_ptr<ARDOUR::Stripable> pre_master_stripable;
boost::weak_ptr<ARDOUR::Stripable> pre_monitor_stripable;
boost::shared_ptr<ARDOUR::AsyncMIDIPort> _input_port;
boost::shared_ptr<ARDOUR::AsyncMIDIPort> _output_port;
@ -294,15 +294,15 @@ class FaderPort : public ARDOUR::ControlProtocol, public AbstractUI<FaderPortReq
void start_blinking (ButtonID);
void stop_blinking (ButtonID);
void set_current_route (boost::shared_ptr<ARDOUR::Route>);
void drop_current_route ();
void set_current_stripable (boost::shared_ptr<ARDOUR::Stripable>);
void drop_current_stripable ();
void use_master ();
void use_monitor ();
void gui_track_selection_changed (ARDOUR::RouteNotificationListPtr);
void gui_track_selection_changed (ARDOUR::StripableNotificationListPtr);
PBD::ScopedConnection selection_connection;
PBD::ScopedConnectionList route_connections;
PBD::ScopedConnectionList stripable_connections;
void map_route_state ();
void map_stripable_state ();
void map_solo ();
void map_mute ();
bool rec_enable_state;

92
libs/surfaces/faderport/operations.cc
View File

@ -60,8 +60,8 @@ FaderPort::right ()
void
FaderPort::read ()
{
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
gain->set_automation_state( (ARDOUR::AutoState) ARDOUR::Play );
}
@ -71,8 +71,8 @@ FaderPort::read ()
void
FaderPort::write ()
{
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
gain->set_automation_state( (ARDOUR::AutoState) ARDOUR::Write );
}
@ -82,8 +82,8 @@ FaderPort::write ()
void
FaderPort::touch ()
{
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
gain->set_automation_state( (ARDOUR::AutoState) ARDOUR::Touch );
}
@ -93,8 +93,8 @@ FaderPort::touch ()
void
FaderPort::off ()
{
if (_current_route) {
boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
if (_current_stripable) {
boost::shared_ptr<AutomationControl> gain = _current_stripable->gain_control ();
if (gain) {
gain->set_automation_state( (ARDOUR::AutoState) ARDOUR::Off );
}
@ -119,39 +119,39 @@ FaderPort::redo ()
void
FaderPort::mute ()
{
if (!_current_route) {
if (!_current_stripable) {
return;
}
if (_current_route == session->monitor_out()) {
boost::shared_ptr<MonitorProcessor> mp = _current_route->monitor_control();
if (_current_stripable == session->monitor_out()) {
boost::shared_ptr<MonitorProcessor> mp = _current_stripable->monitor_control();
mp->set_cut_all (!mp->cut_all());
return;
}
boost::shared_ptr<ControlList> cl (new ControlList);
cl->push_back (_current_route->mute_control());
session->set_controls (cl, !_current_route->muted(), PBD::Controllable::UseGroup);
cl->push_back (_current_stripable->mute_control());
session->set_controls (cl, !_current_stripable->mute_control()->muted(), PBD::Controllable::UseGroup);
}
void
FaderPort::solo ()
{
if (!_current_route) {
if (!_current_stripable) {
return;
}
_current_route->solo_control()->set_value (_current_route->soloed() ? 0.0 : 1.0, PBD::Controllable::UseGroup);
_current_stripable->solo_control()->set_value (_current_stripable->solo_control()->soloed() ? 0.0 : 1.0, PBD::Controllable::UseGroup);
}
void
FaderPort::rec_enable ()
{
if (!_current_route) {
if (!_current_stripable) {
return;
}
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_current_route);
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_current_stripable);
if (!t) {
return;
@ -163,18 +163,18 @@ FaderPort::rec_enable ()
void
FaderPort::use_master ()
{
boost::shared_ptr<Route> r = session->master_out();
boost::shared_ptr<Stripable> r = session->master_out();
if (r) {
if (_current_route == r) {
r = pre_master_route.lock();
set_current_route (r);
if (_current_stripable == r) {
r = pre_master_stripable.lock();
set_current_stripable (r);
get_button(Output).set_led_state (_output_port, false);
blinkers.remove (Output);
} else {
if (_current_route != session->master_out() && _current_route != session->monitor_out()) {
pre_master_route = boost::weak_ptr<Route> (_current_route);
if (_current_stripable != session->master_out() && _current_stripable != session->monitor_out()) {
pre_master_stripable = boost::weak_ptr<Stripable> (_current_stripable);
}
set_current_route (r);
set_current_stripable (r);
get_button(Output).set_led_state (_output_port, true);
blinkers.remove (Output);
}
@ -184,19 +184,19 @@ FaderPort::use_master ()
void
FaderPort::use_monitor ()
{
boost::shared_ptr<Route> r = session->monitor_out();
boost::shared_ptr<Stripable> r = session->monitor_out();
if (r) {
if (_current_route == r) {
r = pre_monitor_route.lock();
set_current_route (r);
if (_current_stripable == r) {
r = pre_monitor_stripable.lock();
set_current_stripable (r);
get_button(Output).set_led_state (_output_port, false);
blinkers.remove (Output);
} else {
if (_current_route != session->master_out() && _current_route != session->monitor_out()) {
pre_monitor_route = boost::weak_ptr<Route> (_current_route);
if (_current_stripable != session->master_out() && _current_stripable != session->monitor_out()) {
pre_monitor_stripable = boost::weak_ptr<Stripable> (_current_stripable);
}
set_current_route (r);
set_current_stripable (r);
get_button(Output).set_led_state (_output_port, true);
blinkers.push_back (Output);
}
@ -207,11 +207,17 @@ FaderPort::use_monitor ()
void
FaderPort::ardour_pan_azimuth (int delta)
{
if (!_current_route) {
if (!_current_stripable) {
return;
}
boost::shared_ptr<Pannable> pannable = _current_route->pannable ();
boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (_current_stripable);
if (!r) {
return;
}
boost::shared_ptr<Pannable> pannable = r->pannable ();
if (!pannable) {
return;
@ -230,11 +236,17 @@ FaderPort::ardour_pan_azimuth (int delta)
void
FaderPort::ardour_pan_width(int delta)
{
if (!_current_route) {
if (!_current_stripable) {
return;
}
boost::shared_ptr<Pannable> pannable = _current_route->pannable ();
boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (_current_stripable);
if (!r) {
return;
}
boost::shared_ptr<Pannable> pannable = r->pannable ();
if (!pannable) {
return;
@ -253,12 +265,18 @@ void
FaderPort::mixbus_pan (int delta)
{
#ifdef MIXBUS
if (!_current_route) {
if (!_current_stripable) {
return;
}
boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (_current_stripable);
if (!r) {
return;
}
const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
boost::shared_ptr<ARDOUR::PluginInsert> plug = _current_route->ch_post();
boost::shared_ptr<ARDOUR::PluginInsert> plug = r->ch_post();
if (!plug) {
return;