13
0
livetrax/libs/surfaces/websockets/feedback.cc

291 lines
8.7 KiB
C++
Raw Normal View History

2020-02-20 07:12:36 -05:00
/*
2021-06-14 08:45:51 -04:00
* Copyright (C) 2020-2021 Luciano Iam <oss@lucianoiam.com>
2020-02-20 07:12:36 -05:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "ardour/plugin_insert.h"
2020-02-20 07:12:36 -05:00
#include "ardour/session.h"
#include "ardour/tempo.h"
#include "pbd/abstract_ui.cc" // instantiate template
2020-02-20 07:12:36 -05:00
#include "feedback.h"
#include "transport.h"
2020-02-20 07:12:36 -05:00
#include "server.h"
#include "state.h"
2020-02-20 07:12:36 -05:00
2020-04-22 05:26:51 -04:00
// TO DO: make this configurable
#define POLL_INTERVAL_MS 100
2020-02-20 07:12:36 -05:00
using namespace ARDOUR;
using namespace ArdourSurface;
2020-02-20 07:12:36 -05:00
struct TransportObserver {
void operator() (ArdourFeedback* p)
{
p->update_all (Node::transport_roll, p->transport ().roll ());
}
};
struct RecordStateObserver {
void operator() (ArdourFeedback* p)
{
p->update_all (Node::transport_record, p->transport ().record ());
}
};
2020-02-22 06:49:52 -05:00
struct TempoObserver {
void operator() (ArdourFeedback* p)
{
p->update_all (Node::transport_tempo, p->transport ().tempo ());
}
2020-02-22 06:49:52 -05:00
};
struct StripGainObserver {
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
// fires multiple times (4x as of ardour 6.0)
p->update_all (Node::strip_gain, strip_id, p->mixer ().strip (strip_id).gain ());
}
2020-02-22 06:49:52 -05:00
};
struct StripPanObserver {
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
p->update_all (Node::strip_pan, strip_id, p->mixer ().strip (strip_id).pan ());
}
2020-02-22 06:49:52 -05:00
};
struct StripMuteObserver {
void operator() (ArdourFeedback* p, uint32_t strip_id)
{
p->update_all (Node::strip_mute, strip_id, p->mixer ().strip (strip_id).mute ());
}
2020-02-22 06:49:52 -05:00
};
struct PluginBypassObserver {
void operator() (ArdourFeedback* p, uint32_t strip_id, uint32_t plugin_id)
{
p->update_all (Node::strip_plugin_enable, strip_id, plugin_id,
p->mixer ().strip (strip_id).plugin (plugin_id).enabled ());
}
2020-02-22 06:49:52 -05:00
};
struct PluginParamValueObserver {
void operator() (ArdourFeedback* p, uint32_t strip_id, uint32_t plugin_id,
uint32_t param_id, std::weak_ptr<AutomationControl> ctrl)
{
std::shared_ptr<AutomationControl> control = ctrl.lock ();
if (!control) {
return;
}
2022-01-09 16:19:20 -05:00
p->update_all (Node::strip_plugin_param_value, strip_id, plugin_id, param_id,
ArdourMixerPlugin::param_value (control));
}
2020-02-22 06:49:52 -05:00
};
2020-02-20 07:12:36 -05:00
FeedbackHelperUI::FeedbackHelperUI()
: AbstractUI<BaseUI::BaseRequestObject> ("WS_FeedbackHelperUI")
{
}
FeedbackHelperUI::~FeedbackHelperUI ()
{
}
void
FeedbackHelperUI::do_request (BaseUI::BaseRequestObject* req) {
if (req->type == CallSlot) {
call_slot (MISSING_INVALIDATOR, req->the_slot);
} else if (req->type == Quit) {
quit ();
}
};
2020-02-20 07:12:36 -05:00
int
ArdourFeedback::start ()
{
observe_transport ();
observe_mixer ();
2020-02-20 07:12:36 -05:00
// some values need polling like the strip meters
2020-04-22 05:26:51 -04:00
Glib::RefPtr<Glib::TimeoutSource> periodic_timeout = Glib::TimeoutSource::create (POLL_INTERVAL_MS);
_periodic_connection = periodic_timeout->connect (sigc::mem_fun (*this,
&ArdourFeedback::poll));
// server must be started before feedback otherwise
2021-06-14 08:45:51 -04:00
// read_blocks_event_loop() will always return false
if (server ().read_blocks_event_loop ()) {
_helper.run();
periodic_timeout->attach (_helper.main_loop()->get_context ());
} else {
periodic_timeout->attach (main_loop ()->get_context ());
}
2020-02-20 07:12:36 -05:00
return 0;
2020-02-20 07:12:36 -05:00
}
int
ArdourFeedback::stop ()
{
if (server ().read_blocks_event_loop ()) {
_helper.quit();
}
_periodic_connection.disconnect ();
_transport_connections.drop_connections ();
2022-01-09 16:19:20 -05:00
return 0;
2020-02-20 07:12:36 -05:00
}
2020-02-22 06:49:52 -05:00
void
ArdourFeedback::update_all (std::string node, TypedValue value) const
{
update_all (node, ADDR_NONE, ADDR_NONE, ADDR_NONE, value);
2020-02-22 06:49:52 -05:00
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_id, TypedValue value) const
2020-02-22 06:49:52 -05:00
{
update_all (node, strip_id, ADDR_NONE, ADDR_NONE, value);
2020-02-22 06:49:52 -05:00
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_id, uint32_t plugin_id,
TypedValue value) const
2020-02-22 06:49:52 -05:00
{
update_all (node, strip_id, plugin_id, ADDR_NONE, value);
2020-02-22 06:49:52 -05:00
}
void
ArdourFeedback::update_all (std::string node, uint32_t strip_id, uint32_t plugin_id, uint32_t param_id,
TypedValue value) const
2020-02-22 06:49:52 -05:00
{
AddressVector addr = AddressVector ();
2020-02-22 06:49:52 -05:00
if (strip_id != ADDR_NONE) {
addr.push_back (strip_id);
}
2020-02-22 06:49:52 -05:00
if (plugin_id != ADDR_NONE) {
addr.push_back (plugin_id);
}
2020-02-22 06:49:52 -05:00
if (param_id != ADDR_NONE) {
addr.push_back (param_id);
}
2020-02-22 06:49:52 -05:00
ValueVector val = ValueVector ();
val.push_back (value);
2020-02-22 06:49:52 -05:00
server ().update_all_clients (NodeState (node, addr, val), false);
2020-02-22 06:49:52 -05:00
}
PBD::EventLoop*
ArdourFeedback::event_loop () const
{
if (server ().read_blocks_event_loop ()) {
return static_cast<PBD::EventLoop*> (&_helper);
} else {
return SurfaceComponent::event_loop ();
}
}
2020-02-20 07:12:36 -05:00
bool
ArdourFeedback::poll () const
{
update_all (Node::transport_time, transport ().time ());
2022-01-09 16:19:20 -05:00
update_all (Node::transport_bbt, transport ().bbt ());
2020-08-29 16:41:47 -04:00
Glib::Threads::Mutex::Lock lock (mixer ().mutex ());
for (ArdourMixer::StripMap::iterator it = mixer ().strips ().begin (); it != mixer ().strips ().end (); ++it) {
double db = it->second->meter_level_db ();
update_all (Node::strip_meter, it->first, db);
}
return true;
2020-02-20 07:12:36 -05:00
}
void
ArdourFeedback::observe_transport ()
2020-02-20 07:12:36 -05:00
{
ARDOUR::Session& sess = session ();
sess.TransportStateChange.connect (_transport_connections, MISSING_INVALIDATOR,
boost::bind<void> (TransportObserver (), this), event_loop ());
sess.RecordStateChanged.connect (_transport_connections, MISSING_INVALIDATOR,
boost::bind<void> (RecordStateObserver (), this), event_loop ());
Temporal::TempoMap::MapChanged.connect (_transport_connections, MISSING_INVALIDATOR, boost::bind<void> (TempoObserver (), this), event_loop ());
2020-02-20 07:12:36 -05:00
}
void
ArdourFeedback::observe_mixer ()
2020-02-20 07:12:36 -05:00
{
for (ArdourMixer::StripMap::iterator it = mixer().strips().begin(); it != mixer().strips().end(); ++it) {
uint32_t strip_id = it->first;
std::shared_ptr<ArdourMixerStrip> strip = it->second;
std::shared_ptr<Stripable> stripable = strip->stripable ();
stripable->gain_control ()->Changed.connect (*it->second, MISSING_INVALIDATOR,
boost::bind<void> (StripGainObserver (), this, strip_id), event_loop ());
2020-02-20 07:12:36 -05:00
if (stripable->pan_azimuth_control ()) {
stripable->pan_azimuth_control ()->Changed.connect (*it->second, MISSING_INVALIDATOR,
boost::bind<void> (StripPanObserver (), this, strip_id), event_loop ());
}
2020-02-20 07:12:36 -05:00
stripable->mute_control ()->Changed.connect (*it->second, MISSING_INVALIDATOR,
boost::bind<void> (StripMuteObserver (), this, strip_id), event_loop ());
observe_strip_plugins (strip_id, strip->plugins ());
}
2020-02-20 07:12:36 -05:00
}
void
ArdourFeedback::observe_strip_plugins (uint32_t strip_id, ArdourMixerStrip::PluginMap& plugins)
2020-02-20 07:12:36 -05:00
{
for (ArdourMixerStrip::PluginMap::iterator it = plugins.begin(); it != plugins.end(); ++it) {
2020-09-05 07:12:04 -04:00
uint32_t plugin_id = it->first;
std::shared_ptr<ArdourMixerPlugin> plugin = it->second;
std::shared_ptr<PluginInsert> insert = plugin->insert ();
2020-09-05 07:12:04 -04:00
uint32_t bypass = insert->plugin ()->designated_bypass_port ();
Evoral::Parameter param = Evoral::Parameter (PluginAutomation, 0, bypass);
std::shared_ptr<AutomationControl> control = insert->automation_control (param);
if (control) {
control->Changed.connect (*plugin, MISSING_INVALIDATOR,
boost::bind<void> (PluginBypassObserver (), this, strip_id, plugin_id), event_loop ());
}
for (uint32_t param_id = 0; param_id < plugin->param_count (); ++param_id) {
try {
std::shared_ptr<AutomationControl> control = plugin->param_control (param_id);
control->Changed.connect (*plugin, MISSING_INVALIDATOR,
boost::bind<void> (PluginParamValueObserver (), this, strip_id, plugin_id, param_id,
std::weak_ptr<AutomationControl>(control)),
event_loop ());
2020-08-30 15:15:33 -04:00
} catch (ArdourMixerNotFoundException& e) {
/* ignore */
}
}
}
}