allanger/ardour
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Activity

WS: consistent naming of strip/plugin/param identifiers

Browse Source 
Rename all {object}_n variables and arguments to {object}_id

Parts of code were using the former convention, now use the latter everywhere
Another step towards supporting visual position agnostic identifiers in the future
This commit is contained in:
Luciano Iam
2020-08-30 00:42:07 +02:00
committed by Robin Gareus
parent c32a5917f3
commit e510c0cb75
4 changed files with 97 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
libs/surfaces/websockets/dispatcher.cc
View File

@@ -56,21 +56,22 @@ void
WebsocketsDispatcher::update_all_nodes (Client client)
{
for (ArdourMixer::StripMap::iterator it = mixer().strips().begin(); it != mixer().strips().end(); ++it) {
uint32_t strip_n = it->first;
uint32_t strip_id = it->first;
ArdourMixerStrip& strip = it->second;
bool is_vca = strip.stripable ()->presentation_info ().flags () & ARDOUR::PresentationInfo::VCA;
AddressVector strip_addr = AddressVector ();
strip_addr.push_back (strip_n);
strip_addr.push_back (strip_id);
ValueVector strip_desc = ValueVector ();
strip_desc.push_back (strip.name ());
strip_desc.push_back (is_vca);
update (client, Node::strip_description, strip_addr, strip_desc);
update (client, Node::strip_gain, strip_n, strip.gain ());
update (client, Node::strip_mute, strip_n, strip.mute ());
update (client, Node::strip_gain, strip_id, strip.gain ());
update (client, Node::strip_mute, strip_id, strip.mute ());
// Pan and plugins not available in VCAs
if (is_vca) {
@@ -82,32 +83,32 @@ WebsocketsDispatcher::update_all_nodes (Client client)
continue;
}
update (client, Node::strip_pan, strip_n, strip.pan ());
update (client, Node::strip_pan, strip_id, strip.pan ());
for (ArdourMixerStrip::PluginMap::iterator it = strip.plugins ().begin (); it != strip.plugins ().end (); ++it) {
uint32_t plugin_n = it->first;
uint32_t plugin_id = it->first;
boost::shared_ptr<PluginInsert> insert = it->second.insert ();
boost::shared_ptr<Plugin> plugin = insert->plugin ();
update (client, Node::strip_plugin_description, strip_n, plugin_n,
update (client, Node::strip_plugin_description, strip_id, plugin_id,
static_cast<std::string> (plugin->name ()));
update (client, Node::strip_plugin_enable, strip_n, plugin_n,
strip.plugin (plugin_n).enabled ());
update (client, Node::strip_plugin_enable, strip_id, plugin_id,
strip.plugin (plugin_id).enabled ());
for (uint32_t param_n = 0; param_n < plugin->parameter_count (); ++param_n) {
for (uint32_t param_id = 0; param_id < plugin->parameter_count (); ++param_id) {
boost::shared_ptr<AutomationControl> a_ctrl;
try {
a_ctrl = strip.plugin (plugin_n).param_control (param_n);
a_ctrl = strip.plugin (plugin_id).param_control (param_id);
} catch (ArdourMixerNotFoundException) {
continue;
}
AddressVector addr = AddressVector ();
addr.push_back (strip_n);
addr.push_back (plugin_n);
addr.push_back (param_n);
addr.push_back (strip_id);
addr.push_back (plugin_id);
addr.push_back (param_id);
ValueVector val = ValueVector ();
val.push_back (a_ctrl->name ());
@@ -130,8 +131,8 @@ WebsocketsDispatcher::update_all_nodes (Client client)
update (client, Node::strip_plugin_param_description, addr, val);
TypedValue value = strip.plugin (plugin_n).param_value (param_n);
update (client, Node::strip_plugin_param_value, strip_n, plugin_n, param_n, value);
TypedValue value = strip.plugin (plugin_id).param_value (param_id);
update (client, Node::strip_plugin_param_value, strip_id, plugin_id, param_id, value);
}
}
}
@@ -281,34 +282,34 @@ WebsocketsDispatcher::update (Client client, std::string node, TypedValue val1)
}
void
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_n, TypedValue val1)
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_id, TypedValue val1)
{
update (client, node, strip_n, ADDR_NONE, ADDR_NONE, val1);
update (client, node, strip_id, ADDR_NONE, ADDR_NONE, val1);
}
void
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_n, uint32_t plugin_n,
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_id, uint32_t plugin_id,
TypedValue val1)
{
update (client, node, strip_n, plugin_n, ADDR_NONE, val1);
update (client, node, strip_id, plugin_id, ADDR_NONE, val1);
}
void
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_n, uint32_t plugin_n,
uint32_t param_n, TypedValue val1)
WebsocketsDispatcher::update (Client client, std::string node, uint32_t strip_id, uint32_t plugin_id,
uint32_t param_id, TypedValue val1)
{
AddressVector addr = AddressVector ();
if (strip_n != ADDR_NONE) {
addr.push_back (strip_n);
if (strip_id != ADDR_NONE) {
addr.push_back (strip_id);
}
if (plugin_n != ADDR_NONE) {
addr.push_back (plugin_n);
if (plugin_id != ADDR_NONE) {
addr.push_back (plugin_id);
}
if (param_n != ADDR_NONE) {
addr.push_back (param_n);
if (param_id != ADDR_NONE) {
addr.push_back (param_id);
}
ValueVector val = ValueVector ();

101
libs/surfaces/websockets/feedback.cc
View File

@@ -52,38 +52,38 @@ struct TempoObserver {
};
struct StripGainObserver {
void operator() (ArdourFeedback* p, uint32_t strip_n)
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
// fires multiple times (4x as of ardour 6.0)
p->update_all (Node::strip_gain, strip_n, p->mixer ().strip (strip_n).gain ());
p->update_all (Node::strip_gain, strip_id, p->mixer ().strip (strip_id).gain ());
}
};
struct StripPanObserver {
void operator() (ArdourFeedback* p, uint32_t strip_n)
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
p->update_all (Node::strip_pan, strip_n, p->mixer ().strip (strip_n).pan ());
p->update_all (Node::strip_pan, strip_id, p->mixer ().strip (strip_id).pan ());
}
};
struct StripMuteObserver {
void operator() (ArdourFeedback* p, uint32_t strip_n)
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
p->update_all (Node::strip_mute, strip_n, p->mixer ().strip (strip_n).mute ());
p->update_all (Node::strip_mute, strip_id, p->mixer ().strip (strip_id).mute ());
}
};
struct PluginBypassObserver {
void operator() (ArdourFeedback* p, uint32_t strip_n, uint32_t plugin_n)
void operator() (ArdourFeedback* p, uint32_t strip_id, uint32_t plugin_id)
{
p->update_all (Node::strip_plugin_enable, strip_n, plugin_n,
p->mixer ().strip (strip_n).plugin (plugin_n).enabled ());
p->update_all (Node::strip_plugin_enable, strip_id, plugin_id,
p->mixer ().strip (strip_id).plugin (plugin_id).enabled ());
}
};
struct PluginParamValueObserver {
void operator() (ArdourFeedback* p, uint32_t strip_n, uint32_t plugin_n,
uint32_t param_n, boost::weak_ptr<AutomationControl> ctrl)
void operator() (ArdourFeedback* p, uint32_t strip_id, uint32_t plugin_id,
uint32_t param_id, boost::weak_ptr<AutomationControl> ctrl)
{
boost::shared_ptr<AutomationControl> control = ctrl.lock ();
@@ -91,7 +91,7 @@ struct PluginParamValueObserver {
return;
}
p->update_all (Node::strip_plugin_param_value, strip_n, plugin_n, param_n,
p->update_all (Node::strip_plugin_param_value, strip_id, plugin_id, param_id,
ArdourMixerPlugin::param_value (control));
}
};
@@ -116,19 +116,7 @@ ArdourFeedback::stop ()
{
_periodic_connection.disconnect ();
_transport_connections.drop_connections ();
/*for (StripConnectionMap::iterator it = _strip_connections.begin (); it != _strip_connections.end(); ++it) {
it->second->drop_connections ();
}
_strip_connections.clear();
*/
/*for (PluginConnectionMap::iterator it = _plugin_connections.begin (); it != _plugin_connections.end(); ++it) {
it->second->drop_connections ();
}
_plugin_connections.clear();*/
return 0;
}
@@ -139,34 +127,34 @@ ArdourFeedback::update_all (std::string node, TypedValue value) const
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_n, TypedValue value) const
ArdourFeedback::update_all (std::string node, uint32_t strip_id, TypedValue value) const
{
update_all (node, strip_n, ADDR_NONE, ADDR_NONE, value);
update_all (node, strip_id, ADDR_NONE, ADDR_NONE, value);
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_n, uint32_t plugin_n,
ArdourFeedback::update_all (std::string node, uint32_t strip_id, uint32_t plugin_id,
TypedValue value) const
{
update_all (node, strip_n, plugin_n, ADDR_NONE, value);
update_all (node, strip_id, plugin_id, ADDR_NONE, value);
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_n, uint32_t plugin_n, uint32_t param_n,
ArdourFeedback::update_all (std::string node, uint32_t strip_id, uint32_t plugin_id, uint32_t param_id,
TypedValue value) const
{
AddressVector addr = AddressVector ();
if (strip_n != ADDR_NONE) {
addr.push_back (strip_n);
if (strip_id != ADDR_NONE) {
addr.push_back (strip_id);
}
if (plugin_n != ADDR_NONE) {
addr.push_back (plugin_n);
if (plugin_id != ADDR_NONE) {
addr.push_back (plugin_id);
}
if (param_n != ADDR_NONE) {
addr.push_back (param_n);
if (param_id != ADDR_NONE) {
addr.push_back (param_id);
}
ValueVector val = ValueVector ();
@@ -206,32 +194,32 @@ void
ArdourFeedback::observe_mixer ()
{
for (ArdourMixer::StripMap::iterator it = mixer().strips().begin(); it != mixer().strips().end(); ++it) {
uint32_t strip_n = it->first;
uint32_t strip_id = it->first;
ArdourMixerStrip& strip = it->second;
boost::shared_ptr<Stripable> stripable = strip.stripable ();
boost::shared_ptr<PBD::ScopedConnectionList> connections = it->second.connections ();
stripable->gain_control ()->Changed.connect (*connections, MISSING_INVALIDATOR,
boost::bind<void> (StripGainObserver (), this, strip_n), event_loop ());
boost::bind<void> (StripGainObserver (), this, strip_id), event_loop ());
if (stripable->pan_azimuth_control ()) {
stripable->pan_azimuth_control ()->Changed.connect (*connections, MISSING_INVALIDATOR,
boost::bind<void> (StripPanObserver (), this, strip_n), event_loop ());
boost::bind<void> (StripPanObserver (), this, strip_id), event_loop ());
}
stripable->mute_control ()->Changed.connect (*connections, MISSING_INVALIDATOR,
boost::bind<void> (StripMuteObserver (), this, strip_n), event_loop ());
boost::bind<void> (StripMuteObserver (), this, strip_id), event_loop ());
observe_strip_plugins (strip_n, strip.plugins ());
observe_strip_plugins (strip_id, strip.plugins ());
}
}
void
ArdourFeedback::observe_strip_plugins (uint32_t strip_n, ArdourMixerStrip::PluginMap& plugins)
ArdourFeedback::observe_strip_plugins (uint32_t strip_id, ArdourMixerStrip::PluginMap& plugins)
{
for (ArdourMixerStrip::PluginMap::iterator it = plugins.begin(); it != plugins.end(); ++it) {
uint32_t plugin_n = it->first;
uint32_t plugin_id = it->first;
ArdourMixerPlugin& plugin = it->second;
boost::shared_ptr<PluginInsert> insert = plugin.insert ();
boost::shared_ptr<PBD::ScopedConnectionList> connections = plugin.connections ();
@@ -241,27 +229,20 @@ ArdourFeedback::observe_strip_plugins (uint32_t strip_n, ArdourMixerStrip::Plugi
if (control) {
control->Changed.connect (*connections, MISSING_INVALIDATOR,
boost::bind<void> (PluginBypassObserver (), this, strip_n, plugin_n), event_loop ());
boost::bind<void> (PluginBypassObserver (), this, strip_id, plugin_id), event_loop ());
}
observe_strip_plugin_param_values (strip_n, plugin_n, plugin);
}
}
for (uint32_t param_id = 0; param_id < plugin.param_count (); ++param_id) {
try {
boost::shared_ptr<AutomationControl> control = plugin.param_control (param_id);
void
ArdourFeedback::observe_strip_plugin_param_values (uint32_t strip_n,
uint32_t plugin_n, ArdourMixerPlugin& plugin)
{
for (uint32_t param_n = 0; param_n < plugin.param_count (); ++param_n) {
try {
boost::shared_ptr<AutomationControl> control = plugin.param_control (param_n);
control->Changed.connect (*plugin.connections (), MISSING_INVALIDATOR,
boost::bind<void> (PluginParamValueObserver (), this, strip_n, plugin_n, param_n,
boost::weak_ptr<AutomationControl>(control)),
event_loop ());
} catch (ArdourMixerNotFoundException) {
/* ignore */
control->Changed.connect (*plugin.connections (), MISSING_INVALIDATOR,
boost::bind<void> (PluginParamValueObserver (), this, strip_id, plugin_id, param_id,
boost::weak_ptr<AutomationControl>(control)),
event_loop ());
} catch (ArdourMixerNotFoundException) {
/* ignore */
}
}
}
}

1
libs/surfaces/websockets/feedback.h
View File

@@ -52,7 +52,6 @@ private:
void observe_transport ();
void observe_mixer ();
void observe_strip_plugins (uint32_t, ArdourMixerStrip::PluginMap&);
void observe_strip_plugin_param_values (uint32_t, uint32_t, ArdourMixerPlugin&);
};
#endif // _ardour_surface_websockets_feedback_h_

54
libs/surfaces/websockets/mixer.cc
View File

@@ -69,15 +69,15 @@ ArdourMixerPlugin::param_count () const
}
TypedValue
ArdourMixerPlugin::param_value (uint32_t param_n)
ArdourMixerPlugin::param_value (uint32_t param_id)
{
return param_value (param_control (param_n));
return param_value (param_control (param_id));
}
void
ArdourMixerPlugin::set_param_value (uint32_t param_n, TypedValue value)
ArdourMixerPlugin::set_param_value (uint32_t param_id, TypedValue value)
{
boost::shared_ptr<AutomationControl> control = param_control (param_n);
boost::shared_ptr<AutomationControl> control = param_control (param_id);
ParameterDescriptor pd = control->desc ();
double dbl_val;
@@ -93,15 +93,15 @@ ArdourMixerPlugin::set_param_value (uint32_t param_n, TypedValue value)
}
boost::shared_ptr<ARDOUR::AutomationControl>
ArdourMixerPlugin::param_control (uint32_t param_n) const
ArdourMixerPlugin::param_control (uint32_t param_id) const
{
bool ok = false;
boost::shared_ptr<Plugin> plugin = _insert->plugin ();
uint32_t control_id = plugin->nth_parameter (param_n, ok);
uint32_t control_id = plugin->nth_parameter (param_id, ok);
if (!ok || !plugin->parameter_is_input (control_id)) {
throw ArdourMixerNotFoundException("invalid automation control for param id = "
+ boost::lexical_cast<std::string>(param_n));
+ boost::lexical_cast<std::string>(param_id));
}
return _insert->automation_control (Evoral::Parameter (PluginAutomation, 0, control_id));
@@ -139,8 +139,8 @@ ArdourMixerStrip::ArdourMixerStrip (boost::shared_ptr<ARDOUR::Stripable> stripab
return;
}
for (uint32_t plugin_n = 0;; ++plugin_n) {
boost::shared_ptr<Processor> processor = route->nth_plugin (plugin_n);
for (uint32_t plugin_id = 0;; ++plugin_id) {
boost::shared_ptr<Processor> processor = route->nth_plugin (plugin_id);
if (!processor) {
break;
@@ -151,8 +151,8 @@ ArdourMixerStrip::ArdourMixerStrip (boost::shared_ptr<ARDOUR::Stripable> stripab
if (insert) {
ArdourMixerPlugin plugin (insert);
plugin.insert ()->DropReferences.connect (*plugin.connections (), MISSING_INVALIDATOR,
boost::bind (&ArdourMixerStrip::on_drop_plugin, this, plugin_n), event_loop);
_plugins.emplace (plugin_n, plugin);
boost::bind (&ArdourMixerStrip::on_drop_plugin, this, plugin_id), event_loop);
_plugins.emplace (plugin_id, plugin);
}
}
}
@@ -175,13 +175,13 @@ ArdourMixerStrip::connections () const
}
ArdourMixerPlugin&
ArdourMixerStrip::plugin (uint32_t plugin_n)
ArdourMixerStrip::plugin (uint32_t plugin_id)
{
if (_plugins.find (plugin_n) == _plugins.end ()) {
throw ArdourMixerNotFoundException ("plugin id = " + boost::lexical_cast<std::string>(plugin_n) + " not found");
if (_plugins.find (plugin_id) == _plugins.end ()) {
throw ArdourMixerNotFoundException ("plugin id = " + boost::lexical_cast<std::string>(plugin_id) + " not found");
}
return _plugins.at (plugin_n);
return _plugins.at (plugin_id);
}
ArdourMixerStrip::PluginMap&
@@ -252,9 +252,9 @@ ArdourMixerStrip::name () const
}
void
ArdourMixerStrip::on_drop_plugin (uint32_t plugin_n)
ArdourMixerStrip::on_drop_plugin (uint32_t plugin_id)
{
_plugins.erase (plugin_n);
_plugins.erase (plugin_id);
}
double
@@ -287,14 +287,14 @@ ArdourMixer::start ()
/* take a snapshot of current strips */
StripableList strips;
session ().get_stripables (strips, PresentationInfo::AllStripables);
uint32_t strip_n = 0;
uint32_t strip_id = 0;
for (StripableList::iterator it = strips.begin (); it != strips.end (); ++it) {
ArdourMixerStrip strip (*it, event_loop ());
strip.stripable ()->DropReferences.connect (*strip.connections (), MISSING_INVALIDATOR,
boost::bind (&ArdourMixer::on_drop_strip, this, strip_n), event_loop ());
_strips.emplace (strip_n, strip);
strip_n++;
boost::bind (&ArdourMixer::on_drop_strip, this, strip_id), event_loop ());
_strips.emplace (strip_id, strip);
strip_id++;
}
return 0;
@@ -316,20 +316,20 @@ ArdourMixer::strips ()
ArdourMixerStrip&
ArdourMixer::strip (uint32_t strip_n)
ArdourMixer::strip (uint32_t strip_id)
{
if (_strips.find (strip_n) == _strips.end ()) {
throw ArdourMixerNotFoundException ("strip id = " + boost::lexical_cast<std::string>(strip_n) + " not found");
if (_strips.find (strip_id) == _strips.end ()) {
throw ArdourMixerNotFoundException ("strip id = " + boost::lexical_cast<std::string>(strip_id) + " not found");
}
return _strips.at (strip_n);
return _strips.at (strip_id);
}
void
ArdourMixer::on_drop_strip (uint32_t strip_n)
ArdourMixer::on_drop_strip (uint32_t strip_id)
{
Glib::Threads::Mutex::Lock lock (_mutex);
_strips.erase (strip_n);
_strips.erase (strip_id);
}
Glib::Threads::Mutex&