#include "ardour/midi_port.h"
#include "ardour/monitor_processor.h"
#include "ardour/pannable.h"
+#include "ardour/panner.h"
#include "ardour/panner_shell.h"
#include "ardour/plugin_insert.h"
#include "ardour/port.h"
Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
{
- /* run a configure so that the invisible processors get set up */
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
configure_processors (0);
}
framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
int declick, bool gain_automation_ok)
{
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+ assert(lm.locked());
+
/* figure out if we're going to use gain automation */
if (gain_automation_ok) {
_amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
}
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
// configure redirect ports properly, etc.
{
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
if (configure_processors_unlocked (err)) {
pstate.restore ();
configure_processors_unlocked (0); // it worked before we tried to add it ...
} else if (node.name() == "Send") {
- processor.reset (new Send (_session, _pannable, _mute_master));
+ boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
+ processor.reset (new Send (_session, sendpan, _mute_master));
} else {
}
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
(*i)->activate ();
}
+ /* Think: does this really need to be called for every processor in the loop? */
{
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (configure_processors_unlocked (err)) {
pstate.restore ();
configure_processors_unlocked (0); // it worked before we tried to add it ...
}
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorList new_list;
ProcessorStreams err;
}
_processors = new_list;
-
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- configure_processors_unlocked (&err); // this can't fail
- }
+ configure_processors_unlocked (&err); // this can't fail
}
processor_max_streams.reset();
processor_max_streams.reset();
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
+ if (need_process_lock) {
+ lx.acquire();
+ }
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
return 1;
}
- if (need_process_lock) {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
- if (configure_processors_unlocked (err)) {
- pstate.restore ();
- /* we know this will work, because it worked before :) */
- configure_processors_unlocked (0);
- return -1;
- }
- } else {
- if (configure_processors_unlocked (err)) {
- pstate.restore ();
- /* we know this will work, because it worked before :) */
- configure_processors_unlocked (0);
- return -1;
- }
+ if (configure_processors_unlocked (err)) {
+ pstate.restore ();
+ /* we know this will work, because it worked before :) */
+ configure_processors_unlocked (0);
+ return -1;
}
_have_internal_generator = false;
}
}
}
+ if (need_process_lock) {
+ lx.release();
+ }
}
reset_instrument_info ();
processor_max_streams.reset();
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
_output->set_user_latency (0);
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
- if (configure_processors_unlocked (err)) {
- pstate.restore ();
- /* we know this will work, because it worked before :) */
- configure_processors_unlocked (0);
- return -1;
- }
+ if (configure_processors_unlocked (err)) {
+ pstate.restore ();
+ /* we know this will work, because it worked before :) */
+ configure_processors_unlocked (0);
+ return -1;
}
+ //lx.unlock();
_have_internal_generator = false;
return 0;
}
+void
+Route::set_custom_panner_uri (std::string const panner_uri)
+{
+ if (_in_configure_processors) {
+ DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1' -- called while in_configure_processors\n"), name()));
+ return;
+ }
+
+ if (!_main_outs->panner_shell()->set_user_selected_panner_uri(panner_uri)) {
+ DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1 '%2' -- no change needed\n"), name(), panner_uri));
+ /* no change needed */
+ return;
+ }
+
+ DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1 '%2' -- reconfigure I/O\n"), name(), panner_uri));
+
+ /* reconfigure I/O -- re-initialize panner modules */
+ {
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+ Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+
+ for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
+ boost::shared_ptr<Delivery> dl;
+ boost::shared_ptr<Panner> panner;
+ if ((dl = boost::dynamic_pointer_cast<Delivery> (*p)) == 0) {
+ continue;
+ }
+ if (!dl->panner_shell()) {
+ continue;
+ }
+ if (!(panner = dl->panner_shell()->panner())) {
+ continue;
+ }
+ /* _main_outs has already been set before the loop.
+ * Ignore the return status here. It need reconfiguration */
+ if (dl->panner_shell() != _main_outs->panner_shell()) {
+ if (!dl->panner_shell()->set_user_selected_panner_uri(panner_uri)) {
+ continue;
+ }
+ }
+
+ ChanCount in = panner->in();
+ ChanCount out = panner->out();
+ dl->panner_shell()->configure_io(in, out);
+ dl->panner_shell()->pannable()->set_panner(dl->panner_shell()->panner());
+ }
+ }
+
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ _session.set_dirty ();
+}
+
void
Route::reset_instrument_info ()
{
Route::configure_processors (ProcessorStreams* err)
{
assert (!AudioEngine::instance()->process_lock().trylock());
-
if (!_in_configure_processors) {
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
return configure_processors_unlocked (err);
*/
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
/* If the meter is in a custom position, find it and make a rough note of its position */
maybe_note_meter_position ();
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
- if (configure_processors_unlocked (err)) {
- pstate.restore ();
- return -1;
- }
+ if (configure_processors_unlocked (err)) {
+ pstate.restore ();
+ return -1;
}
}
if (prop->value() == "intsend") {
- processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
+ boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
+ processor.reset (new InternalSend (_session, sendpan, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
} else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
prop->value() == "lv2" ||
} else if (prop->value() == "send") {
- processor.reset (new Send (_session, _pannable, _mute_master));
+ boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
+ processor.reset (new Send (_session, sendpan, _mute_master));
} else {
error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
}
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
_processors = new_order;
if (must_configure) {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
configure_processors_unlocked (0);
}
/* master never sends to monitor section via the normal mechanism */
assert (!is_master ());
+ assert (!is_monitor ());
/* make sure we have one */
if (!_monitor_send) {
{
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
+ boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
+ listener.reset (new InternalSend (_session, sendpan, _mute_master, route, Delivery::Aux));
}
add_processor (listener, before);
Route::listen_position_changed ()
{
{
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
ProcessorState pstate (this);
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
- if (configure_processors_unlocked (0)) {
- pstate.restore ();
- configure_processors_unlocked (0); // it worked before we tried to add it ...
- return;
- }
+ if (configure_processors_unlocked (0)) {
+ pstate.restore ();
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return;
}
}
_capturing_processor.reset (new CapturingProcessor (_session));
_capturing_processor->activate ();
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- configure_processors (0);
- }
+ configure_processors (0);
}
boost::shared_ptr<Processor>
Route::the_instrument () const
{
- Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
return the_instrument_unlocked ();
}
}
{
+ //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {