, _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*
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 (_running) {
- stop_metering_thread ();
-
if (_session) {
session_remove_pending = true;
session_removal_countdown = 0;
Glib::PatternSpec so_extension_pattern("*backend.so");
Glib::PatternSpec dylib_extension_pattern("*backend.dylib");
+#if defined(PLATFORM_WINDOWS) && defined(DEBUGGABLE_BACKENDS)
+ #if defined(DEBUG) || defined(_DEBUG)
+ Glib::PatternSpec dll_extension_pattern("*backendD.dll");
+ #else
+ Glib::PatternSpec dll_extension_pattern("*backendRDC.dll");
+ #endif
+#else
+ Glib::PatternSpec dll_extension_pattern("*backend.dll");
+#endif
+
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;
}
}
}
+boost::shared_ptr<AudioBackend>
+AudioEngine::set_default_backend ()
+{
+ if (_backends.empty()) {
+ return boost::shared_ptr<AudioBackend>();
+ }
+
+ return set_backend (_backends.begin()->first, "", "");
+}
+
boost::shared_ptr<AudioBackend>
AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
{
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;
/* BACKEND PROXY WRAPPERS */
int
-AudioEngine::start ()
+AudioEngine::start (bool for_latency)
{
if (!_backend) {
return -1;
_processed_frames = 0;
last_monitor_check = 0;
- if (_backend->start()) {
+ if (_backend->start (for_latency)) {
return -1;
}
start_metering_thread ();
- Running(); /* EMIT SIGNAL */
+ if (!for_latency) {
+ Running(); /* EMIT SIGNAL */
+ }
return 0;
}
int
-AudioEngine::stop ()
+AudioEngine::stop (bool for_latency)
{
if (!_backend) {
return 0;
_measuring_latency = false;
_latency_output_port = 0;
_latency_input_port = 0;
+ _started_for_latency = false;
stop_metering_thread ();
Port::PortDrop ();
- Stopped (); /* EMIT SIGNAL */
-
- return 0;
-}
-int
-AudioEngine::pause ()
-{
- if (!_backend) {
- return 0;
+ if (!for_latency) {
+ Stopped (); /* EMIT SIGNAL */
}
- if (_backend->pause ()) {
- return -1;
- }
-
- _running = false;
-
- Stopped(); /* EMIT SIGNAL */
return 0;
}
}
float
-AudioEngine::get_cpu_load() const
+AudioEngine::get_dsp_load() const
{
if (!_backend) {
return 0.0;
}
- return _backend->cpu_load ();
+ return _backend->dsp_load ();
}
bool
return false;
}
- return _backend->connected();
+ return _backend->available();
}
void
}
int
-AudioEngine::create_process_thread (boost::function<void()> func, AudioBackendNativeThread* 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::wait_for_process_thread_exit (AudioBackendNativeThread thr)
+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->wait_for_process_thread_exit (thr);
+ return _backend->process_thread_count ();
}
int
void
AudioEngine::halted_callback (const char* why)
{
+ if (_in_destructor) {
+ /* everything is under control */
+ return;
+ }
+
stop_metering_thread ();
_running = false;
Port::PortDrop (); /* EMIT SIGNAL */
- Halted (why); /* 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 _mtdm;
}
-void
+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) {
- return;
+ stop (true);
+ return -1;
}
if (pe.connect (_latency_output_port, _latency_output_name)) {
- return;
+ 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);
- return;
+ stop (true);
+ return -1;
}
if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
pe.unregister_port (_latency_output_port);
- return;
+ stop (true);
+ return -1;
}
LatencyRange lr;
_latency_signal_latency = 0;
- lr = pe.get_latency_range (_latency_input_port, false);
+ lr = pe.get_latency_range (in, false);
_latency_signal_latency = lr.max;
- lr = pe.get_latency_range (_latency_output_port, true);
+ lr = pe.get_latency_range (out, true);
_latency_signal_latency += lr.max;
- cerr << "latency signal pathway = " << _latency_signal_latency << endl;
-
/* 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 ()
{
- port_engine().unregister_port (_latency_output_port);
- port_engine().unregister_port (_latency_input_port);
_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
projects / ardour.git / blobdiff