Add [hidden] option to list "Dummy" backend with optmized bundles
[ardour.git] / libs / ardour / audioengine.cc
index 16283d92320a145ae360dbc1a548f12790c86709..df015cf693f773b6e66ad50a267fc7cbad37cee9 100644 (file)
 #include "ardour/mtdm.h"
 #include "ardour/port.h"
 #include "ardour/process_thread.h"
+#include "ardour/rc_configuration.h"
 #include "ardour/session.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -63,6 +64,8 @@ using namespace PBD;
 
 AudioEngine* AudioEngine::_instance = 0;
 
+static gint audioengine_thread_cnt = 1;
+
 #ifdef SILENCE_AFTER
 #define SILENCE_AFTER_SECONDS 600
 #endif
@@ -87,6 +90,7 @@ AudioEngine::AudioEngine ()
        , _stopped_for_latency (false)
        , _started_for_latency (false)
        , _in_destructor (false)
+       , _last_backend_error_string(AudioBackend::get_error_string((AudioBackend::ErrorCode)-1))
     , _hw_reset_event_thread(0)
     , _hw_reset_request_count(0)
     , _stop_hw_reset_processing(0)
@@ -111,6 +115,7 @@ AudioEngine::~AudioEngine ()
        for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
                i->second->deinstantiate();
        }
+       delete _main_thread;
 }
 
 AudioEngine*
@@ -121,7 +126,7 @@ AudioEngine::create ()
        }
 
        _instance = new AudioEngine ();
-       
+
        return _instance;
 }
 
@@ -158,11 +163,11 @@ AudioEngine::sample_rate_change (pframes_t nframes)
 #ifdef SILENCE_AFTER_SECONDS
        _silence_countdown = nframes * SILENCE_AFTER_SECONDS;
 #endif
-       
+
        return 0;
 }
 
-int 
+int
 AudioEngine::buffer_size_change (pframes_t bufsiz)
 {
        if (_session) {
@@ -207,23 +212,43 @@ AudioEngine::process_callback (pframes_t nframes)
                }
                /* really only JACK requires this
                 * (other backends clear the output buffers
-                * before the process_callback. it may even be 
+                * before the process_callback. it may even be
                 * jack/alsa only). but better safe than sorry.
                 */
                PortManager::silence_outputs (nframes);
                return 0;
        }
 
+       /* The coreaudio-backend calls thread_init_callback() if
+        * the hardware changes or pthread_self() changes.
+        *
+        * However there are cases when neither holds true, yet
+        * the thread-pool changes: e.g. connect a headphone to
+        * a shared mic/headphone jack.
+        * It's probably related to, or caused by clocksource changes.
+        *
+        * For reasons yet unknown Glib::Threads::Private() can
+        * use a different thread-private in the same pthread
+        * (coreaudio render callback).
+        *
+        * Coreaudio must set something which influences
+        * pthread_key_t uniqness or reset the key using
+        * pthread_getspecific().
+        */
+       if (! SessionEvent::has_per_thread_pool ()) {
+               thread_init_callback (NULL);
+       }
+
        bool return_after_remove_check = false;
 
        if (_measuring_latency == MeasureAudio && _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);
 
@@ -262,7 +287,7 @@ AudioEngine::process_callback (pframes_t 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.
                 */
@@ -270,7 +295,7 @@ AudioEngine::process_callback (pframes_t nframes)
                PortManager::cycle_start (nframes);
                PortManager::silence (nframes);
                PortManager::cycle_end (nframes);
-               
+
                 if (_latency_flush_frames > nframes) {
                         _latency_flush_frames -= nframes;
                 } else {
@@ -294,12 +319,12 @@ AudioEngine::process_callback (pframes_t nframes)
                } else if (session_removal_countdown > 0) {
 
                        /* we'll be fading audio out.
-                          
-                          if this is the last time we do this as part 
+
+                          if this is the last time we do this as part
                           of session removal, do a MIDI panic now
                           to get MIDI stopped. This relies on the fact
                           that "immediate data" (aka "out of band data") from
-                          MIDI tracks is *appended* after any other data, 
+                          MIDI tracks is *appended* after any other data,
                           so that it emerges after any outbound note ons, etc.
                        */
 
@@ -362,7 +387,7 @@ AudioEngine::process_callback (pframes_t nframes)
        }
 
        if (last_monitor_check + monitor_check_interval < next_processed_frames) {
-               
+
                PortManager::check_monitoring ();
                last_monitor_check = next_processed_frames;
        }
@@ -370,7 +395,7 @@ AudioEngine::process_callback (pframes_t nframes)
 #ifdef SILENCE_AFTER_SECONDS
 
        bool was_silent = (_silence_countdown == 0);
-       
+
        if (_silence_countdown >= nframes) {
                _silence_countdown -= nframes;
        } else {
@@ -385,17 +410,17 @@ AudioEngine::process_callback (pframes_t nframes)
        if (_silence_countdown == 0 || _session->silent()) {
                PortManager::silence (nframes);
        }
-       
-#else  
+
+#else
        if (_session->silent()) {
-               PortManager::silence (nframes);
+               PortManager::silence (nframes, _session);
        }
 #endif
-       
+
        if (session_remove_pending && session_removal_countdown) {
 
                PortManager::fade_out (session_removal_gain, session_removal_gain_step, nframes);
-               
+
                if (session_removal_countdown > nframes) {
                        session_removal_countdown -= nframes;
                } else {
@@ -410,7 +435,7 @@ AudioEngine::process_callback (pframes_t nframes)
        _processed_frames = next_processed_frames;
 
        PT_TIMING_CHECK (2);
-       
+
        return 0;
 }
 
@@ -456,21 +481,21 @@ void
 AudioEngine::do_reset_backend()
 {
        SessionEvent::create_per_thread_pool (X_("Backend reset processing thread"), 1024);
-    
+
        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 ();
 
@@ -478,28 +503,28 @@ AudioEngine::do_reset_backend()
                        if ( ( 0 == stop () ) &&
                  ( 0 == _backend->reset_device () ) &&
                  ( 0 == start () ) ) {
-                               
+
                                std::cout << "AudioEngine::RESET::Engine started..." << std::endl;
-                               
+
                                // inform about possible changes
                                BufferSizeChanged (_backend->buffer_size() );
                 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();
-            
+
                } else {
-            
+
                        _hw_reset_condition.wait (_reset_request_lock);
-            
+
                }
        }
 }
@@ -516,22 +541,22 @@ 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();
-            
+
             Glib::Threads::RecMutex::Lock pl (_state_lock);
-            
+
             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);
         }
@@ -541,13 +566,13 @@ AudioEngine::do_devicelist_update()
 
 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);
@@ -566,7 +591,7 @@ AudioEngine::stop_hw_event_processing()
         _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);
@@ -574,7 +599,7 @@ AudioEngine::stop_hw_event_processing()
         _hw_devicelist_update_thread->join ();
         _hw_devicelist_update_thread = 0;
     }
-       
+
 }
 
 
@@ -613,7 +638,8 @@ AudioEngine::remove_session ()
 
                if (_session) {
                        session_remove_pending = true;
-                       session_removal_countdown = 0;
+                       /* signal the start of the fade out countdown */
+                       session_removal_countdown = -1;
                        session_removed.wait(_process_lock);
                }
 
@@ -632,7 +658,7 @@ AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_out
        if (_session) {
                _session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
        }
-#endif 
+#endif
 }
 
 
@@ -732,13 +758,13 @@ AudioEngine::backend_discover (const string& path)
                                        Glib::Module::get_last_error()) << endmsg;
                return 0;
        }
-       
+
        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;
        }
-       
+
        dfunc = (AudioBackendInfo* (*)(void))func;
        info = dfunc();
        if (!info->available()) {
@@ -746,16 +772,28 @@ AudioEngine::backend_discover (const string& path)
        }
 
        module.make_resident ();
-       
+
        return info;
 }
 
+static bool running_from_source_tree ()
+{
+       // dup ARDOUR_UI_UTILS::running_from_source_tree ()
+       gchar const *x = g_getenv ("ARDOUR_THEMES_PATH");
+       return x && (string (x).find ("gtk2_ardour") != string::npos);
+}
+
 vector<const AudioBackendInfo*>
 AudioEngine::available_backends() const
 {
        vector<const AudioBackendInfo*> r;
-       
+
        for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
+#ifdef NDEBUG
+               if (i->first == "None (Dummy)" && !running_from_source_tree () && Config->get_hide_dummy_backend ()) {
+                       continue;
+               }
+#endif
                r.push_back (i->second);
        }
 
@@ -767,7 +805,7 @@ AudioEngine::current_backend_name() const
 {
        if (_backend) {
                return _backend->name();
-       } 
+       }
        return string();
 }
 
@@ -776,6 +814,8 @@ AudioEngine::drop_backend ()
 {
        if (_backend) {
                _backend->stop ();
+               // Stopped is needed for Graph to explicitly terminate threads
+               Stopped (); /* EMIT SIGNAL */
                _backend->drop_device ();
                _backend.reset ();
                _running = false;
@@ -802,12 +842,12 @@ AudioEngine::set_backend (const std::string& name, const std::string& arg1, cons
        }
 
        drop_backend ();
-       
+
        try {
                if (b->second->instantiate (arg1, arg2)) {
                        throw failed_constructor ();
                }
-               
+
                _backend = b->second->factory (*this);
 
        } catch (exception& e) {
@@ -833,41 +873,67 @@ AudioEngine::start (bool for_latency)
 
        _processed_frames = 0;
        last_monitor_check = 0;
-       
-       if (_backend->start (for_latency)) {
+
+       int error_code = _backend->start (for_latency);
+
+       if (error_code != 0) {
+               _last_backend_error_string = AudioBackend::get_error_string((AudioBackend::ErrorCode) error_code);
                return -1;
        }
 
        _running = true;
-       
+
        if (_session) {
                _session->set_frame_rate (_backend->sample_rate());
-               
+
                if (_session->config.get_jack_time_master()) {
                        _backend->set_time_master (true);
                }
 
        }
-       
+
+       /* XXX MIDI ports may not actually be available here yet .. */
+
+       PortManager::fill_midi_port_info ();
+
        if (!for_latency) {
                Running(); /* EMIT SIGNAL */
        }
-       
+
        return 0;
 }
 
 int
 AudioEngine::stop (bool for_latency)
 {
+       bool stop_engine = true;
+
        if (!_backend) {
                return 0;
        }
 
-       if (_backend->stop ()) {
-               return -1;
+       Glib::Threads::Mutex::Lock pl (_process_lock, Glib::Threads::NOT_LOCK);
+
+       if (running()) {
+               pl.acquire ();
+       }
+
+       if (for_latency && _backend->can_change_systemic_latency_when_running()) {
+               stop_engine = false;
+       } else {
+               if (_backend->stop ()) {
+                       if (pl.locked ()) {
+                            pl.release ();
+                        }
+                       return -1;
+               }
        }
-       
-       if (_session && _running &&
+
+       if (pl.locked ()) {
+               pl.release ();
+       }
+
+       if (_session && _running && stop_engine &&
            (_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:
@@ -875,19 +941,23 @@ AudioEngine::stop (bool for_latency)
                _session->engine_halted ();
        }
 
-       _running = false;
+       if (stop_engine) {
+               _running = false;
+       }
        _processed_frames = 0;
        _measuring_latency = MeasureNone;
        _latency_output_port = 0;
        _latency_input_port = 0;
        _started_for_latency = false;
-       
-       Port::PortDrop ();
 
-       if (!for_latency) {
+       if (stop_engine) {
+               Port::PortDrop ();
+       }
+
+       if (!for_latency && stop_engine) {
                Stopped (); /* EMIT SIGNAL */
        }
-       
+
        return 0;
 }
 
@@ -904,16 +974,16 @@ AudioEngine::freewheel (bool start_stop)
 }
 
 float
-AudioEngine::get_dsp_load() const 
+AudioEngine::get_dsp_load() const
 {
-       if (!_backend) {
+       if (!_backend || !_running) {
                return 0.0;
        }
        return _backend->dsp_load ();
 }
 
 bool
-AudioEngine::is_realtime() const 
+AudioEngine::is_realtime() const
 {
        if (!_backend) {
                return false;
@@ -923,7 +993,7 @@ AudioEngine::is_realtime() const
 }
 
 bool
-AudioEngine::connected() const 
+AudioEngine::connected() const
 {
        if (!_backend) {
                return false;
@@ -1175,14 +1245,15 @@ AudioEngine::thread_init_callback (void* arg)
 
        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);
+       const int thread_num = g_atomic_int_add (&audioengine_thread_cnt, 1);
+       const string thread_name = string_compose (X_("AudioEngine %1"), thread_num);
 
+       SessionEvent::create_per_thread_pool (thread_name, 512);
+       PBD::notify_event_loops_about_thread_creation (pthread_self(), thread_name, 4096);
        AsyncMIDIPort::set_process_thread (pthread_self());
 
        if (arg) {
+               delete AudioEngine::instance()->_main_thread;
                /* the special thread created/managed by the backend */
                AudioEngine::instance()->_main_thread = new ProcessThread;
        }
@@ -1247,22 +1318,35 @@ AudioEngine::setup_required () const
                        return false;
                }
        }
-       
+
        return true;
 }
 
 int
 AudioEngine::prepare_for_latency_measurement ()
 {
+       if (!_backend) {
+               return -1;
+       }
+
+       if (_backend->can_change_systemic_latency_when_running()) {
+               if (start()) {
+                       return -1;
+               }
+               _backend->set_systemic_input_latency (0);
+               _backend->set_systemic_output_latency (0);
+               return 0;
+       }
+
        if (running()) {
                _stopped_for_latency = true;
                stop (true);
        }
 
        if (start (true)) {
-               _started_for_latency = true;
                return -1;
        }
+       _started_for_latency = true;
 
        return 0;
 }
@@ -1270,10 +1354,8 @@ AudioEngine::prepare_for_latency_measurement ()
 int
 AudioEngine::start_latency_detection (bool for_midi)
 {
-       if (!running()) {
-               if (prepare_for_latency_measurement ()) {
-                       return -1;
-               }
+       if (prepare_for_latency_measurement ()) {
+               return -1;
        }
 
        PortEngine& pe (port_engine());
@@ -1380,7 +1462,9 @@ AudioEngine::stop_latency_detection ()
                _latency_input_port = 0;
        }
 
-       stop (true);
+       if (!_backend->can_change_systemic_latency_when_running()) {
+               stop (true);
+       }
 
        if (_stopped_for_latency) {
                start ();
@@ -1401,3 +1485,18 @@ AudioEngine::set_latency_input_port (const string& name)
 {
        _latency_input_name = name;
 }
+
+void
+AudioEngine::add_pending_port_deletion (Port* p)
+{
+       if (_session) {
+               DEBUG_TRACE (DEBUG::Ports, string_compose ("adding %1 to pending port deletion list\n", p->name()));
+               if (_port_deletions_pending.write (&p, 1) != 1) {
+                       error << string_compose (_("programming error: port %1 could not be placed on the pending deletion queue\n"), p->name()) << endmsg;
+               }
+               _session->auto_connect_thread_wakeup ();
+       } else {
+               DEBUG_TRACE (DEBUG::Ports, string_compose ("Directly delete port %1\n", p->name()));
+               delete p;
+       }
+}