#include "pbd/stacktrace.h"
#include "pbd/unknown_type.h"
-#include <jack/weakjack.h>
-
#include "midi++/port.h"
-#include "midi++/jack_midi_port.h"
#include "midi++/mmc.h"
-#include "midi++/manager.h"
+#include "ardour/async_midi_port.h"
#include "ardour/audio_port.h"
#include "ardour/audio_backend.h"
#include "ardour/audioengine.h"
#include "ardour/internal_send.h"
#include "ardour/meter.h"
#include "ardour/midi_port.h"
+#include "ardour/midiport_manager.h"
+#include "ardour/mtdm.h"
#include "ardour/port.h"
#include "ardour/process_thread.h"
#include "ardour/session.h"
AudioEngine::AudioEngine ()
: session_remove_pending (false)
, session_removal_countdown (-1)
+ , _running (false)
+ , _freewheeling (false)
, monitor_check_interval (INT32_MAX)
, last_monitor_check (0)
, _processed_frames (0)
- , _freewheeling (false)
- , _pre_freewheel_mmc_enabled (false)
- , _usecs_per_cycle (0)
- , port_remove_in_progress (false)
, m_meter_thread (0)
, _main_thread (0)
+ , _mtdm (0)
+ , _measuring_latency (false)
+ , _latency_input_port (0)
+ , _latency_output_port (0)
+ , _latency_flush_frames (0)
+ , _latency_signal_latency (0)
+ , _stopped_for_latency (false)
+ , _in_destructor (false)
{
g_atomic_int_set (&m_meter_exit, 0);
discover_backends ();
AudioEngine::~AudioEngine ()
{
+ _in_destructor = true;
+ stop_metering_thread ();
drop_backend ();
-
- config_connection.disconnect ();
-
- {
- Glib::Threads::Mutex::Lock tm (_process_lock);
- session_removed.signal ();
- stop_metering_thread ();
- }
}
AudioEngine*
SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
- MIDI::JackMIDIPort::set_process_thread (pthread_self());
+ AsyncMIDIPort::set_process_thread (pthread_self());
}
void
return 0;
}
- cerr << "pc, srp = " << session_remove_pending << endl;
+ bool return_after_remove_check = false;
+
+ if (_measuring_latency && _mtdm) {
+ /* run a normal cycle from the perspective of the PortManager
+ so that we get silence on all registered ports.
+
+ we overwrite the silence on the two ports used for latency
+ measurement.
+ */
+
+ PortManager::cycle_start (nframes);
+ PortManager::silence (nframes);
+
+ if (_latency_input_port && _latency_output_port) {
+ PortEngine& pe (port_engine());
+
+ Sample* in = (Sample*) pe.get_buffer (_latency_input_port, nframes);
+ Sample* out = (Sample*) pe.get_buffer (_latency_output_port, nframes);
+
+ _mtdm->process (nframes, in, out);
+ }
+
+ PortManager::cycle_end (nframes);
+ return_after_remove_check = true;
+
+ } else if (_latency_flush_frames) {
+
+ /* wait for the appropriate duration for the MTDM signal to
+ * drain from the ports before we revert to normal behaviour.
+ */
+
+ PortManager::cycle_start (nframes);
+ PortManager::silence (nframes);
+ PortManager::cycle_end (nframes);
+
+ if (_latency_flush_frames > nframes) {
+ _latency_flush_frames -= nframes;
+ } else {
+ _latency_flush_frames = 0;
+ }
+
+ return_after_remove_check = true;
+ }
if (session_remove_pending) {
/* perform the actual session removal */
- cerr << "\tsrc = " << session_removal_countdown << endl;
-
if (session_removal_countdown < 0) {
/* fade out over 1 second */
- session_removal_countdown = _frame_rate/2;
+ session_removal_countdown = sample_rate()/2;
session_removal_gain = 1.0;
session_removal_gain_step = 1.0/session_removal_countdown;
_session = 0;
session_removal_countdown = -1; // reset to "not in progress"
session_remove_pending = false;
- cerr << "Send removed signal\n";
session_removed.signal(); // wakes up thread that initiated session removal
}
}
+ if (return_after_remove_check) {
+ return 0;
+ }
+
if (_session == 0) {
if (!_freewheeling) {
- MIDI::Manager::instance()->cycle_start(nframes);
- MIDI::Manager::instance()->cycle_end();
+ PortManager::cycle_start (nframes);
+ PortManager::cycle_end (nframes);
}
_processed_frames = next_processed_frames;
/* tell all relevant objects that we're starting a new cycle */
InternalSend::CycleStart (nframes);
- Port::set_global_port_buffer_offset (0);
- Port::set_cycle_framecnt (nframes);
/* tell all Ports that we're starting a new cycle */
- boost::shared_ptr<Ports> p = ports.reader();
-
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
- i->second->cycle_start (nframes);
- }
+ PortManager::cycle_start (nframes);
/* test if we are freewheeling and there are freewheel signals connected.
ardour should act normally even when freewheeling unless /it/ is
- exporting
+ exporting (which is what Freewheel.empty() tests for).
*/
if (_freewheeling && !Freewheel.empty()) {
-
Freewheel (nframes);
-
} else {
- MIDI::Manager::instance()->cycle_start(nframes);
-
if (_session) {
_session->process (nframes);
}
-
- MIDI::Manager::instance()->cycle_end();
}
if (_freewheeling) {
}
if (last_monitor_check + monitor_check_interval < next_processed_frames) {
-
- boost::shared_ptr<Ports> p = ports.reader();
-
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
-
- bool x;
-
- if (i->second->last_monitor() != (x = i->second->monitoring_input ())) {
- i->second->set_last_monitor (x);
- /* XXX I think this is dangerous, due to
- a likely mutex in the signal handlers ...
- */
- i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
- }
- }
+
+ PortManager::check_monitoring ();
last_monitor_check = next_processed_frames;
}
if (_session->silent()) {
-
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
-
- if (i->second->sends_output()) {
- i->second->get_buffer(nframes).silence(nframes);
- }
- }
+ PortManager::silence (nframes);
}
if (session_remove_pending && session_removal_countdown) {
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
-
- if (i->second->sends_output()) {
-
- boost::shared_ptr<AudioPort> ap = boost::dynamic_pointer_cast<AudioPort> (i->second);
- if (ap) {
- Sample* s = ap->engine_get_whole_audio_buffer ();
- gain_t g = session_removal_gain;
-
- for (pframes_t n = 0; n < nframes; ++n) {
- *s++ *= g;
- g -= session_removal_gain_step;
- }
- }
- }
- }
+ PortManager::fade_out (session_removal_gain, session_removal_gain_step, nframes);
if (session_removal_countdown > nframes) {
session_removal_countdown -= nframes;
session_removal_gain -= (nframes * session_removal_gain_step);
}
- // Finalize ports
-
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
- i->second->cycle_end (nframes);
- }
+ PortManager::cycle_end (nframes);
_processed_frames = next_processed_frames;
if (_session) {
- start_metering_thread ();
-
- pframes_t blocksize = _backend->buffer_size ();
-
- /* page in as much of the session process code as we
- can before we really start running.
- */
+ pframes_t blocksize = samples_per_cycle ();
- boost::shared_ptr<Ports> p = ports.reader();
-
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
- i->second->cycle_start (blocksize);
- }
+ PortManager::cycle_start (blocksize);
_session->process (blocksize);
_session->process (blocksize);
_session->process (blocksize);
_session->process (blocksize);
- for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
- i->second->cycle_end (blocksize);
- }
+ PortManager::cycle_end (blocksize);
}
}
if (_running) {
- stop_metering_thread ();
-
if (_session) {
session_remove_pending = true;
session_removal_countdown = 0;
stop_metering_thread ();
_running = false;
- _buffer_size = 0;
- _frame_rate = 0;
}
int
Glib::PatternSpec so_extension_pattern("*backend.so");
Glib::PatternSpec dylib_extension_pattern("*backend.dylib");
+ Glib::PatternSpec dll_extension_pattern("*backend.dll");
find_matching_files_in_search_path (backend_search_path (),
so_extension_pattern, backend_modules);
find_matching_files_in_search_path (backend_search_path (),
dylib_extension_pattern, backend_modules);
+ find_matching_files_in_search_path (backend_search_path (),
+ dll_extension_pattern, backend_modules);
+
DEBUG_TRACE (DEBUG::Panning, string_compose (_("looking for backends in %1\n"), backend_search_path().to_string()));
for (vector<std::string>::iterator i = backend_modules.begin(); i != backend_modules.end(); ++i) {
{
Glib::Module module (path);
AudioBackendInfo* info;
- void* sym = 0;
+ AudioBackendInfo* (*dfunc)(void);
+ void* func = 0;
if (!module) {
error << string_compose(_("AudioEngine: cannot load module \"%1\" (%2)"), path,
return 0;
}
- if (!module.get_symbol ("descriptor", sym)) {
- error << string_compose(_("AudioEngine: backend at \"%1\" has no descriptor."), path) << endmsg;
+ if (!module.get_symbol ("descriptor", func)) {
+ error << string_compose(_("AudioEngine: backend at \"%1\" has no descriptor function."), path) << endmsg;
error << Glib::Module::get_last_error() << endmsg;
return 0;
}
module.make_resident ();
- info = (AudioBackendInfo*) sym;
+ dfunc = (AudioBackendInfo* (*)(void))func;
+ info = dfunc();
return info;
}
if (_backend) {
_backend->stop ();
_backend.reset ();
+ }
+}
- BackendRemoved(); /* EMIT SIGNAL */
+boost::shared_ptr<AudioBackend>
+AudioEngine::set_default_backend ()
+{
+ if (_backends.empty()) {
+ return boost::shared_ptr<AudioBackend>();
}
+
+ return set_backend (_backends.begin()->first, "", "");
}
-int
+boost::shared_ptr<AudioBackend>
AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
{
BackendMap::iterator b = _backends.find (name);
if (b == _backends.end()) {
- return -1;
+ return boost::shared_ptr<AudioBackend>();
}
drop_backend ();
-
+
try {
- cerr << "Instantiate " << b->second->name << " with " << arg1 << " + " << arg2 << endl;
-
if (b->second->instantiate (arg1, arg2)) {
- cerr << "i failed\n";
throw failed_constructor ();
}
- _backend = b->second->backend_factory (*this);
- _impl = b->second->portengine_factory (*this);
+ _backend = b->second->factory (*this);
} catch (exception& e) {
error << string_compose (_("Could not create backend for %1: %2"), name, e.what()) << endmsg;
- return -1;
+ return boost::shared_ptr<AudioBackend>();
}
- BackendAvailable (); /* EMIT SIGNAL */
-
- return 0;
+ return _backend;
}
/* BACKEND PROXY WRAPPERS */
int
-AudioEngine::start ()
+AudioEngine::start (bool for_latency)
{
if (!_backend) {
return -1;
}
- if (!_running) {
-
- if (_session) {
- BootMessage (_("Connect session to engine"));
- _session->set_frame_rate (_backend->sample_rate());
- }
-
- _processed_frames = 0;
- last_monitor_check = 0;
-
- if (_backend->start() == 0) {
- _running = true;
- _has_run = true;
- last_monitor_check = 0;
+ if (_running) {
+ return 0;
+ }
- if (_session && _session->config.get_jack_time_master()) {
- _backend->set_time_master (true);
- }
+ _processed_frames = 0;
+ last_monitor_check = 0;
+
+ if (_backend->start (for_latency)) {
+ return -1;
+ }
- Running(); /* EMIT SIGNAL */
- } else {
- /* should report error? */
+ _running = true;
+
+ if (_session) {
+ _session->set_frame_rate (_backend->sample_rate());
+
+ if (_session->config.get_jack_time_master()) {
+ _backend->set_time_master (true);
}
}
-
- return _running ? 0 : -1;
+
+ start_metering_thread ();
+
+ if (!for_latency) {
+ Running(); /* EMIT SIGNAL */
+ }
+
+ return 0;
}
int
-AudioEngine::stop ()
+AudioEngine::stop (bool for_latency)
{
if (!_backend) {
return 0;
Glib::Threads::Mutex::Lock lm (_process_lock);
- if (_backend->stop () == 0) {
- _running = false;
- stop_metering_thread ();
-
- Stopped (); /* EMIT SIGNAL */
-
- return 0;
+ if (_backend->stop ()) {
+ return -1;
}
+
+ _running = false;
+ _processed_frames = 0;
+ _measuring_latency = false;
+ _latency_output_port = 0;
+ _latency_input_port = 0;
+ _started_for_latency = false;
+ stop_metering_thread ();
+
+ Port::PortDrop ();
- return -1;
-}
-
-int
-AudioEngine::pause ()
-{
- if (!_backend) {
- return 0;
+ if (!for_latency) {
+ Stopped (); /* EMIT SIGNAL */
}
- if (_backend->pause () == 0) {
- _running = false;
- Stopped(); /* EMIT SIGNAL */
- return 0;
- }
-
- return -1;
+ return 0;
}
int
return false;
}
- return _backend->connected();
+ return _backend->available();
}
void
}
int
-AudioEngine::create_process_thread (boost::function<void()> func, pthread_t* thr, size_t stacksize)
+AudioEngine::create_process_thread (boost::function<void()> func)
{
if (!_backend) {
return -1;
}
- return _backend->create_process_thread (func, thr, stacksize);
+ return _backend->create_process_thread (func);
}
+int
+AudioEngine::join_process_threads ()
+{
+ if (!_backend) {
+ return -1;
+ }
+ return _backend->join_process_threads ();
+}
+
+bool
+AudioEngine::in_process_thread ()
+{
+ if (!_backend) {
+ return false;
+ }
+ return _backend->in_process_thread ();
+}
+
+uint32_t
+AudioEngine::process_thread_count ()
+{
+ if (!_backend) {
+ return 0;
+ }
+ return _backend->process_thread_count ();
+}
int
AudioEngine::set_device_name (const std::string& name)
SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
- MIDI::JackMIDIPort::set_process_thread (pthread_self());
+ AsyncMIDIPort::set_process_thread (pthread_self());
if (arg) {
- AudioEngine* ae = static_cast<AudioEngine*> (arg);
/* the special thread created/managed by the backend */
- ae->_main_thread = new ProcessThread;
+ AudioEngine::instance()->_main_thread = new ProcessThread;
}
}
-/* XXXX
-void
-AudioEngine::timebase_callback (TransportState state, pframes_t nframes, jack_position_t pos, int new_position)
-{
- if (_session && _session->synced_to_jack()) {
- // _session->timebase_callback (state, nframes, pos, new_position);
- }
-}
-*/
-
int
AudioEngine::sync_callback (TransportState state, framepos_t position)
{
if (_session) {
- return _session->jack_sync_callback (state, position);
+ return _session->backend_sync_callback (state, position);
}
return 0;
}
void
AudioEngine::freewheel_callback (bool onoff)
{
- if (onoff) {
- _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
- MIDI::Manager::instance()->mmc()->enable_send (false);
- } else {
- MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
- }
+ _freewheeling = onoff;
}
void
void
AudioEngine::halted_callback (const char* why)
{
+ if (_in_destructor) {
+ /* everything is under control */
+ return;
+ }
+
stop_metering_thread ();
-
- MIDI::JackMIDIPort::EngineHalted (); /* EMIT SIGNAL */
- Halted (why); /* EMIT SIGNAL */
+ _running = false;
+
+ Port::PortDrop (); /* EMIT SIGNAL */
+
+ if (!_started_for_latency) {
+ Halted (why); /* EMIT SIGNAL */
+ }
}
bool
AudioEngine::setup_required () const
{
+ /* If there is only a single backend and it claims to be configured
+ * already there is no setup to be done.
+ *
+ * Primarily for a case where there is only a JACK backend and
+ * JACK is already running.
+ */
+
if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
return false;
}
return true;
}
+
+MTDM*
+AudioEngine::mtdm()
+{
+ return _mtdm;
+}
+
+int
+AudioEngine::prepare_for_latency_measurement ()
+{
+ if (running()) {
+ _stopped_for_latency = true;
+ stop (true);
+ }
+
+ if (start (true)) {
+ _started_for_latency = true;
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+AudioEngine::start_latency_detection ()
+{
+ if (!running()) {
+ if (prepare_for_latency_measurement ()) {
+ return -1;
+ }
+ }
+
+ PortEngine& pe (port_engine());
+
+ delete _mtdm;
+ _mtdm = 0;
+
+ /* find the ports we will connect to */
+
+ PortEngine::PortHandle out = pe.get_port_by_name (_latency_output_name);
+ PortEngine::PortHandle in = pe.get_port_by_name (_latency_input_name);
+
+ if (!out || !in) {
+ stop (true);
+ return -1;
+ }
+
+ /* create the ports we will use to read/write data */
+
+ if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
+ stop (true);
+ return -1;
+ }
+ if (pe.connect (_latency_output_port, _latency_output_name)) {
+ pe.unregister_port (_latency_output_port);
+ stop (true);
+ return -1;
+ }
+
+ const string portname ("latency_in");
+ if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
+ pe.unregister_port (_latency_output_port);
+ stop (true);
+ return -1;
+ }
+ if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
+ pe.unregister_port (_latency_output_port);
+ stop (true);
+ return -1;
+ }
+
+ LatencyRange lr;
+ _latency_signal_latency = 0;
+ lr = pe.get_latency_range (in, false);
+ _latency_signal_latency = lr.max;
+ lr = pe.get_latency_range (out, true);
+ _latency_signal_latency += lr.max;
+
+ /* all created and connected, lets go */
+
+ _mtdm = new MTDM (sample_rate());
+ _measuring_latency = true;
+ _latency_flush_frames = samples_per_cycle();
+
+ return 0;
+}
+
+void
+AudioEngine::stop_latency_detection ()
+{
+ _measuring_latency = false;
+
+ if (_latency_output_port) {
+ port_engine().unregister_port (_latency_output_port);
+ _latency_output_port = 0;
+ }
+ if (_latency_input_port) {
+ port_engine().unregister_port (_latency_input_port);
+ _latency_input_port = 0;
+ }
+
+ stop (true);
+
+ if (_stopped_for_latency) {
+ start ();
+ }
+
+ _stopped_for_latency = false;
+ _started_for_latency = false;
+}
+
+void
+AudioEngine::set_latency_output_port (const string& name)
+{
+ _latency_output_name = name;
+}
+
+void
+AudioEngine::set_latency_input_port (const string& name)
+{
+ _latency_input_name = name;
+}
projects / ardour.git / blobdiff