#include <cmath>
#include <fstream>
+#include <cassert>
#include <sigc++/bind.h>
#include <pbd/xml++.h>
#include <ardour/timestamps.h>
#include <ardour/audioengine.h>
#include <ardour/route.h>
+#include <ardour/buffer.h>
#include <ardour/insert.h>
#include <ardour/send.h>
#include <ardour/session.h>
#include <ardour/cycle_timer.h>
#include <ardour/route_group.h>
#include <ardour/port.h>
+#include <ardour/audio_port.h>
#include <ardour/ladspa_plugin.h>
#include <ardour/panner.h>
#include <ardour/dB.h>
#include <ardour/mix.h>
-
+#include <ardour/amp.h>
+#include <ardour/meter.h>
+#include <ardour/buffer_set.h>
#include "i18n.h"
using namespace std;
using namespace ARDOUR;
-//using namespace sigc;
+using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg)
- : IO (sess, name, input_min, input_max, output_min, output_max),
+Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
+ : IO (sess, name, input_min, input_max, output_min, output_max, default_type),
_flags (flg),
- _midi_solo_control (*this, MIDIToggleControl::SoloControl, _session.midi_port()),
- _midi_mute_control (*this, MIDIToggleControl::MuteControl, _session.midi_port())
+ _solo_control (*this, ToggleControllable::SoloControl),
+ _mute_control (*this, ToggleControllable::MuteControl)
{
init ();
}
Route::Route (Session& sess, const XMLNode& node)
: IO (sess, "route"),
- _midi_solo_control (*this, MIDIToggleControl::SoloControl, _session.midi_port()),
- _midi_mute_control (*this, MIDIToggleControl::MuteControl, _session.midi_port())
+ _solo_control (*this, ToggleControllable::SoloControl),
+ _mute_control (*this, ToggleControllable::MuteControl)
{
init ();
set_state (node);
void
Route::init ()
{
- redirect_max_outs = 0;
+ redirect_max_outs.reset();
_muted = false;
_soloed = false;
_solo_safe = false;
input_changed.connect (mem_fun (this, &Route::input_change_handler));
output_changed.connect (mem_fun (this, &Route::output_change_handler));
-
- reset_midi_control (_session.midi_port(), _session.get_midi_control());
}
Route::~Route ()
{
- GoingAway (); /* EMIT SIGNAL */
clear_redirects (this);
if (_control_outs) {
IO::set_gain (val, src);
}
+/** Process this route for one (sub) cycle (process thread)
+ *
+ * @param bufs Scratch buffers to use for the signal path
+ * @param start_frame Initial transport frame
+ * @param end_frame Final transport frame
+ * @param nframes Number of frames to output (to ports)
+ * @param offset Output offset (of port buffers, for split cycles)
+ *
+ * Note that (end_frame - start_frame) may not be equal to nframes when the
+ * transport speed isn't 1.0 (eg varispeed).
+ */
void
-Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
- jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset, bool with_redirects, int declick,
- bool meter)
+Route::process_output_buffers (BufferSet& bufs,
+ jack_nframes_t start_frame, jack_nframes_t end_frame,
+ jack_nframes_t nframes, jack_nframes_t offset, bool with_redirects, int declick,
+ bool meter)
{
- uint32_t n;
+ // This is definitely very audio-only for now
+ assert(_default_type == DataType::AUDIO);
+
RedirectList::iterator i;
bool post_fader_work = false;
bool mute_declick_applied = false;
declick = _pending_declick;
{
- TentativeLockMonitor cm (control_outs_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
if (cm.locked()) {
co = _control_outs;
}
{
- TentativeLockMonitor dm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
if (dm.locked()) {
dmg = desired_mute_gain;
-------------------------------------------------------------------------------------------------- */
if (declick > 0) {
- apply_declick (bufs, nbufs, nframes, 0.0, 1.0, _phase_invert);
+ Amp::run (bufs, nframes, 0.0, 1.0, _phase_invert);
_pending_declick = 0;
} else if (declick < 0) {
- apply_declick (bufs, nbufs, nframes, 1.0, 0.0, _phase_invert);
+ Amp::run (bufs, nframes, 1.0, 0.0, _phase_invert);
_pending_declick = 0;
} else {
/* no global declick */
if (solo_gain != dsg) {
- apply_declick (bufs, nbufs, nframes, solo_gain, dsg, _phase_invert);
+ Amp::run (bufs, nframes, solo_gain, dsg, _phase_invert);
solo_gain = dsg;
}
}
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterInput)) {
- for (n = 0; n < nbufs; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
- }
+ _meter->run(bufs, nframes);
}
if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, _phase_invert);
+ Amp::run (bufs, nframes, mute_gain, dmg, _phase_invert);
mute_gain = dmg;
mute_declick_applied = true;
}
} else {
- co->deliver_output (bufs, nbufs, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
-------------------------------------------------------------------------------------------------- */
if (with_redirects) {
- TentativeRWLockMonitor rm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_pre_fader) {
for (i = _redirects.begin(); i != _redirects.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
- (*i)->run (bufs, nbufs, nframes, offset);
+ (*i)->run (bufs, start_frame, end_frame, nframes, offset);
break;
case PostFader:
post_fader_work = true;
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, _phase_invert);
+ Amp::run (bufs, nframes, mute_gain, dmg, _phase_invert);
mute_gain = dmg;
mute_declick_applied = true;
}
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPreFader)) {
- for (n = 0; n < nbufs; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
- }
+ _meter->run(bufs, nframes);
}
} else {
- co->deliver_output (bufs, nbufs, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
if (apply_gain_automation) {
if (_phase_invert) {
- for (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data(nframes);
for (jack_nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= -gab[nx];
}
}
} else {
- for (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data(nframes);
for (jack_nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= gab[nx];
if (_gain != dg) {
- apply_declick (bufs, nbufs, nframes, _gain, dg, _phase_invert);
+ Amp::run (bufs, nframes, _gain, dg, _phase_invert);
_gain = dg;
} else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
this_gain = _gain;
}
- for (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data(nframes);
apply_gain_to_buffer(sp,nframes,this_gain);
}
} else if (_gain == 0) {
- for (n = 0; n < nbufs; ++n) {
- memset (bufs[n], 0, sizeof (Sample) * nframes);
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ i->clear();
}
}
}
if (post_fader_work) {
- TentativeRWLockMonitor rm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_post_fader) {
for (i = _redirects.begin(); i != _redirects.end(); ++i) {
case PreFader:
break;
case PostFader:
- (*i)->run (bufs, nbufs, nframes, offset);
+ (*i)->run (bufs, start_frame, end_frame, nframes, offset);
break;
}
}
}
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, _phase_invert);
+ Amp::run (bufs, nframes, mute_gain, dmg, _phase_invert);
mute_gain = dmg;
mute_declick_applied = true;
}
solo_audible = solo_gain > 0;
mute_audible = dmg > 0 || !_mute_affects_control_outs;
-
+
if ( // silent anyway
(_gain == 0 && !apply_gain_automation) ||
} else {
- co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
----------------------------------------------------------------------*/
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, _phase_invert);
+ Amp::run (bufs, nframes, mute_gain, dmg, _phase_invert);
mute_gain = dmg;
mute_declick_applied = true;
}
solo_audible = dsg > 0;
mute_audible = dmg > 0 || !_mute_affects_main_outs;
- if (n_outputs() == 0) {
+ if (n_outputs().get(_default_type) == 0) {
/* relax */
*/
if (_meter_point == MeterPostFader) {
- reset_peak_meters ();
+ peak_meter().reset();
}
IO::silence (nframes, offset);
} else {
- if (_session.transport_speed() > 1.5f || _session.transport_speed() < -1.5f) {
- pan (bufs, nbufs, nframes, offset, speed_quietning);
- } else {
- // cerr << "panner state = " << _panner->automation_state() << endl;
- if (!_panner->empty() &&
- (_panner->automation_state() & Play ||
- ((_panner->automation_state() & Touch) && !_panner->touching()))) {
- pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
- } else {
- pan (bufs, nbufs, nframes, offset, 1.0);
- }
- }
+ deliver_output(bufs, start_frame, end_frame, nframes, offset);
+
}
}
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPostFader)) {
-// cerr << "meter post" << endl;
-
if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
- uint32_t no = n_outputs();
- for (n = 0; n < no; ++n) {
- _peak_power[n] = 0;
- }
+ _meter->reset();
} else {
- uint32_t no = n_outputs();
- for (n = 0; n < no; ++n) {
- _peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
- }
+ _meter->run(output_buffers(), nframes, offset);
}
}
}
-uint32_t
+ChanCount
Route::n_process_buffers ()
{
- return max (n_inputs(), redirect_max_outs);
+ //return max (n_inputs(), redirect_max_outs);
+ return n_inputs(); // FIXME?
}
void
-
Route::passthru (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter_first)
{
- vector<Sample*>& bufs = _session.get_passthru_buffers();
- uint32_t limit = n_process_buffers ();
+ BufferSet& bufs = _session.get_scratch_buffers(n_process_buffers());
_silent = false;
- collect_input (bufs, limit, nframes, offset);
+ collect_input (bufs, nframes, offset);
#define meter_stream meter_first
if (meter_first) {
- for (uint32_t n = 0; n < limit; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
- }
+ _meter->run(bufs, nframes);
meter_stream = false;
} else {
meter_stream = true;
}
- process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
#undef meter_stream
}
void
-Route::set_phase_invert (bool yn, void *src)
+Route::passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter)
{
- if (_phase_invert != yn) {
- _phase_invert = yn;
- }
- // phase_invert_changed (src); /* EMIT SIGNAL */
+ process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
}
void
if (_soloed != yn) {
_soloed = yn;
- solo_changed (src); /* EMIT SIGNAL */
-
- if (_session.get_midi_feedback()) {
- _midi_solo_control.send_feedback (_soloed);
- }
+ solo_changed (src); /* EMIT SIGNAL */
+ _solo_control.Changed (); /* EMIT SIGNAL */
}
}
void
Route::set_solo_mute (bool yn)
{
- LockMonitor lm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (declick_lock);
/* Called by Session in response to another Route being soloed.
*/
_muted = yn;
mute_changed (src); /* EMIT SIGNAL */
- if (_session.get_midi_feedback()) {
- _midi_mute_control.send_feedback (_muted);
- }
+ _mute_control.Changed (); /* EMIT SIGNAL */
- LockMonitor lm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (declick_lock);
desired_mute_gain = (yn?0.0f:1.0f);
}
}
int
-Route::add_redirect (Redirect *redirect, void *src, uint32_t* err_streams)
+Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_rmo = redirect_max_outs;
if (!_session.engine().connected()) {
return 1;
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
+
+ boost::shared_ptr<PluginInsert> pi;
+ boost::shared_ptr<PortInsert> porti;
- PluginInsert* pi;
- PortInsert* porti;
+ redirect->set_default_type(_default_type);
- uint32_t potential_max_streams = 0;
+ ChanCount potential_max_streams;
- if ((pi = dynamic_cast<PluginInsert*>(redirect)) != 0) {
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
pi->set_count (1);
- if (pi->input_streams() == 0) {
- /* instrument plugin */
+ if (pi->input_streams() == ChanCount::ZERO) {
+ /* generator plugin */
_have_internal_generator = true;
}
potential_max_streams = max(pi->input_streams(), pi->output_streams());
-
- } else if ((porti = dynamic_cast<PortInsert*>(redirect)) != 0) {
+
+ } else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
/* force new port inserts to start out with an i/o configuration
that matches this route's i/o configuration.
}
// Ensure peak vector sizes before the plugin is activated
- while (_peak_power.size() < potential_max_streams) {
- _peak_power.push_back(0);
- }
- while (_stored_peak_power.size() < potential_max_streams) {
- _stored_peak_power.push_back(0);
- }
+ _meter->setup(potential_max_streams);
_redirects.push_back (redirect);
redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
}
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
+ if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
int
Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_rmo = redirect_max_outs;
if (!_session.engine().connected()) {
return 1;
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator existing_end = _redirects.end();
--existing_end;
- uint32_t potential_max_streams = 0;
+ ChanCount potential_max_streams;
for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
- PluginInsert* pi;
+ boost::shared_ptr<PluginInsert> pi;
- if ((pi = dynamic_cast<PluginInsert*>(*i)) != 0) {
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
pi->set_count (1);
- uint32_t m = max(pi->input_streams(), pi->output_streams());
+ ChanCount m = max(pi->input_streams(), pi->output_streams());
if (m > potential_max_streams)
potential_max_streams = m;
}
// Ensure peak vector sizes before the plugin is activated
- while (_peak_power.size() < potential_max_streams) {
- _peak_power.push_back(0);
- }
- while (_stored_peak_power.size() < potential_max_streams) {
- _stored_peak_power.push_back(0);
- }
+ _meter->setup(potential_max_streams);
_redirects.push_back (*i);
}
}
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
+ if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
void
Route::clear_redirects (void *src)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_rmo = redirect_max_outs;
if (!_session.engine().connected()) {
return;
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
-
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- delete *i;
- }
-
+ Glib::RWLock::WriterLock lm (redirect_lock);
_redirects.clear ();
}
reset_panner ();
}
- redirect_max_outs = 0;
+ redirect_max_outs.reset();
_have_internal_generator = false;
redirects_changed (src); /* EMIT SIGNAL */
}
int
-Route::remove_redirect (Redirect *redirect, void *src, uint32_t* err_streams)
+Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_rmo = redirect_max_outs;
if (!_session.engine().connected()) {
return 1;
}
- redirect_max_outs = 0;
+ redirect_max_outs.reset();
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator i;
bool removed = false;
run.
*/
- Send* send;
- PortInsert* port_insert;
+ boost::shared_ptr<Send> send;
+ boost::shared_ptr<PortInsert> port_insert;
- if ((send = dynamic_cast<Send*> (*i)) != 0) {
+ if ((send = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
send->disconnect_inputs (this);
send->disconnect_outputs (this);
- } else if ((port_insert = dynamic_cast<PortInsert*> (*i)) != 0) {
+ } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (*i)) != 0) {
port_insert->disconnect_inputs (this);
port_insert->disconnect_outputs (this);
}
bool foo = false;
for (i = _redirects.begin(); i != _redirects.end(); ++i) {
- PluginInsert* pi;
-
- if ((pi = dynamic_cast<PluginInsert*>(*i)) != 0) {
+ boost::shared_ptr<PluginInsert> pi;
+
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
if (pi->is_generator()) {
foo = true;
}
int
Route::reset_plugin_counts (uint32_t* lpc)
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
return _reset_plugin_counts (lpc);
}
map<Placement,list<InsertCount> > insert_map;
jack_nframes_t initial_streams;
- redirect_max_outs = 0;
+ redirect_max_outs.reset();
i_cnt = 0;
s_cnt = 0;
for (r = _redirects.begin(); r != _redirects.end(); ++r) {
- Insert *insert;
+ boost::shared_ptr<Insert> insert;
/* do this here in case we bomb out before we get to the end of
this function.
redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
- if ((insert = dynamic_cast<Insert*>(*r)) != 0) {
+ if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
++i_cnt;
- insert_map[insert->placement()].push_back (InsertCount (*insert));
+ insert_map[insert->placement()].push_back (InsertCount (insert));
/* reset plugin counts back to one for now so
that we have a predictable, controlled
state to try to configure.
*/
- PluginInsert* pi;
+ boost::shared_ptr<PluginInsert> pi;
- if ((pi = dynamic_cast<PluginInsert*>(insert)) != 0) {
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
pi->set_count (1);
}
- } else if (dynamic_cast<Send*> (*r) != 0) {
+ } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
++s_cnt;
}
}
/* A: PreFader */
- if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
+ if (check_some_plugin_counts (insert_map[PreFader], n_inputs ().get(_default_type), err_streams)) {
return -1;
}
if (!insert_map[PreFader].empty()) {
InsertCount& ic (insert_map[PreFader].back());
- initial_streams = ic.insert.compute_output_streams (ic.cnt);
+ initial_streams = ic.insert->compute_output_streams (ic.cnt);
} else {
- initial_streams = n_inputs ();
+ initial_streams = n_inputs ().get(_default_type);
}
/* B: PostFader */
recompute:
- redirect_max_outs = 0;
+ redirect_max_outs.reset();
RedirectList::iterator prev = _redirects.end();
for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
- Send* s;
+ boost::shared_ptr<Send> s;
- if ((s = dynamic_cast<Send*> (*r)) != 0) {
+ if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
if (r == _redirects.begin()) {
s->expect_inputs (n_inputs());
} else {
}
}
- redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
+ redirect_max_outs = max ((*r)->output_streams(), redirect_max_outs);
}
/* we're done */
for (i = iclist.begin(); i != iclist.end(); ++i) {
- if ((*i).insert.configure_io ((*i).cnt, (*i).in, (*i).out)) {
+ if ((*i).insert->configure_io ((*i).cnt, (*i).in, (*i).out)) {
return -1;
}
/* make sure that however many we have, they are all active */
- (*i).insert.activate ();
+ (*i).insert->activate ();
}
return 0;
for (i = iclist.begin(); i != iclist.end(); ++i) {
- if (((*i).cnt = (*i).insert.can_support_input_configuration (required_inputs)) < 0) {
+ if (((*i).cnt = (*i).insert->can_support_input_configuration (required_inputs)) < 0) {
if (err_streams) {
*err_streams = required_inputs;
}
}
(*i).in = required_inputs;
- (*i).out = (*i).insert.compute_output_streams ((*i).cnt);
+ (*i).out = (*i).insert->compute_output_streams ((*i).cnt);
required_inputs = (*i).out;
}
int
Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_rmo = redirect_max_outs;
if (err_streams) {
*err_streams = 0;
RedirectList to_be_deleted;
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator tmp;
RedirectList the_copy;
for (RedirectList::const_iterator i = other._redirects.begin(); i != other._redirects.end(); ++i) {
if ((*i)->placement() == placement) {
- _redirects.push_back (Redirect::clone (**i));
+ _redirects.push_back (Redirect::clone (*i));
}
}
++tmp;
if ((*i)->placement() == placement) {
- delete *i;
_redirects.erase (i);
}
} else {
/* SUCCESSFUL COPY ATTEMPT: delete the redirects we removed pre-copy */
-
- for (RedirectList::iterator i = to_be_deleted.begin(); i != to_be_deleted.end(); ++i) {
- delete *i;
- }
+ to_be_deleted.clear ();
}
}
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
+ if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
void
Route::all_redirects_flip ()
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (_redirects.empty()) {
return;
void
Route::all_redirects_active (bool state)
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (_redirects.empty()) {
return;
}
struct RedirectSorter {
- bool operator() (const Redirect *a, const Redirect *b) {
+ bool operator() (boost::shared_ptr<const Redirect> a, boost::shared_ptr<const Redirect> b) {
return a->sort_key() < b->sort_key();
}
};
{
{
RedirectSorter comparator;
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
- uint32_t old_rmo = redirect_max_outs;
+ Glib::RWLock::WriterLock lm (redirect_lock);
+ ChanCount old_rmo = redirect_max_outs;
/* the sweet power of C++ ... */
snprintf (buf, sizeof (buf), "0x%x", _flags);
node->add_property("flags", buf);
}
+
+ node->add_property("default-type", _default_type.to_string());
+
node->add_property("active", _active?"yes":"no");
node->add_property("muted", _muted?"yes":"no");
node->add_property("soloed", _soloed?"yes":"no");
node->add_property("mix-group", _mix_group->name());
}
- /* MIDI control */
-
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte additional;
- XMLNode* midi_node = 0;
- XMLNode* child;
-
- midi_node = node->add_child ("MIDI");
-
- if (_midi_mute_control.get_control_info (chn, ev, additional)) {
- child = midi_node->add_child ("mute");
- set_midi_node_info (child, ev, chn, additional);
- }
- if (_midi_solo_control.get_control_info (chn, ev, additional)) {
- child = midi_node->add_child ("solo");
- set_midi_node_info (child, ev, chn, additional);
- }
-
-
string order_string;
OrderKeys::iterator x = order_keys.begin();
Route::add_redirect_from_xml (const XMLNode& node)
{
const XMLProperty *prop;
- Insert *insert = 0;
- Send *send = 0;
if (node.name() == "Send") {
+
try {
- send = new Send (_session, node);
+ boost::shared_ptr<Send> send (new Send (_session, node));
+ add_redirect (send, this);
}
catch (failed_constructor &err) {
return;
}
- add_redirect (send, this);
-
} else if (node.name() == "Insert") {
try {
if ((prop = node.property ("type")) != 0) {
+ boost::shared_ptr<Insert> insert;
+
if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
- insert = new PluginInsert(_session, node);
+ insert.reset (new PluginInsert(_session, node));
} else if (prop->value() == "port") {
- insert = new PortInsert (_session, node);
+ insert.reset (new PortInsert (_session, node));
} else {
XMLNode *child;
XMLPropertyList plist;
const XMLProperty *prop;
- XMLNodeList midi_kids;
-
if (node.name() != "Route"){
error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
} else {
_flags = Flag (0);
}
+
+ if ((prop = node.property ("default-type")) != 0) {
+ _default_type = DataType(prop->value());
+ assert(_default_type != DataType::NIL);
+ }
if ((prop = node.property ("phase-invert")) != 0) {
set_phase_invert(prop->value()=="yes"?true:false, this);
}
}
- midi_kids = node.children ("MIDI");
-
- for (niter = midi_kids.begin(); niter != midi_kids.end(); ++niter) {
-
- XMLNodeList kids;
- XMLNodeConstIterator miter;
- XMLNode* child;
-
- kids = (*niter)->children ();
-
- for (miter = kids.begin(); miter != kids.end(); ++miter) {
-
- child =* miter;
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* ditto */
- MIDI::channel_t chn = 0; /* ditto */
-
- if (child->name() == "mute") {
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_mute_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI mute control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
- else if (child->name() == "solo") {
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_solo_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI mute control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
-
- }
- }
-
-
return 0;
}
{
if (!_silent) {
- // reset_peak_meters ();
-
IO::silence (nframes, offset);
if (_control_outs) {
}
{
- TentativeRWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- PluginInsert* pi;
- if (!_active && (pi = dynamic_cast<PluginInsert*> (*i)) != 0) {
+ boost::shared_ptr<PluginInsert> pi;
+ if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
// skip plugins, they don't need anything when we're not active
continue;
}
int
Route::set_control_outs (const vector<string>& ports)
{
- LockMonitor lm (control_outs_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (control_outs_lock);
vector<string>::const_iterator i;
if (_control_outs) {
_control_outs = new IO (_session, coutname);
/* our control outs need as many outputs as we
- have outputs. we track the changes in ::output_change_handler().
+ have audio outputs. we track the changes in ::output_change_handler().
*/
- _control_outs->ensure_io (0, n_outputs(), true, this);
+ _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().get(DataType::AUDIO)), true, this);
return 0;
}
}
bool
-Route::feeds (Route *o)
+Route::feeds (boost::shared_ptr<Route> other)
{
uint32_t i, j;
- IO& other = *o;
IO& self = *this;
- uint32_t no = self.n_outputs();
- uint32_t ni = other.n_inputs ();
+ uint32_t no = self.n_outputs().get_total();
+ uint32_t ni = other->n_inputs ().get_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
- if (self.output(i)->connected_to (other.input(j)->name())) {
+ if (self.output(i)->connected_to (other->input(j)->name())) {
return true;
}
}
for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
- no = (*r)->n_outputs();
+ no = (*r)->n_outputs().get_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
- if ((*r)->output(i)->connected_to (other.input (j)->name())) {
+ if ((*r)->output(i)->connected_to (other->input (j)->name())) {
return true;
}
}
if (_control_outs) {
- no = _control_outs->n_outputs();
+ no = _control_outs->n_outputs().get_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
- if (_control_outs->output(i)->connected_to (other.input (j)->name())) {
+ if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
return true;
}
}
}
void
-Route::transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
+Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
{
jack_nframes_t now = _session.transport_frame();
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (!did_locate) {
automation_snapshot (now);
{
if (change & ConfigurationChanged) {
if (_control_outs) {
- _control_outs->ensure_io (0, n_outputs(), true, this);
+ _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().get(DataType::AUDIO)), true, this);
}
reset_plugin_counts (0);
uint32_t
Route::pans_required () const
{
- if (n_outputs() < 2) {
+ if (n_outputs().get(DataType::AUDIO) < 2) {
return 0;
}
- return max (n_inputs (), redirect_max_outs);
+ return max (n_inputs ().get(DataType::AUDIO), static_cast<size_t>(redirect_max_outs.get(DataType::AUDIO)));
}
int
Route::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
bool session_state_changing, bool can_record, bool rec_monitors_input)
{
- if (n_outputs() == 0) {
+ if (n_outputs().get_total() == 0) {
return 0;
}
apply_gain_automation = false;
- if (n_inputs()) {
+ if (n_inputs().get_total()) {
passthru (start_frame, end_frame, nframes, offset, 0, false);
} else {
silence (nframes, offset);
bool can_record, bool rec_monitors_input)
{
{
- TentativeRWLockMonitor lm(redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
// automation snapshot can also be called from the non-rt context
// and it uses the redirect list, so we take the lock out here
}
}
- if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
+ if ((n_outputs().get_total() == 0 && _redirects.empty()) || n_inputs().get_total() == 0 || !_active) {
silence (nframes, offset);
return 0;
}
apply_gain_automation = false;
{
- TentativeLockMonitor am (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
if (am.locked() && _session.transport_rolling()) {
- jack_nframes_t start_frame = end_frame - nframes;
-
if (gain_automation_playback()) {
apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
}
void
Route::toggle_monitor_input ()
{
- for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
- (*i)->request_monitor_input(!(*i)->monitoring_input());
+ for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+ i->ensure_monitor_input( ! i->monitoring_input());
}
}
bool
Route::has_external_redirects () const
{
- const PortInsert* pi;
+ boost::shared_ptr<const PortInsert> pi;
for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- if ((pi = dynamic_cast<const PortInsert*>(*i)) != 0) {
-
- uint32_t no = pi->n_outputs();
+ if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
- for (uint32_t n = 0; n < no; ++n) {
+ for (PortSet::const_iterator port = pi->outputs().begin();
+ port != pi->outputs().end(); ++port) {
- string port_name = pi->output(n)->name();
+ string port_name = port->name();
string client_name = port_name.substr (0, port_name.find(':'));
/* only say "yes" if the redirect is actually in use */
return false;
}
-void
-Route::reset_midi_control (MIDI::Port* port, bool on)
-{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
-
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->reset_midi_control (port, on);
- }
-
- IO::reset_midi_control (port, on);
-
- _midi_solo_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_solo_control.midi_rebind (port, chn);
-
- _midi_mute_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_mute_control.midi_rebind (port, chn);
-}
-
-void
-Route::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
-
- {
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->send_all_midi_feedback ();
- }
- }
-
- IO::send_all_midi_feedback();
-
- _midi_solo_control.send_feedback (_soloed);
- _midi_mute_control.send_feedback (_muted);
- }
-}
-
-MIDI::byte*
-Route::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
-{
- buf = _midi_solo_control.write_feedback (buf, bufsize, _soloed);
- buf = _midi_mute_control.write_feedback (buf, bufsize, _muted);
-
- {
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- buf = (*i)->write_midi_feedback (buf, bufsize);
- }
- }
-
- return IO::write_midi_feedback (buf, bufsize);
-}
-
void
Route::flush_redirects ()
{
this is called from the RT audio thread.
*/
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
(*i)->deactivate ();
}
}
-Route::MIDIToggleControl::MIDIToggleControl (Route& s, ToggleType tp, MIDI::Port* port)
- : MIDI::Controllable (port, true), route (s), type(tp), setting(false)
+Route::ToggleControllable::ToggleControllable (Route& s, ToggleType tp)
+ : route (s), type(tp)
{
- last_written = false; /* XXX need a good out-of-bound-value */
+
}
void
-Route::MIDIToggleControl::set_value (float val)
+Route::ToggleControllable::set_value (float val)
{
- MIDI::eventType et;
- MIDI::channel_t chn;
- MIDI::byte additional;
-
- get_control_info (chn, et, additional);
-
- setting = true;
-
-#ifdef HOLD_TOGGLE_VALUES
- if (et == MIDI::off || et == MIDI::on) {
-
- /* literal toggle */
-
- switch (type) {
- case MuteControl:
- route.set_mute (!route.muted(), this);
- break;
- case SoloControl:
- route.set_solo (!route.soloed(), this);
- break;
- default:
- break;
- }
-
- } else {
-#endif
-
- /* map full control range to a boolean */
-
- bool bval = ((val >= 0.5f) ? true: false);
-
- switch (type) {
- case MuteControl:
- route.set_mute (bval, this);
- break;
- case SoloControl:
- route.set_solo (bval, this);
- break;
- default:
- break;
- }
-
-#ifdef HOLD_TOGGLE_VALUES
+ bool bval = ((val >= 0.5f) ? true: false);
+
+ switch (type) {
+ case MuteControl:
+ route.set_mute (bval, this);
+ break;
+ case SoloControl:
+ route.set_solo (bval, this);
+ break;
+ default:
+ break;
}
-#endif
-
- setting = false;
}
-void
-Route::MIDIToggleControl::send_feedback (bool value)
+float
+Route::ToggleControllable::get_value (void) const
{
-
- if (!setting && get_midi_feedback()) {
- MIDI::byte val = (MIDI::byte) (value ? 127: 0);
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
- last_written = value;
-
- route._session.send_midi_message (get_port(), ev, ch, data);
- }
- }
+ float val = 0.0f;
-}
-
-MIDI::byte*
-Route::MIDIToggleControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force)
-{
- if (get_midi_feedback() && bufsize > 2) {
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
-
- if (get_control_info (ch, ev, additional)) {
- if (val != last_written || force) {
- *buf++ = (0xF0 & ev) | (0xF & ch);
- *buf++ = additional; /* controller number */
- *buf++ = (MIDI::byte) (val ? 127 : 0);
- bufsize -= 3;
- last_written = val;
- }
- }
+ switch (type) {
+ case MuteControl:
+ val = route.muted() ? 1.0f : 0.0f;
+ break;
+ case SoloControl:
+ val = route.soloed() ? 1.0f : 0.0f;
+ break;
+ default:
+ break;
}
- return buf;
+ return val;
}
void
}
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- PluginInsert* pi;
- if ((pi = dynamic_cast<PluginInsert*> (*i)) != 0) {
+ boost::shared_ptr<PluginInsert> pi;
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
pi->protect_automation ();
}
}
projects / ardour.git / blobdiff