#include <exception>
#include <stdexcept>
#include <sstream>
+#include <cmath>
#include <glibmm/timer.h>
#include <glibmm/pattern.h>
gint AudioEngine::m_meter_exit;
AudioEngine* AudioEngine::_instance = 0;
+#ifdef SILENCE_AFTER
+#define SILENCE_AFTER_SECONDS 600
+#endif
+
AudioEngine::AudioEngine ()
: session_remove_pending (false)
, session_removal_countdown (-1)
, _latency_flush_frames (0)
, _latency_signal_latency (0)
, _stopped_for_latency (false)
+ , _started_for_latency (false)
, _in_destructor (false)
+ , _hw_reset_event_thread(0)
+ , _hw_reset_request_count(0)
+ , _stop_hw_reset_processing(0)
+ , _hw_devicelist_update_thread(0)
+ , _hw_devicelist_update_count(0)
+ , _stop_hw_devicelist_processing(0)
+#ifdef SILENCE_AFTER_SECONDS
+ , _silence_countdown (0)
+ , _silence_hit_cnt (0)
+#endif
{
g_atomic_int_set (&m_meter_exit, 0);
+ reset_silence_countdown ();
+ start_hw_event_processing();
discover_backends ();
}
{
_in_destructor = true;
stop_metering_thread ();
+ stop_hw_event_processing();
drop_backend ();
+ for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
+ i->second->deinstantiate();
+ }
}
AudioEngine*
return _instance;
}
-void
-_thread_init_callback (void * /*arg*/)
-{
- /* make sure that anybody who needs to know about this thread
- knows about it.
- */
-
- pthread_set_name (X_("audioengine"));
-
- PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
- PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
-
- SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
-
- AsyncMIDIPort::set_process_thread (pthread_self());
-}
-
void
AudioEngine::split_cycle (pframes_t offset)
{
SampleRateChanged (nframes); /* EMIT SIGNAL */
+#ifdef SILENCE_AFTER_SECONDS
+ _silence_countdown = nframes * SILENCE_AFTER_SECONDS;
+#endif
+
return 0;
}
last_monitor_check = 0;
}
+ BufferSizeChanged (bufsiz); /* EMIT SIGNAL */
+
return 0;
}
/** Method called by our ::process_thread when there is work to be done.
* @param nframes Number of frames to process.
*/
+#ifdef __clang__
+__attribute__((annotate("realtime")))
+#endif
int
AudioEngine::process_callback (pframes_t nframes)
{
*/
if (_freewheeling && !Freewheel.empty()) {
- Freewheel (nframes);
+ Freewheel (nframes);
} else {
- if (_session) {
- _session->process (nframes);
- }
+ _session->process (nframes);
}
if (_freewheeling) {
+ PortManager::cycle_end (nframes);
return 0;
}
if (!_running) {
+ PortManager::cycle_end (nframes);
_processed_frames = next_processed_frames;
return 0;
}
last_monitor_check = next_processed_frames;
}
+#ifdef SILENCE_AFTER_SECONDS
+
+ bool was_silent = (_silence_countdown == 0);
+
+ if (_silence_countdown >= nframes) {
+ _silence_countdown -= nframes;
+ } else {
+ _silence_countdown = 0;
+ }
+
+ if (!was_silent && _silence_countdown == 0) {
+ _silence_hit_cnt++;
+ BecameSilent (); /* EMIT SIGNAL */
+ }
+
+ if (_silence_countdown == 0 || _session->silent()) {
+ PortManager::silence (nframes);
+ }
+
+#else
if (_session->silent()) {
PortManager::silence (nframes);
}
-
+#endif
+
if (session_remove_pending && session_removal_countdown) {
PortManager::fade_out (session_removal_gain, session_removal_gain_step, nframes);
return 0;
}
+void
+AudioEngine::reset_silence_countdown ()
+{
+#ifdef SILENCE_AFTER_SECONDS
+ double sr = 48000; /* default in case there is no backend */
+
+ sr = sample_rate();
+
+ _silence_countdown = max (60 * sr, /* 60 seconds */
+ sr * (SILENCE_AFTER_SECONDS / pow (2, _silence_hit_cnt)));
+
+#endif
+}
+
+void
+AudioEngine::launch_device_control_app()
+{
+ if (_state_lock.trylock () ) {
+ _backend->launch_control_app ();
+ _state_lock.unlock ();
+ }
+}
+
+
+void
+AudioEngine::request_backend_reset()
+{
+ Glib::Threads::Mutex::Lock guard (_reset_request_lock);
+ g_atomic_int_inc (&_hw_reset_request_count);
+ _hw_reset_condition.signal ();
+}
+
+int
+AudioEngine::backend_reset_requested()
+{
+ return g_atomic_int_get (&_hw_reset_request_count);
+}
+
+void
+AudioEngine::do_reset_backend()
+{
+ SessionEvent::create_per_thread_pool (X_("Backend reset processing thread"), 512);
+
+ Glib::Threads::Mutex::Lock guard (_reset_request_lock);
+
+ while (!_stop_hw_reset_processing) {
+
+ if (g_atomic_int_get (&_hw_reset_request_count) != 0 && _backend) {
+
+ _reset_request_lock.unlock();
+
+ Glib::Threads::RecMutex::Lock pl (_state_lock);
+ g_atomic_int_dec_and_test (&_hw_reset_request_count);
+
+ std::cout << "AudioEngine::RESET::Reset request processing. Requests left: " << _hw_reset_request_count << std::endl;
+ DeviceResetStarted(); // notify about device reset to be started
+
+ // backup the device name
+ std::string name = _backend->device_name ();
+
+ std::cout << "AudioEngine::RESET::Stoping engine..." << std::endl;
+ stop();
+
+ std::cout << "AudioEngine::RESET::Reseting device..." << std::endl;
+ if ( 0 == _backend->reset_device () ) {
+
+ std::cout << "AudioEngine::RESET::Starting engine..." << std::endl;
+ start ();
+
+ // inform about possible changes
+ BufferSizeChanged (_backend->buffer_size() );
+ } else {
+ DeviceError();
+ }
+
+ std::cout << "AudioEngine::RESET::Done." << std::endl;
+
+ _reset_request_lock.lock();
+
+ } else {
+
+ _hw_reset_condition.wait (_reset_request_lock);
+
+ }
+ }
+}
+void
+AudioEngine::request_device_list_update()
+{
+ Glib::Threads::Mutex::Lock guard (_devicelist_update_lock);
+ g_atomic_int_inc (&_hw_devicelist_update_count);
+ _hw_devicelist_update_condition.signal ();
+}
+
+
+void
+AudioEngine::do_devicelist_update()
+{
+ SessionEvent::create_per_thread_pool (X_("Device list update processing thread"), 512);
+
+ Glib::Threads::Mutex::Lock guard (_devicelist_update_lock);
+
+ while (!_stop_hw_devicelist_processing) {
+
+ if (_hw_devicelist_update_count) {
+
+ _devicelist_update_lock.unlock();
+
+ g_atomic_int_dec_and_test (&_hw_devicelist_update_count);
+ DeviceListChanged (); /* EMIT SIGNAL */
+
+ _devicelist_update_lock.lock();
+
+ } else {
+ _hw_devicelist_update_condition.wait (_devicelist_update_lock);
+ }
+ }
+}
+
+
+void
+AudioEngine::start_hw_event_processing()
+{
+ if (_hw_reset_event_thread == 0) {
+ g_atomic_int_set(&_hw_reset_request_count, 0);
+ g_atomic_int_set(&_stop_hw_reset_processing, 0);
+ _hw_reset_event_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::do_reset_backend, this));
+ }
+
+ if (_hw_devicelist_update_thread == 0) {
+ g_atomic_int_set(&_hw_devicelist_update_count, 0);
+ g_atomic_int_set(&_stop_hw_devicelist_processing, 0);
+ _hw_devicelist_update_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::do_devicelist_update, this));
+ }
+}
+
+
+void
+AudioEngine::stop_hw_event_processing()
+{
+ if (_hw_reset_event_thread) {
+ g_atomic_int_set(&_stop_hw_reset_processing, 1);
+ g_atomic_int_set(&_hw_reset_request_count, 0);
+ _hw_reset_condition.signal ();
+ _hw_reset_event_thread->join ();
+ _hw_reset_event_thread = 0;
+ }
+
+ if (_hw_devicelist_update_thread) {
+ g_atomic_int_set(&_stop_hw_devicelist_processing, 1);
+ g_atomic_int_set(&_hw_devicelist_update_count, 0);
+ _hw_devicelist_update_condition.signal ();
+ _hw_devicelist_update_thread->join ();
+ _hw_devicelist_update_thread = 0;
+ }
+
+}
+
+
void
AudioEngine::stop_metering_thread ()
}
+void
+AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_outputs)
+{
+ if (_session) {
+ _session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
+ }
+}
+
+
void
AudioEngine::died ()
{
stop_metering_thread ();
- _running = false;
+ _running = false;
}
int
#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_files_matching_pattern (backend_modules, backend_search_path (),
+ so_extension_pattern);
- find_matching_files_in_search_path (backend_search_path (),
- dll_extension_pattern, backend_modules);
+ find_files_matching_pattern (backend_modules, backend_search_path (),
+ dylib_extension_pattern);
+
+ find_files_matching_pattern (backend_modules, backend_search_path (),
+ dll_extension_pattern);
DEBUG_TRACE (DEBUG::AudioEngine, string_compose ("looking for backends in %1\n", backend_search_path().to_string()));
AudioBackendInfo*
AudioEngine::backend_discover (const string& path)
{
+#ifdef PLATFORM_WINDOWS
+ // do not show popup dialog (e.g. missing libjack.dll)
+ // win7+ should use SetThreadErrorMode()
+ SetErrorMode(SEM_FAILCRITICALERRORS);
+#endif
Glib::Module module (path);
+#ifdef PLATFORM_WINDOWS
+ SetErrorMode(0); // reset to system default
+#endif
AudioBackendInfo* info;
AudioBackendInfo* (*dfunc)(void);
void* func = 0;
error << Glib::Module::get_last_error() << endmsg;
return 0;
}
-
- module.make_resident ();
dfunc = (AudioBackendInfo* (*)(void))func;
info = dfunc();
+ if (!info->available()) {
+ return 0;
+ }
+
+ module.make_resident ();
return info;
}
AudioEngine::drop_backend ()
{
if (_backend) {
- _backend->stop ();
- _backend->drop_device();
+ stop(false);
+ _backend->drop_device ();
_backend.reset ();
_running = false;
}
if (_session->config.get_jack_time_master()) {
_backend->set_time_master (true);
}
+
}
start_metering_thread ();
return 0;
}
+ if (_session && _running) {
+ // it's not a halt, but should be handled the same way:
+ // disable record, stop transport and I/O processign but save the data.
+ _session->engine_halted ();
+ }
+
Glib::Threads::Mutex::Lock lm (_process_lock);
if (_backend->stop ()) {
return _backend->raw_buffer_size (t);
}
-pframes_t
+framepos_t
AudioEngine::sample_time ()
{
if (!_backend) {
return _backend->sample_time ();
}
-pframes_t
+framepos_t
AudioEngine::sample_time_at_cycle_start ()
{
if (!_backend) {
if (!_backend) {
return -1;
}
+
return _backend->set_sample_rate (sr);
}
pthread_set_name (X_("audioengine"));
+ SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
+
PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("AudioEngine"), 128);
- SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
-
AsyncMIDIPort::set_process_thread (pthread_self());
if (arg) {
return;
}
- stop_metering_thread ();
+ stop_metering_thread ();
_running = false;
Port::PortDrop (); /* EMIT SIGNAL */