libs/ardour/audioengine.cc

   1 /*
   2     Copyright (C) 2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <unistd.h>
  21 #include <cerrno>
  22 #include <vector>
  23 #include <exception>
  24 #include <stdexcept>
  25 #include <sstream>
  26 #include <cmath>
  27
  28 #include <glibmm/timer.h>
  29 #include <glibmm/pattern.h>
  30 #include <glibmm/module.h>
  31
  32 #include "pbd/epa.h"
  33 #include "pbd/file_utils.h"
  34 #include "pbd/pthread_utils.h"
  35 #include "pbd/stacktrace.h"
  36 #include "pbd/unknown_type.h"
  37
  38 #include "midi++/port.h"
  39 #include "midi++/mmc.h"
  40
  41 #include "ardour/async_midi_port.h"
  42 #include "ardour/audio_port.h"
  43 #include "ardour/audio_backend.h"
  44 #include "ardour/audioengine.h"
  45 #include "ardour/search_paths.h"
  46 #include "ardour/buffer.h"
  47 #include "ardour/cycle_timer.h"
  48 #include "ardour/internal_send.h"
  49 #include "ardour/meter.h"
  50 #include "ardour/midi_port.h"
  51 #include "ardour/midiport_manager.h"
  52 #include "ardour/mididm.h"
  53 #include "ardour/mtdm.h"
  54 #include "ardour/port.h"
  55 #include "ardour/process_thread.h"
  56 #include "ardour/session.h"
  57
  58 #include "pbd/i18n.h"
  59
  60 using namespace std;
  61 using namespace ARDOUR;
  62 using namespace PBD;
  63
  64 AudioEngine* AudioEngine::_instance = 0;
  65
  66 static gint audioengine_thread_cnt = 1;
  67
  68 #ifdef SILENCE_AFTER
  69 #define SILENCE_AFTER_SECONDS 600
  70 #endif
  71
  72 AudioEngine::AudioEngine ()
  73         : session_remove_pending (false)
  74         , session_removal_countdown (-1)
  75         , _running (false)
  76         , _freewheeling (false)
  77         , monitor_check_interval (INT32_MAX)
  78         , last_monitor_check (0)
  79         , _processed_frames (0)
  80         , m_meter_thread (0)
  81         , _main_thread (0)
  82         , _mtdm (0)
  83         , _mididm (0)
  84         , _measuring_latency (MeasureNone)
  85         , _latency_input_port (0)
  86         , _latency_output_port (0)
  87         , _latency_flush_frames (0)
  88         , _latency_signal_latency (0)
  89         , _stopped_for_latency (false)
  90         , _started_for_latency (false)
  91         , _in_destructor (false)
  92         , _last_backend_error_string(AudioBackend::get_error_string((AudioBackend::ErrorCode)-1))
  93     , _hw_reset_event_thread(0)
  94     , _hw_reset_request_count(0)
  95     , _stop_hw_reset_processing(0)
  96     , _hw_devicelist_update_thread(0)
  97     , _hw_devicelist_update_count(0)
  98     , _stop_hw_devicelist_processing(0)
  99 #ifdef SILENCE_AFTER_SECONDS
 100         , _silence_countdown (0)
 101         , _silence_hit_cnt (0)
 102 #endif
 103 {
 104         reset_silence_countdown ();
 105         start_hw_event_processing();
 106         discover_backends ();
 107 }
 108
 109 AudioEngine::~AudioEngine ()
 110 {
 111         _in_destructor = true;
 112         stop_hw_event_processing();
 113         drop_backend ();
 114         for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
 115                 i->second->deinstantiate();
 116         }
 117         delete _main_thread;
 118 }
 119
 120 AudioEngine*
 121 AudioEngine::create ()
 122 {
 123         if (_instance) {
 124                 return _instance;
 125         }
 126
 127         _instance = new AudioEngine ();
 128
 129         return _instance;
 130 }
 131
 132 void
 133 AudioEngine::split_cycle (pframes_t offset)
 134 {
 135         /* caller must hold process lock */
 136
 137         Port::increment_global_port_buffer_offset (offset);
 138
 139         /* tell all Ports that we're going to start a new (split) cycle */
 140
 141         boost::shared_ptr<Ports> p = ports.reader();
 142
 143         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 144                 i->second->cycle_split ();
 145         }
 146 }
 147
 148 int
 149 AudioEngine::sample_rate_change (pframes_t nframes)
 150 {
 151         /* check for monitor input change every 1/10th of second */
 152
 153         monitor_check_interval = nframes / 10;
 154         last_monitor_check = 0;
 155
 156         if (_session) {
 157                 _session->set_frame_rate (nframes);
 158         }
 159
 160         SampleRateChanged (nframes); /* EMIT SIGNAL */
 161
 162 #ifdef SILENCE_AFTER_SECONDS
 163         _silence_countdown = nframes * SILENCE_AFTER_SECONDS;
 164 #endif
 165
 166         return 0;
 167 }
 168
 169 int
 170 AudioEngine::buffer_size_change (pframes_t bufsiz)
 171 {
 172         if (_session) {
 173                 _session->set_block_size (bufsiz);
 174                 last_monitor_check = 0;
 175         }
 176
 177         BufferSizeChanged (bufsiz); /* EMIT SIGNAL */
 178
 179         return 0;
 180 }
 181
 182 /** Method called by our ::process_thread when there is work to be done.
 183  *  @param nframes Number of frames to process.
 184  */
 185 #ifdef __clang__
 186 __attribute__((annotate("realtime")))
 187 #endif
 188 int
 189 AudioEngine::process_callback (pframes_t nframes)
 190 {
 191         Glib::Threads::Mutex::Lock tm (_process_lock, Glib::Threads::TRY_LOCK);
 192
 193         PT_TIMING_REF;
 194         PT_TIMING_CHECK (1);
 195
 196         /// The number of frames that will have been processed when we've finished
 197         pframes_t next_processed_frames;
 198
 199         /* handle wrap around of total frames counter */
 200
 201         if (max_framepos - _processed_frames < nframes) {
 202                 next_processed_frames = nframes - (max_framepos - _processed_frames);
 203         } else {
 204                 next_processed_frames = _processed_frames + nframes;
 205         }
 206
 207         if (!tm.locked()) {
 208                 /* return having done nothing */
 209                 if (_session) {
 210                         Xrun();
 211                 }
 212                 /* really only JACK requires this
 213                  * (other backends clear the output buffers
 214                  * before the process_callback. it may even be
 215                  * jack/alsa only). but better safe than sorry.
 216                  */
 217                 PortManager::silence_outputs (nframes);
 218                 return 0;
 219         }
 220
 221         /* The coreaudio-backend calls thread_init_callback() if
 222          * the hardware changes or pthread_self() changes.
 223          *
 224          * However there are cases when neither holds true, yet
 225          * the thread-pool changes: e.g. connect a headphone to
 226          * a shared mic/headphone jack.
 227          * It's probably related to, or caused by clocksource changes.
 228          *
 229          * For reasons yet unknown Glib::Threads::Private() can
 230          * use a different thread-private in the same pthread
 231          * (coreaudio render callback).
 232          *
 233          * Coreaudio must set something which influences
 234          * pthread_key_t uniqness or reset the key using
 235          * pthread_getspecific().
 236          */
 237         if (! SessionEvent::has_per_thread_pool ()) {
 238                 thread_init_callback (NULL);
 239         }
 240
 241         bool return_after_remove_check = false;
 242
 243         if (_measuring_latency == MeasureAudio && _mtdm) {
 244                 /* run a normal cycle from the perspective of the PortManager
 245                    so that we get silence on all registered ports.
 246
 247                    we overwrite the silence on the two ports used for latency
 248                    measurement.
 249                 */
 250
 251                 PortManager::cycle_start (nframes);
 252                 PortManager::silence (nframes);
 253
 254                 if (_latency_input_port && _latency_output_port) {
 255                         PortEngine& pe (port_engine());
 256
 257                         Sample* in = (Sample*) pe.get_buffer (_latency_input_port, nframes);
 258                         Sample* out = (Sample*) pe.get_buffer (_latency_output_port, nframes);
 259
 260                         _mtdm->process (nframes, in, out);
 261                 }
 262
 263                 PortManager::cycle_end (nframes);
 264                 return_after_remove_check = true;
 265
 266         } else if (_measuring_latency == MeasureMIDI && _mididm) {
 267                 /* run a normal cycle from the perspective of the PortManager
 268                    so that we get silence on all registered ports.
 269
 270                    we overwrite the silence on the two ports used for latency
 271                    measurement.
 272                 */
 273
 274                 PortManager::cycle_start (nframes);
 275                 PortManager::silence (nframes);
 276
 277                 if (_latency_input_port && _latency_output_port) {
 278                         PortEngine& pe (port_engine());
 279
 280                         _mididm->process (nframes, pe,
 281                                         pe.get_buffer (_latency_input_port, nframes),
 282                                         pe.get_buffer (_latency_output_port, nframes));
 283                 }
 284
 285                 PortManager::cycle_end (nframes);
 286                 return_after_remove_check = true;
 287
 288         } else if (_latency_flush_frames) {
 289
 290                 /* wait for the appropriate duration for the MTDM signal to
 291                  * drain from the ports before we revert to normal behaviour.
 292                  */
 293
 294                 PortManager::cycle_start (nframes);
 295                 PortManager::silence (nframes);
 296                 PortManager::cycle_end (nframes);
 297
 298                 if (_latency_flush_frames > nframes) {
 299                         _latency_flush_frames -= nframes;
 300                 } else {
 301                         _latency_flush_frames = 0;
 302                 }
 303
 304                 return_after_remove_check = true;
 305         }
 306
 307         if (session_remove_pending) {
 308
 309                 /* perform the actual session removal */
 310
 311                 if (session_removal_countdown < 0) {
 312
 313                         /* fade out over 1 second */
 314                         session_removal_countdown = sample_rate()/2;
 315                         session_removal_gain = GAIN_COEFF_UNITY;
 316                         session_removal_gain_step = 1.0/session_removal_countdown;
 317
 318                 } else if (session_removal_countdown > 0) {
 319
 320                         /* we'll be fading audio out.
 321
 322                            if this is the last time we do this as part
 323                            of session removal, do a MIDI panic now
 324                            to get MIDI stopped. This relies on the fact
 325                            that "immediate data" (aka "out of band data") from
 326                            MIDI tracks is *appended* after any other data,
 327                            so that it emerges after any outbound note ons, etc.
 328                         */
 329
 330                         if (session_removal_countdown <= nframes) {
 331                                 _session->midi_panic ();
 332                         }
 333
 334                 } else {
 335                         /* fade out done */
 336                         _session = 0;
 337                         session_removal_countdown = -1; // reset to "not in progress"
 338                         session_remove_pending = false;
 339                         session_removed.signal(); // wakes up thread that initiated session removal
 340                 }
 341         }
 342
 343         if (return_after_remove_check) {
 344                 return 0;
 345         }
 346
 347         if (_session == 0) {
 348
 349                 if (!_freewheeling) {
 350                         PortManager::cycle_start (nframes);
 351                         PortManager::cycle_end (nframes);
 352                 }
 353
 354                 _processed_frames = next_processed_frames;
 355
 356                 return 0;
 357         }
 358
 359         /* tell all relevant objects that we're starting a new cycle */
 360
 361         InternalSend::CycleStart (nframes);
 362
 363         /* tell all Ports that we're starting a new cycle */
 364
 365         PortManager::cycle_start (nframes);
 366
 367         /* test if we are freewheeling and there are freewheel signals connected.
 368            ardour should act normally even when freewheeling unless /it/ is
 369            exporting (which is what Freewheel.empty() tests for).
 370         */
 371
 372         if (_freewheeling && !Freewheel.empty()) {
 373                 Freewheel (nframes);
 374         } else {
 375                 _session->process (nframes);
 376         }
 377
 378         if (_freewheeling) {
 379                 PortManager::cycle_end (nframes);
 380                 return 0;
 381         }
 382
 383         if (!_running) {
 384                 _processed_frames = next_processed_frames;
 385                 return 0;
 386         }
 387
 388         if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 389
 390                 PortManager::check_monitoring ();
 391                 last_monitor_check = next_processed_frames;
 392         }
 393
 394 #ifdef SILENCE_AFTER_SECONDS
 395
 396         bool was_silent = (_silence_countdown == 0);
 397
 398         if (_silence_countdown >= nframes) {
 399                 _silence_countdown -= nframes;
 400         } else {
 401                 _silence_countdown = 0;
 402         }
 403
 404         if (!was_silent && _silence_countdown == 0) {
 405                 _silence_hit_cnt++;
 406                 BecameSilent (); /* EMIT SIGNAL */
 407         }
 408
 409         if (_silence_countdown == 0 || _session->silent()) {
 410                 PortManager::silence (nframes);
 411         }
 412
 413 #else
 414         if (_session->silent()) {
 415                 PortManager::silence (nframes, _session);
 416         }
 417 #endif
 418
 419         if (session_remove_pending && session_removal_countdown) {
 420
 421                 PortManager::fade_out (session_removal_gain, session_removal_gain_step, nframes);
 422
 423                 if (session_removal_countdown > nframes) {
 424                         session_removal_countdown -= nframes;
 425                 } else {
 426                         session_removal_countdown = 0;
 427                 }
 428
 429                 session_removal_gain -= (nframes * session_removal_gain_step);
 430         }
 431
 432         PortManager::cycle_end (nframes);
 433
 434         _processed_frames = next_processed_frames;
 435
 436         PT_TIMING_CHECK (2);
 437
 438         return 0;
 439 }
 440
 441 void
 442 AudioEngine::reset_silence_countdown ()
 443 {
 444 #ifdef SILENCE_AFTER_SECONDS
 445         double sr = 48000; /* default in case there is no backend */
 446
 447         sr = sample_rate();
 448
 449         _silence_countdown = max (60 * sr, /* 60 seconds */
 450                                   sr * (SILENCE_AFTER_SECONDS / ::pow (2.0, (double) _silence_hit_cnt)));
 451
 452 #endif
 453 }
 454
 455 void
 456 AudioEngine::launch_device_control_app()
 457 {
 458         if (_state_lock.trylock () ) {
 459                 _backend->launch_control_app ();
 460                 _state_lock.unlock ();
 461         }
 462 }
 463
 464
 465 void
 466 AudioEngine::request_backend_reset()
 467 {
 468     Glib::Threads::Mutex::Lock guard (_reset_request_lock);
 469     g_atomic_int_inc (&_hw_reset_request_count);
 470     _hw_reset_condition.signal ();
 471 }
 472
 473 int
 474 AudioEngine::backend_reset_requested()
 475 {
 476         return g_atomic_int_get (&_hw_reset_request_count);
 477 }
 478
 479 void
 480 AudioEngine::do_reset_backend()
 481 {
 482         SessionEvent::create_per_thread_pool (X_("Backend reset processing thread"), 1024);
 483
 484         Glib::Threads::Mutex::Lock guard (_reset_request_lock);
 485
 486         while (!_stop_hw_reset_processing) {
 487
 488                 if (g_atomic_int_get (&_hw_reset_request_count) != 0 && _backend) {
 489
 490                         _reset_request_lock.unlock();
 491
 492                         Glib::Threads::RecMutex::Lock pl (_state_lock);
 493                         g_atomic_int_dec_and_test (&_hw_reset_request_count);
 494
 495             std::cout << "AudioEngine::RESET::Reset request processing. Requests left: " << _hw_reset_request_count << std::endl;
 496                         DeviceResetStarted(); // notify about device reset to be started
 497
 498                         // backup the device name
 499                         std::string name = _backend->device_name ();
 500
 501             std::cout << "AudioEngine::RESET::Reseting device..." << std::endl;
 502                         if ( ( 0 == stop () ) &&
 503                  ( 0 == _backend->reset_device () ) &&
 504                  ( 0 == start () ) ) {
 505
 506                                 std::cout << "AudioEngine::RESET::Engine started..." << std::endl;
 507
 508                                 // inform about possible changes
 509                                 BufferSizeChanged (_backend->buffer_size() );
 510                 DeviceResetFinished(); // notify about device reset finish
 511
 512             } else {
 513
 514                 DeviceResetFinished(); // notify about device reset finish
 515                                 // we've got an error
 516                 DeviceError();
 517                         }
 518
 519                         std::cout << "AudioEngine::RESET::Done." << std::endl;
 520
 521                         _reset_request_lock.lock();
 522
 523                 } else {
 524
 525                         _hw_reset_condition.wait (_reset_request_lock);
 526
 527                 }
 528         }
 529 }
 530 void
 531 AudioEngine::request_device_list_update()
 532 {
 533     Glib::Threads::Mutex::Lock guard (_devicelist_update_lock);
 534     g_atomic_int_inc (&_hw_devicelist_update_count);
 535     _hw_devicelist_update_condition.signal ();
 536 }
 537
 538
 539 void
 540 AudioEngine::do_devicelist_update()
 541 {
 542     SessionEvent::create_per_thread_pool (X_("Device list update processing thread"), 512);
 543
 544     Glib::Threads::Mutex::Lock guard (_devicelist_update_lock);
 545
 546     while (!_stop_hw_devicelist_processing) {
 547
 548         if (_hw_devicelist_update_count) {
 549
 550             _devicelist_update_lock.unlock();
 551
 552             Glib::Threads::RecMutex::Lock pl (_state_lock);
 553
 554             g_atomic_int_dec_and_test (&_hw_devicelist_update_count);
 555             DeviceListChanged (); /* EMIT SIGNAL */
 556
 557             _devicelist_update_lock.lock();
 558
 559         } else {
 560             _hw_devicelist_update_condition.wait (_devicelist_update_lock);
 561         }
 562     }
 563 }
 564
 565
 566 void
 567 AudioEngine::start_hw_event_processing()
 568 {
 569     if (_hw_reset_event_thread == 0) {
 570         g_atomic_int_set(&_hw_reset_request_count, 0);
 571         g_atomic_int_set(&_stop_hw_reset_processing, 0);
 572         _hw_reset_event_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::do_reset_backend, this));
 573     }
 574
 575     if (_hw_devicelist_update_thread == 0) {
 576         g_atomic_int_set(&_hw_devicelist_update_count, 0);
 577         g_atomic_int_set(&_stop_hw_devicelist_processing, 0);
 578         _hw_devicelist_update_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::do_devicelist_update, this));
 579     }
 580 }
 581
 582
 583 void
 584 AudioEngine::stop_hw_event_processing()
 585 {
 586     if (_hw_reset_event_thread) {
 587         g_atomic_int_set(&_stop_hw_reset_processing, 1);
 588         g_atomic_int_set(&_hw_reset_request_count, 0);
 589         _hw_reset_condition.signal ();
 590         _hw_reset_event_thread->join ();
 591         _hw_reset_event_thread = 0;
 592     }
 593
 594     if (_hw_devicelist_update_thread) {
 595         g_atomic_int_set(&_stop_hw_devicelist_processing, 1);
 596         g_atomic_int_set(&_hw_devicelist_update_count, 0);
 597         _hw_devicelist_update_condition.signal ();
 598         _hw_devicelist_update_thread->join ();
 599         _hw_devicelist_update_thread = 0;
 600     }
 601
 602 }
 603
 604
 605 void
 606 AudioEngine::set_session (Session *s)
 607 {
 608         Glib::Threads::Mutex::Lock pl (_process_lock);
 609
 610         SessionHandlePtr::set_session (s);
 611
 612         if (_session) {
 613
 614                 pframes_t blocksize = samples_per_cycle ();
 615
 616                 PortManager::cycle_start (blocksize);
 617
 618                 _session->process (blocksize);
 619                 _session->process (blocksize);
 620                 _session->process (blocksize);
 621                 _session->process (blocksize);
 622                 _session->process (blocksize);
 623                 _session->process (blocksize);
 624                 _session->process (blocksize);
 625                 _session->process (blocksize);
 626
 627                 PortManager::cycle_end (blocksize);
 628         }
 629 }
 630
 631 void
 632 AudioEngine::remove_session ()
 633 {
 634         Glib::Threads::Mutex::Lock lm (_process_lock);
 635
 636         if (_running) {
 637
 638                 if (_session) {
 639                         session_remove_pending = true;
 640                         /* signal the start of the fade out countdown */
 641                         session_removal_countdown = -1;
 642                         session_removed.wait(_process_lock);
 643                 }
 644
 645         } else {
 646                 SessionHandlePtr::set_session (0);
 647         }
 648
 649         remove_all_ports ();
 650 }
 651
 652
 653 void
 654 AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_outputs)
 655 {
 656 #ifdef USE_TRACKS_CODE_FEATURES
 657         if (_session) {
 658                 _session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
 659         }
 660 #endif
 661 }
 662
 663
 664 void
 665 AudioEngine::died ()
 666 {
 667         /* called from a signal handler for SIGPIPE */
 668         _running = false;
 669 }
 670
 671 int
 672 AudioEngine::reset_timebase ()
 673 {
 674         if (_session) {
 675                 if (_session->config.get_jack_time_master()) {
 676                         _backend->set_time_master (true);
 677                 } else {
 678                         _backend->set_time_master (false);
 679                 }
 680         }
 681         return 0;
 682 }
 683
 684
 685 void
 686 AudioEngine::destroy ()
 687 {
 688         delete _instance;
 689         _instance = 0;
 690 }
 691
 692 int
 693 AudioEngine::discover_backends ()
 694 {
 695         vector<std::string> backend_modules;
 696
 697         _backends.clear ();
 698
 699         Glib::PatternSpec so_extension_pattern("*backend.so");
 700         Glib::PatternSpec dylib_extension_pattern("*backend.dylib");
 701
 702 #if defined(PLATFORM_WINDOWS) && defined(DEBUGGABLE_BACKENDS)
 703         #if defined(DEBUG) || defined(_DEBUG)
 704                 Glib::PatternSpec dll_extension_pattern("*backendD.dll");
 705         #else
 706                 Glib::PatternSpec dll_extension_pattern("*backendRDC.dll");
 707         #endif
 708 #else
 709         Glib::PatternSpec dll_extension_pattern("*backend.dll");
 710 #endif
 711
 712         find_files_matching_pattern (backend_modules, backend_search_path (),
 713                                      so_extension_pattern);
 714
 715         find_files_matching_pattern (backend_modules, backend_search_path (),
 716                                      dylib_extension_pattern);
 717
 718         find_files_matching_pattern (backend_modules, backend_search_path (),
 719                                      dll_extension_pattern);
 720
 721         DEBUG_TRACE (DEBUG::AudioEngine, string_compose ("looking for backends in %1\n", backend_search_path().to_string()));
 722
 723         for (vector<std::string>::iterator i = backend_modules.begin(); i != backend_modules.end(); ++i) {
 724
 725                 AudioBackendInfo* info;
 726
 727                 DEBUG_TRACE (DEBUG::AudioEngine, string_compose ("Checking possible backend in %1\n", *i));
 728
 729                 if ((info = backend_discover (*i)) != 0) {
 730                         _backends.insert (make_pair (info->name, info));
 731                 }
 732         }
 733
 734         DEBUG_TRACE (DEBUG::AudioEngine, string_compose ("Found %1 backends\n", _backends.size()));
 735
 736         return _backends.size();
 737 }
 738
 739 AudioBackendInfo*
 740 AudioEngine::backend_discover (const string& path)
 741 {
 742 #ifdef PLATFORM_WINDOWS
 743         // do not show popup dialog (e.g. missing libjack.dll)
 744         // win7+ should use SetThreadErrorMode()
 745         SetErrorMode(SEM_FAILCRITICALERRORS);
 746 #endif
 747         Glib::Module module (path);
 748 #ifdef PLATFORM_WINDOWS
 749         SetErrorMode(0); // reset to system default
 750 #endif
 751         AudioBackendInfo* info;
 752         AudioBackendInfo* (*dfunc)(void);
 753         void* func = 0;
 754
 755         if (!module) {
 756                 error << string_compose(_("AudioEngine: cannot load module \"%1\" (%2)"), path,
 757                                         Glib::Module::get_last_error()) << endmsg;
 758                 return 0;
 759         }
 760
 761         if (!module.get_symbol ("descriptor", func)) {
 762                 error << string_compose(_("AudioEngine: backend at \"%1\" has no descriptor function."), path) << endmsg;
 763                 error << Glib::Module::get_last_error() << endmsg;
 764                 return 0;
 765         }
 766
 767         dfunc = (AudioBackendInfo* (*)(void))func;
 768         info = dfunc();
 769         if (!info->available()) {
 770                 return 0;
 771         }
 772
 773         module.make_resident ();
 774
 775         return info;
 776 }
 777
 778 static bool running_from_source_tree ()
 779 {
 780         // dup ARDOUR_UI_UTILS::running_from_source_tree ()
 781         gchar const *x = g_getenv ("ARDOUR_THEMES_PATH");
 782         return x && (string (x).find ("gtk2_ardour") != string::npos);
 783 }
 784
 785 vector<const AudioBackendInfo*>
 786 AudioEngine::available_backends() const
 787 {
 788         vector<const AudioBackendInfo*> r;
 789
 790         for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
 791 #ifdef NDEBUG
 792                 if (i->first == "None (Dummy)" && !running_from_source_tree ()) {
 793                         continue;
 794                 }
 795 #endif
 796                 r.push_back (i->second);
 797         }
 798
 799         return r;
 800 }
 801
 802 string
 803 AudioEngine::current_backend_name() const
 804 {
 805         if (_backend) {
 806                 return _backend->name();
 807         }
 808         return string();
 809 }
 810
 811 void
 812 AudioEngine::drop_backend ()
 813 {
 814         if (_backend) {
 815                 _backend->stop ();
 816                 // Stopped is needed for Graph to explicitly terminate threads
 817                 Stopped (); /* EMIT SIGNAL */
 818                 _backend->drop_device ();
 819                 _backend.reset ();
 820                 _running = false;
 821         }
 822 }
 823
 824 boost::shared_ptr<AudioBackend>
 825 AudioEngine::set_default_backend ()
 826 {
 827         if (_backends.empty()) {
 828                 return boost::shared_ptr<AudioBackend>();
 829         }
 830
 831         return set_backend (_backends.begin()->first, "", "");
 832 }
 833
 834 boost::shared_ptr<AudioBackend>
 835 AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
 836 {
 837         BackendMap::iterator b = _backends.find (name);
 838
 839         if (b == _backends.end()) {
 840                 return boost::shared_ptr<AudioBackend>();
 841         }
 842
 843         drop_backend ();
 844
 845         try {
 846                 if (b->second->instantiate (arg1, arg2)) {
 847                         throw failed_constructor ();
 848                 }
 849
 850                 _backend = b->second->factory (*this);
 851
 852         } catch (exception& e) {
 853                 error << string_compose (_("Could not create backend for %1: %2"), name, e.what()) << endmsg;
 854                 return boost::shared_ptr<AudioBackend>();
 855         }
 856
 857         return _backend;
 858 }
 859
 860 /* BACKEND PROXY WRAPPERS */
 861
 862 int
 863 AudioEngine::start (bool for_latency)
 864 {
 865         if (!_backend) {
 866                 return -1;
 867         }
 868
 869         if (_running) {
 870                 return 0;
 871         }
 872
 873         _processed_frames = 0;
 874         last_monitor_check = 0;
 875
 876         int error_code = _backend->start (for_latency);
 877
 878         if (error_code != 0) {
 879                 _last_backend_error_string = AudioBackend::get_error_string((AudioBackend::ErrorCode) error_code);
 880                 return -1;
 881         }
 882
 883         _running = true;
 884
 885         if (_session) {
 886                 _session->set_frame_rate (_backend->sample_rate());
 887
 888                 if (_session->config.get_jack_time_master()) {
 889                         _backend->set_time_master (true);
 890                 }
 891
 892         }
 893
 894         /* XXX MIDI ports may not actually be available here yet .. */
 895
 896         PortManager::fill_midi_port_info ();
 897
 898         if (!for_latency) {
 899                 Running(); /* EMIT SIGNAL */
 900         }
 901
 902         return 0;
 903 }
 904
 905 int
 906 AudioEngine::stop (bool for_latency)
 907 {
 908         bool stop_engine = true;
 909
 910         if (!_backend) {
 911                 return 0;
 912         }
 913
 914         Glib::Threads::Mutex::Lock pl (_process_lock, Glib::Threads::NOT_LOCK);
 915
 916         if (running()) {
 917                 pl.acquire ();
 918         }
 919
 920         if (for_latency && _backend->can_change_systemic_latency_when_running()) {
 921                 stop_engine = false;
 922         } else {
 923                 if (_backend->stop ()) {
 924                         if (pl.locked ()) {
 925                             pl.release ();
 926                         }
 927                         return -1;
 928                 }
 929         }
 930
 931         if (pl.locked ()) {
 932                 pl.release ();
 933         }
 934
 935         if (_session && _running && stop_engine &&
 936             (_session->state_of_the_state() & Session::Loading) == 0 &&
 937             (_session->state_of_the_state() & Session::Deletion) == 0) {
 938                 // it's not a halt, but should be handled the same way:
 939                 // disable record, stop transport and I/O processign but save the data.
 940                 _session->engine_halted ();
 941         }
 942
 943         if (stop_engine) {
 944                 _running = false;
 945         }
 946         _processed_frames = 0;
 947         _measuring_latency = MeasureNone;
 948         _latency_output_port = 0;
 949         _latency_input_port = 0;
 950         _started_for_latency = false;
 951
 952         if (stop_engine) {
 953                 Port::PortDrop ();
 954         }
 955
 956         if (!for_latency && stop_engine) {
 957                 Stopped (); /* EMIT SIGNAL */
 958         }
 959
 960         return 0;
 961 }
 962
 963 int
 964 AudioEngine::freewheel (bool start_stop)
 965 {
 966         if (!_backend) {
 967                 return -1;
 968         }
 969
 970         /* _freewheeling will be set when first Freewheel signal occurs */
 971
 972         return _backend->freewheel (start_stop);
 973 }
 974
 975 float
 976 AudioEngine::get_dsp_load() const
 977 {
 978         if (!_backend || !_running) {
 979                 return 0.0;
 980         }
 981         return _backend->dsp_load ();
 982 }
 983
 984 bool
 985 AudioEngine::is_realtime() const
 986 {
 987         if (!_backend) {
 988                 return false;
 989         }
 990
 991         return _backend->is_realtime();
 992 }
 993
 994 bool
 995 AudioEngine::connected() const
 996 {
 997         if (!_backend) {
 998                 return false;
 999         }
1000
1001         return _backend->available();
1002 }
1003
1004 void
1005 AudioEngine::transport_start ()
1006 {
1007         if (!_backend) {
1008                 return;
1009         }
1010         return _backend->transport_start ();
1011 }
1012
1013 void
1014 AudioEngine::transport_stop ()
1015 {
1016         if (!_backend) {
1017                 return;
1018         }
1019         return _backend->transport_stop ();
1020 }
1021
1022 TransportState
1023 AudioEngine::transport_state ()
1024 {
1025         if (!_backend) {
1026                 return TransportStopped;
1027         }
1028         return _backend->transport_state ();
1029 }
1030
1031 void
1032 AudioEngine::transport_locate (framepos_t pos)
1033 {
1034         if (!_backend) {
1035                 return;
1036         }
1037         return _backend->transport_locate (pos);
1038 }
1039
1040 framepos_t
1041 AudioEngine::transport_frame()
1042 {
1043         if (!_backend) {
1044                 return 0;
1045         }
1046         return _backend->transport_frame ();
1047 }
1048
1049 framecnt_t
1050 AudioEngine::sample_rate () const
1051 {
1052         if (!_backend) {
1053                 return 0;
1054         }
1055         return _backend->sample_rate ();
1056 }
1057
1058 pframes_t
1059 AudioEngine::samples_per_cycle () const
1060 {
1061         if (!_backend) {
1062                 return 0;
1063         }
1064         return _backend->buffer_size ();
1065 }
1066
1067 int
1068 AudioEngine::usecs_per_cycle () const
1069 {
1070         if (!_backend) {
1071                 return -1;
1072         }
1073         return _backend->usecs_per_cycle ();
1074 }
1075
1076 size_t
1077 AudioEngine::raw_buffer_size (DataType t)
1078 {
1079         if (!_backend) {
1080                 return -1;
1081         }
1082         return _backend->raw_buffer_size (t);
1083 }
1084
1085 framepos_t
1086 AudioEngine::sample_time ()
1087 {
1088         if (!_backend) {
1089                 return 0;
1090         }
1091         return _backend->sample_time ();
1092 }
1093
1094 framepos_t
1095 AudioEngine::sample_time_at_cycle_start ()
1096 {
1097         if (!_backend) {
1098                 return 0;
1099         }
1100         return _backend->sample_time_at_cycle_start ();
1101 }
1102
1103 pframes_t
1104 AudioEngine::samples_since_cycle_start ()
1105 {
1106         if (!_backend) {
1107                 return 0;
1108         }
1109         return _backend->samples_since_cycle_start ();
1110 }
1111
1112 bool
1113 AudioEngine::get_sync_offset (pframes_t& offset) const
1114 {
1115         if (!_backend) {
1116                 return false;
1117         }
1118         return _backend->get_sync_offset (offset);
1119 }
1120
1121 int
1122 AudioEngine::create_process_thread (boost::function<void()> func)
1123 {
1124         if (!_backend) {
1125                 return -1;
1126         }
1127         return _backend->create_process_thread (func);
1128 }
1129
1130 int
1131 AudioEngine::join_process_threads ()
1132 {
1133         if (!_backend) {
1134                 return -1;
1135         }
1136         return _backend->join_process_threads ();
1137 }
1138
1139 bool
1140 AudioEngine::in_process_thread ()
1141 {
1142         if (!_backend) {
1143                 return false;
1144         }
1145         return _backend->in_process_thread ();
1146 }
1147
1148 uint32_t
1149 AudioEngine::process_thread_count ()
1150 {
1151         if (!_backend) {
1152                 return 0;
1153         }
1154         return _backend->process_thread_count ();
1155 }
1156
1157 int
1158 AudioEngine::set_device_name (const std::string& name)
1159 {
1160         if (!_backend) {
1161                 return -1;
1162         }
1163         return _backend->set_device_name  (name);
1164 }
1165
1166 int
1167 AudioEngine::set_sample_rate (float sr)
1168 {
1169         if (!_backend) {
1170                 return -1;
1171         }
1172
1173         return _backend->set_sample_rate  (sr);
1174 }
1175
1176 int
1177 AudioEngine::set_buffer_size (uint32_t bufsiz)
1178 {
1179         if (!_backend) {
1180                 return -1;
1181         }
1182         return _backend->set_buffer_size  (bufsiz);
1183 }
1184
1185 int
1186 AudioEngine::set_interleaved (bool yn)
1187 {
1188         if (!_backend) {
1189                 return -1;
1190         }
1191         return _backend->set_interleaved  (yn);
1192 }
1193
1194 int
1195 AudioEngine::set_input_channels (uint32_t ic)
1196 {
1197         if (!_backend) {
1198                 return -1;
1199         }
1200         return _backend->set_input_channels  (ic);
1201 }
1202
1203 int
1204 AudioEngine::set_output_channels (uint32_t oc)
1205 {
1206         if (!_backend) {
1207                 return -1;
1208         }
1209         return _backend->set_output_channels (oc);
1210 }
1211
1212 int
1213 AudioEngine::set_systemic_input_latency (uint32_t il)
1214 {
1215         if (!_backend) {
1216                 return -1;
1217         }
1218         return _backend->set_systemic_input_latency  (il);
1219 }
1220
1221 int
1222 AudioEngine::set_systemic_output_latency (uint32_t ol)
1223 {
1224         if (!_backend) {
1225                 return -1;
1226         }
1227         return _backend->set_systemic_output_latency  (ol);
1228 }
1229
1230 bool
1231 AudioEngine::thread_initialised_for_audio_processing ()
1232 {
1233     return SessionEvent::has_per_thread_pool () && AsyncMIDIPort::is_process_thread();
1234 }
1235
1236 /* END OF BACKEND PROXY API */
1237
1238 void
1239 AudioEngine::thread_init_callback (void* arg)
1240 {
1241         /* make sure that anybody who needs to know about this thread
1242            knows about it.
1243         */
1244
1245         pthread_set_name (X_("audioengine"));
1246
1247         const int thread_num = g_atomic_int_add (&audioengine_thread_cnt, 1);
1248         const string thread_name = string_compose (X_("AudioEngine %1"), thread_num);
1249
1250         SessionEvent::create_per_thread_pool (thread_name, 512);
1251         PBD::notify_event_loops_about_thread_creation (pthread_self(), thread_name, 4096);
1252         AsyncMIDIPort::set_process_thread (pthread_self());
1253
1254         if (arg) {
1255                 delete AudioEngine::instance()->_main_thread;
1256                 /* the special thread created/managed by the backend */
1257                 AudioEngine::instance()->_main_thread = new ProcessThread;
1258         }
1259 }
1260
1261 int
1262 AudioEngine::sync_callback (TransportState state, framepos_t position)
1263 {
1264         if (_session) {
1265                 return _session->backend_sync_callback (state, position);
1266         }
1267         return 0;
1268 }
1269
1270 void
1271 AudioEngine::freewheel_callback (bool onoff)
1272 {
1273         _freewheeling = onoff;
1274 }
1275
1276 void
1277 AudioEngine::latency_callback (bool for_playback)
1278 {
1279         if (_session) {
1280                 _session->update_latency (for_playback);
1281         }
1282 }
1283
1284 void
1285 AudioEngine::update_latencies ()
1286 {
1287         if (_backend) {
1288                 _backend->update_latencies ();
1289         }
1290 }
1291
1292 void
1293 AudioEngine::halted_callback (const char* why)
1294 {
1295         if (_in_destructor) {
1296                 /* everything is under control */
1297                 return;
1298         }
1299
1300         _running = false;
1301
1302         Port::PortDrop (); /* EMIT SIGNAL */
1303
1304         if (!_started_for_latency) {
1305                 Halted (why);      /* EMIT SIGNAL */
1306         }
1307 }
1308
1309 bool
1310 AudioEngine::setup_required () const
1311 {
1312         if (_backend) {
1313                 if (_backend->info().already_configured())
1314                         return false;
1315         } else {
1316                 if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
1317                         return false;
1318                 }
1319         }
1320
1321         return true;
1322 }
1323
1324 int
1325 AudioEngine::prepare_for_latency_measurement ()
1326 {
1327         if (!_backend) {
1328                 return -1;
1329         }
1330
1331         if (_backend->can_change_systemic_latency_when_running()) {
1332                 if (start()) {
1333                         return -1;
1334                 }
1335                 _backend->set_systemic_input_latency (0);
1336                 _backend->set_systemic_output_latency (0);
1337                 return 0;
1338         }
1339
1340         if (running()) {
1341                 _stopped_for_latency = true;
1342                 stop (true);
1343         }
1344
1345         if (start (true)) {
1346                 return -1;
1347         }
1348         _started_for_latency = true;
1349
1350         return 0;
1351 }
1352
1353 int
1354 AudioEngine::start_latency_detection (bool for_midi)
1355 {
1356         if (prepare_for_latency_measurement ()) {
1357                 return -1;
1358         }
1359
1360         PortEngine& pe (port_engine());
1361
1362         delete _mtdm;
1363         _mtdm = 0;
1364
1365         delete _mididm;
1366         _mididm = 0;
1367
1368         /* find the ports we will connect to */
1369
1370         PortEngine::PortHandle out = pe.get_port_by_name (_latency_output_name);
1371         PortEngine::PortHandle in = pe.get_port_by_name (_latency_input_name);
1372
1373         if (!out || !in) {
1374                 stop (true);
1375                 return -1;
1376         }
1377
1378         /* create the ports we will use to read/write data */
1379         if (for_midi) {
1380                 if ((_latency_output_port = pe.register_port ("latency_out", DataType::MIDI, IsOutput)) == 0) {
1381                         stop (true);
1382                         return -1;
1383                 }
1384                 if (pe.connect (_latency_output_port, _latency_output_name)) {
1385                         pe.unregister_port (_latency_output_port);
1386                         stop (true);
1387                         return -1;
1388                 }
1389
1390                 const string portname ("latency_in");
1391                 if ((_latency_input_port = pe.register_port (portname, DataType::MIDI, IsInput)) == 0) {
1392                         pe.unregister_port (_latency_input_port);
1393                         pe.unregister_port (_latency_output_port);
1394                         stop (true);
1395                         return -1;
1396                 }
1397                 if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1398                         pe.unregister_port (_latency_input_port);
1399                         pe.unregister_port (_latency_output_port);
1400                         stop (true);
1401                         return -1;
1402                 }
1403
1404                 _mididm = new MIDIDM (sample_rate());
1405
1406         } else {
1407
1408                 if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
1409                         stop (true);
1410                         return -1;
1411                 }
1412                 if (pe.connect (_latency_output_port, _latency_output_name)) {
1413                         pe.unregister_port (_latency_output_port);
1414                         stop (true);
1415                         return -1;
1416                 }
1417
1418                 const string portname ("latency_in");
1419                 if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
1420                         pe.unregister_port (_latency_input_port);
1421                         pe.unregister_port (_latency_output_port);
1422                         stop (true);
1423                         return -1;
1424                 }
1425                 if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1426                         pe.unregister_port (_latency_input_port);
1427                         pe.unregister_port (_latency_output_port);
1428                         stop (true);
1429                         return -1;
1430                 }
1431
1432                 _mtdm = new MTDM (sample_rate());
1433
1434         }
1435
1436         LatencyRange lr;
1437         _latency_signal_latency = 0;
1438         lr = pe.get_latency_range (in, false);
1439         _latency_signal_latency = lr.max;
1440         lr = pe.get_latency_range (out, true);
1441         _latency_signal_latency += lr.max;
1442
1443         /* all created and connected, lets go */
1444         _latency_flush_frames = samples_per_cycle();
1445         _measuring_latency = for_midi ? MeasureMIDI : MeasureAudio;
1446
1447         return 0;
1448 }
1449
1450 void
1451 AudioEngine::stop_latency_detection ()
1452 {
1453         _measuring_latency = MeasureNone;
1454
1455         if (_latency_output_port) {
1456                 port_engine().unregister_port (_latency_output_port);
1457                 _latency_output_port = 0;
1458         }
1459         if (_latency_input_port) {
1460                 port_engine().unregister_port (_latency_input_port);
1461                 _latency_input_port = 0;
1462         }
1463
1464         if (!_backend->can_change_systemic_latency_when_running()) {
1465                 stop (true);
1466         }
1467
1468         if (_stopped_for_latency) {
1469                 start ();
1470         }
1471
1472         _stopped_for_latency = false;
1473         _started_for_latency = false;
1474 }
1475
1476 void
1477 AudioEngine::set_latency_output_port (const string& name)
1478 {
1479         _latency_output_name = name;
1480 }
1481
1482 void
1483 AudioEngine::set_latency_input_port (const string& name)
1484 {
1485         _latency_input_name = name;
1486 }
1487
1488 void
1489 AudioEngine::add_pending_port_deletion (Port* p)
1490 {
1491         if (_session) {
1492                 DEBUG_TRACE (DEBUG::Ports, string_compose ("adding %1 to pending port deletion list\n", p->name()));
1493                 if (_port_deletions_pending.write (&p, 1) != 1) {
1494                         error << string_compose (_("programming error: port %1 could not be placed on the pending deletion queue\n"), p->name()) << endmsg;
1495                 }
1496                 _session->auto_connect_thread_wakeup ();
1497         } else {
1498                 DEBUG_TRACE (DEBUG::Ports, string_compose ("Directly delete port %1\n", p->name()));
1499                 delete p;
1500         }
1501 }