#include <exception>
#include <stdexcept>
#include <sstream>
+#include <cmath>
#include <glibmm/timer.h>
#include <glibmm/pattern.h>
using namespace ARDOUR;
using namespace PBD;
-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)
, _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);
- start_hw_event_processing();
+ reset_silence_countdown ();
+ start_hw_event_processing();
discover_backends ();
}
AudioEngine::~AudioEngine ()
{
_in_destructor = true;
- stop_metering_thread ();
stop_hw_event_processing();
drop_backend ();
for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
SampleRateChanged (nframes); /* EMIT SIGNAL */
+#ifdef SILENCE_AFTER_SECONDS
+ _silence_countdown = nframes * SILENCE_AFTER_SECONDS;
+#endif
+
return 0;
}
if (!tm.locked()) {
/* return having done nothing */
- _processed_frames = next_processed_frames;
+ if (_session) {
+ Xrun();
+ }
+ /* really only JACK requires this
+ * (other backends clear the output buffers
+ * before the process_callback. it may even be
+ * jack/alsa only). but better safe than sorry.
+ */
+ PortManager::silence_outputs (nframes);
return 0;
}
/* fade out over 1 second */
session_removal_countdown = sample_rate()/2;
- session_removal_gain = 1.0;
+ session_removal_gain = GAIN_COEFF_UNITY;
session_removal_gain_step = 1.0/session_removal_countdown;
} else if (session_removal_countdown > 0) {
}
if (_freewheeling) {
+ PortManager::cycle_end (nframes);
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.0, (double) _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()
_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);
+ SessionEvent::create_per_thread_pool (X_("Backend reset processing thread"), 1024);
- Glib::Threads::Mutex::Lock guard (_reset_request_lock);
+ Glib::Threads::Mutex::Lock guard (_reset_request_lock);
- while (!_stop_hw_reset_processing) {
+ while (!_stop_hw_reset_processing) {
- if (_hw_reset_request_count && _backend) {
-
+ 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" << std::endl;
-
- // backup the device name
- std::string name = _backend->device_name ();
+ 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
- std::cout << "AudioEngine::RESET::Stoping engine..." << std::endl;
- stop();
+ // backup the device name
+ std::string name = _backend->device_name ();
- std::cout << "AudioEngine::RESET::Reseting device..." << std::endl;
- if ( 0 == _backend->reset_device () ) {
+ std::cout << "AudioEngine::RESET::Reseting device..." << std::endl;
+ if ( ( 0 == stop () ) &&
+ ( 0 == _backend->reset_device () ) &&
+ ( 0 == start () ) ) {
+
+ std::cout << "AudioEngine::RESET::Engine started..." << std::endl;
- std::cout << "AudioEngine::RESET::Starting engine..." << std::endl;
- start ();
-
// inform about possible changes
BufferSizeChanged (_backend->buffer_size() );
- } else {
- DeviceError();
- }
+ DeviceResetFinished(); // notify about device reset finish
+
+ } else {
+ DeviceResetFinished(); // notify about device reset finish
+ // we've got an error
+ DeviceError();
+ }
+
std::cout << "AudioEngine::RESET::Done." << std::endl;
- _reset_request_lock.lock();
+ _reset_request_lock.lock();
- } else {
+ } else {
- _hw_reset_condition.wait (_reset_request_lock);
+ _hw_reset_condition.wait (_reset_request_lock);
- }
- }
+ }
+ }
}
-
-
void
AudioEngine::request_device_list_update()
{
_devicelist_update_lock.unlock();
+ Glib::Threads::RecMutex::Lock pl (_state_lock);
+
g_atomic_int_dec_and_test (&_hw_devicelist_update_count);
DeviceListChanged (); /* EMIT SIGNAL */
}
-
-void
-AudioEngine::stop_metering_thread ()
-{
- if (m_meter_thread) {
- g_atomic_int_set (&m_meter_exit, 1);
- m_meter_thread->join ();
- m_meter_thread = 0;
- }
-}
-
-void
-AudioEngine::start_metering_thread ()
-{
- if (m_meter_thread == 0) {
- g_atomic_int_set (&m_meter_exit, 0);
- m_meter_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::meter_thread, this));
- }
-}
-
-void
-AudioEngine::meter_thread ()
-{
- pthread_set_name (X_("meter"));
-
- while (true) {
- Glib::usleep (10000); /* 1/100th sec interval */
- if (g_atomic_int_get(&m_meter_exit)) {
- break;
- }
- Metering::Meter ();
- }
-}
-
void
AudioEngine::set_session (Session *s)
{
void
AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_outputs)
{
- if (_session) {
- _session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
- }
+#ifdef USE_TRACKS_CODE_FEATURES
+ if (_session) {
+ _session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
+ }
+#endif
}
void
AudioEngine::died ()
{
- /* called from a signal handler for SIGPIPE */
-
- stop_metering_thread ();
-
- _running = false;
+ /* called from a signal handler for SIGPIPE */
+ _running = false;
}
int
AudioEngine::drop_backend ()
{
if (_backend) {
- stop(false);
+ _backend->stop ();
_backend->drop_device ();
_backend.reset ();
_running = false;
}
- start_metering_thread ();
-
if (!for_latency) {
Running(); /* EMIT SIGNAL */
}
return 0;
}
- if (_session && _running) {
+ if (_backend->stop ()) {
+ return -1;
+ }
+
+ if (_session && _running &&
+ (_session->state_of_the_state() & Session::Loading) == 0 &&
+ (_session->state_of_the_state() & Session::Deletion) == 0) {
// 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 -1;
- }
-
_running = false;
_processed_frames = 0;
_measuring_latency = MeasureNone;
_latency_output_port = 0;
_latency_input_port = 0;
_started_for_latency = false;
- stop_metering_thread ();
Port::PortDrop ();
if (!_backend) {
return -1;
}
+
return _backend->set_sample_rate (sr);
}
return _backend->set_systemic_output_latency (ol);
}
+bool
+AudioEngine::thread_initialised_for_audio_processing ()
+{
+ return SessionEvent::has_per_thread_pool () && AsyncMIDIPort::is_process_thread();
+}
+
/* END OF BACKEND PROXY API */
void
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 ();
_running = false;
Port::PortDrop (); /* EMIT SIGNAL */