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 vector<const AudioBackendInfo*>
 779 AudioEngine::available_backends() const
 780 {
 781         vector<const AudioBackendInfo*> r;
 782
 783         for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
 784                 r.push_back (i->second);
 785         }
 786
 787         return r;
 788 }
 789
 790 string
 791 AudioEngine::current_backend_name() const
 792 {
 793         if (_backend) {
 794                 return _backend->name();
 795         }
 796         return string();
 797 }
 798
 799 void
 800 AudioEngine::drop_backend ()
 801 {
 802         if (_backend) {
 803                 _backend->stop ();
 804                 // Stopped is needed for Graph to explicitly terminate threads
 805                 Stopped (); /* EMIT SIGNAL */
 806                 _backend->drop_device ();
 807                 _backend.reset ();
 808                 _running = false;
 809         }
 810 }
 811
 812 boost::shared_ptr<AudioBackend>
 813 AudioEngine::set_default_backend ()
 814 {
 815         if (_backends.empty()) {
 816                 return boost::shared_ptr<AudioBackend>();
 817         }
 818
 819         return set_backend (_backends.begin()->first, "", "");
 820 }
 821
 822 boost::shared_ptr<AudioBackend>
 823 AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
 824 {
 825         BackendMap::iterator b = _backends.find (name);
 826
 827         if (b == _backends.end()) {
 828                 return boost::shared_ptr<AudioBackend>();
 829         }
 830
 831         drop_backend ();
 832
 833         try {
 834                 if (b->second->instantiate (arg1, arg2)) {
 835                         throw failed_constructor ();
 836                 }
 837
 838                 _backend = b->second->factory (*this);
 839
 840         } catch (exception& e) {
 841                 error << string_compose (_("Could not create backend for %1: %2"), name, e.what()) << endmsg;
 842                 return boost::shared_ptr<AudioBackend>();
 843         }
 844
 845         return _backend;
 846 }
 847
 848 /* BACKEND PROXY WRAPPERS */
 849
 850 int
 851 AudioEngine::start (bool for_latency)
 852 {
 853         if (!_backend) {
 854                 return -1;
 855         }
 856
 857         if (_running) {
 858                 return 0;
 859         }
 860
 861         _processed_frames = 0;
 862         last_monitor_check = 0;
 863
 864         int error_code = _backend->start (for_latency);
 865
 866         if (error_code != 0) {
 867                 _last_backend_error_string =
 868                     AudioBackend::get_error_string((AudioBackend::ErrorCode)error_code);
 869                 return -1;
 870         }
 871
 872         _running = true;
 873
 874         if (_session) {
 875                 _session->set_frame_rate (_backend->sample_rate());
 876
 877                 if (_session->config.get_jack_time_master()) {
 878                         _backend->set_time_master (true);
 879                 }
 880
 881         }
 882
 883         if (!for_latency) {
 884                 Running(); /* EMIT SIGNAL */
 885         }
 886
 887         return 0;
 888 }
 889
 890 int
 891 AudioEngine::stop (bool for_latency)
 892 {
 893         bool stop_engine = true;
 894
 895         if (!_backend) {
 896                 return 0;
 897         }
 898
 899         Glib::Threads::Mutex::Lock pl (_process_lock, Glib::Threads::NOT_LOCK);
 900
 901         if (running()) {
 902                 pl.acquire ();
 903         }
 904
 905         if (for_latency && _backend->can_change_systemic_latency_when_running()) {
 906                 stop_engine = false;
 907         } else {
 908                 if (_backend->stop ()) {
 909                         if (pl.locked ()) {
 910                             pl.release ();
 911                         }
 912                         return -1;
 913                 }
 914         }
 915
 916         if (pl.locked ()) {
 917                 pl.release ();
 918         }
 919
 920         if (_session && _running && stop_engine &&
 921             (_session->state_of_the_state() & Session::Loading) == 0 &&
 922             (_session->state_of_the_state() & Session::Deletion) == 0) {
 923                 // it's not a halt, but should be handled the same way:
 924                 // disable record, stop transport and I/O processign but save the data.
 925                 _session->engine_halted ();
 926         }
 927
 928         if (stop_engine) {
 929                 _running = false;
 930         }
 931         _processed_frames = 0;
 932         _measuring_latency = MeasureNone;
 933         _latency_output_port = 0;
 934         _latency_input_port = 0;
 935         _started_for_latency = false;
 936
 937         if (stop_engine) {
 938                 Port::PortDrop ();
 939         }
 940
 941         if (!for_latency && stop_engine) {
 942                 Stopped (); /* EMIT SIGNAL */
 943         }
 944
 945         return 0;
 946 }
 947
 948 int
 949 AudioEngine::freewheel (bool start_stop)
 950 {
 951         if (!_backend) {
 952                 return -1;
 953         }
 954
 955         /* _freewheeling will be set when first Freewheel signal occurs */
 956
 957         return _backend->freewheel (start_stop);
 958 }
 959
 960 float
 961 AudioEngine::get_dsp_load() const
 962 {
 963         if (!_backend || !_running) {
 964                 return 0.0;
 965         }
 966         return _backend->dsp_load ();
 967 }
 968
 969 bool
 970 AudioEngine::is_realtime() const
 971 {
 972         if (!_backend) {
 973                 return false;
 974         }
 975
 976         return _backend->is_realtime();
 977 }
 978
 979 bool
 980 AudioEngine::connected() const
 981 {
 982         if (!_backend) {
 983                 return false;
 984         }
 985
 986         return _backend->available();
 987 }
 988
 989 void
 990 AudioEngine::transport_start ()
 991 {
 992         if (!_backend) {
 993                 return;
 994         }
 995         return _backend->transport_start ();
 996 }
 997
 998 void
 999 AudioEngine::transport_stop ()
1000 {
1001         if (!_backend) {
1002                 return;
1003         }
1004         return _backend->transport_stop ();
1005 }
1006
1007 TransportState
1008 AudioEngine::transport_state ()
1009 {
1010         if (!_backend) {
1011                 return TransportStopped;
1012         }
1013         return _backend->transport_state ();
1014 }
1015
1016 void
1017 AudioEngine::transport_locate (framepos_t pos)
1018 {
1019         if (!_backend) {
1020                 return;
1021         }
1022         return _backend->transport_locate (pos);
1023 }
1024
1025 framepos_t
1026 AudioEngine::transport_frame()
1027 {
1028         if (!_backend) {
1029                 return 0;
1030         }
1031         return _backend->transport_frame ();
1032 }
1033
1034 framecnt_t
1035 AudioEngine::sample_rate () const
1036 {
1037         if (!_backend) {
1038                 return 0;
1039         }
1040         return _backend->sample_rate ();
1041 }
1042
1043 pframes_t
1044 AudioEngine::samples_per_cycle () const
1045 {
1046         if (!_backend) {
1047                 return 0;
1048         }
1049         return _backend->buffer_size ();
1050 }
1051
1052 int
1053 AudioEngine::usecs_per_cycle () const
1054 {
1055         if (!_backend) {
1056                 return -1;
1057         }
1058         return _backend->usecs_per_cycle ();
1059 }
1060
1061 size_t
1062 AudioEngine::raw_buffer_size (DataType t)
1063 {
1064         if (!_backend) {
1065                 return -1;
1066         }
1067         return _backend->raw_buffer_size (t);
1068 }
1069
1070 framepos_t
1071 AudioEngine::sample_time ()
1072 {
1073         if (!_backend) {
1074                 return 0;
1075         }
1076         return _backend->sample_time ();
1077 }
1078
1079 framepos_t
1080 AudioEngine::sample_time_at_cycle_start ()
1081 {
1082         if (!_backend) {
1083                 return 0;
1084         }
1085         return _backend->sample_time_at_cycle_start ();
1086 }
1087
1088 pframes_t
1089 AudioEngine::samples_since_cycle_start ()
1090 {
1091         if (!_backend) {
1092                 return 0;
1093         }
1094         return _backend->samples_since_cycle_start ();
1095 }
1096
1097 bool
1098 AudioEngine::get_sync_offset (pframes_t& offset) const
1099 {
1100         if (!_backend) {
1101                 return false;
1102         }
1103         return _backend->get_sync_offset (offset);
1104 }
1105
1106 int
1107 AudioEngine::create_process_thread (boost::function<void()> func)
1108 {
1109         if (!_backend) {
1110                 return -1;
1111         }
1112         return _backend->create_process_thread (func);
1113 }
1114
1115 int
1116 AudioEngine::join_process_threads ()
1117 {
1118         if (!_backend) {
1119                 return -1;
1120         }
1121         return _backend->join_process_threads ();
1122 }
1123
1124 bool
1125 AudioEngine::in_process_thread ()
1126 {
1127         if (!_backend) {
1128                 return false;
1129         }
1130         return _backend->in_process_thread ();
1131 }
1132
1133 uint32_t
1134 AudioEngine::process_thread_count ()
1135 {
1136         if (!_backend) {
1137                 return 0;
1138         }
1139         return _backend->process_thread_count ();
1140 }
1141
1142 int
1143 AudioEngine::set_device_name (const std::string& name)
1144 {
1145         if (!_backend) {
1146                 return -1;
1147         }
1148         return _backend->set_device_name  (name);
1149 }
1150
1151 int
1152 AudioEngine::set_sample_rate (float sr)
1153 {
1154         if (!_backend) {
1155                 return -1;
1156         }
1157
1158         return _backend->set_sample_rate  (sr);
1159 }
1160
1161 int
1162 AudioEngine::set_buffer_size (uint32_t bufsiz)
1163 {
1164         if (!_backend) {
1165                 return -1;
1166         }
1167         return _backend->set_buffer_size  (bufsiz);
1168 }
1169
1170 int
1171 AudioEngine::set_interleaved (bool yn)
1172 {
1173         if (!_backend) {
1174                 return -1;
1175         }
1176         return _backend->set_interleaved  (yn);
1177 }
1178
1179 int
1180 AudioEngine::set_input_channels (uint32_t ic)
1181 {
1182         if (!_backend) {
1183                 return -1;
1184         }
1185         return _backend->set_input_channels  (ic);
1186 }
1187
1188 int
1189 AudioEngine::set_output_channels (uint32_t oc)
1190 {
1191         if (!_backend) {
1192                 return -1;
1193         }
1194         return _backend->set_output_channels (oc);
1195 }
1196
1197 int
1198 AudioEngine::set_systemic_input_latency (uint32_t il)
1199 {
1200         if (!_backend) {
1201                 return -1;
1202         }
1203         return _backend->set_systemic_input_latency  (il);
1204 }
1205
1206 int
1207 AudioEngine::set_systemic_output_latency (uint32_t ol)
1208 {
1209         if (!_backend) {
1210                 return -1;
1211         }
1212         return _backend->set_systemic_output_latency  (ol);
1213 }
1214
1215 bool
1216 AudioEngine::thread_initialised_for_audio_processing ()
1217 {
1218     return SessionEvent::has_per_thread_pool () && AsyncMIDIPort::is_process_thread();
1219 }
1220
1221 /* END OF BACKEND PROXY API */
1222
1223 void
1224 AudioEngine::thread_init_callback (void* arg)
1225 {
1226         /* make sure that anybody who needs to know about this thread
1227            knows about it.
1228         */
1229
1230         pthread_set_name (X_("audioengine"));
1231
1232         const int thread_num = g_atomic_int_add (&audioengine_thread_cnt, 1);
1233         const string thread_name = string_compose (X_("AudioEngine %1"), thread_num);
1234
1235         SessionEvent::create_per_thread_pool (thread_name, 512);
1236         PBD::notify_event_loops_about_thread_creation (pthread_self(), thread_name, 4096);
1237         AsyncMIDIPort::set_process_thread (pthread_self());
1238
1239         if (arg) {
1240                 delete AudioEngine::instance()->_main_thread;
1241                 /* the special thread created/managed by the backend */
1242                 AudioEngine::instance()->_main_thread = new ProcessThread;
1243         }
1244 }
1245
1246 int
1247 AudioEngine::sync_callback (TransportState state, framepos_t position)
1248 {
1249         if (_session) {
1250                 return _session->backend_sync_callback (state, position);
1251         }
1252         return 0;
1253 }
1254
1255 void
1256 AudioEngine::freewheel_callback (bool onoff)
1257 {
1258         _freewheeling = onoff;
1259 }
1260
1261 void
1262 AudioEngine::latency_callback (bool for_playback)
1263 {
1264         if (_session) {
1265                 _session->update_latency (for_playback);
1266         }
1267 }
1268
1269 void
1270 AudioEngine::update_latencies ()
1271 {
1272         if (_backend) {
1273                 _backend->update_latencies ();
1274         }
1275 }
1276
1277 void
1278 AudioEngine::halted_callback (const char* why)
1279 {
1280         if (_in_destructor) {
1281                 /* everything is under control */
1282                 return;
1283         }
1284
1285         _running = false;
1286
1287         Port::PortDrop (); /* EMIT SIGNAL */
1288
1289         if (!_started_for_latency) {
1290                 Halted (why);      /* EMIT SIGNAL */
1291         }
1292 }
1293
1294 bool
1295 AudioEngine::setup_required () const
1296 {
1297         if (_backend) {
1298                 if (_backend->info().already_configured())
1299                         return false;
1300         } else {
1301                 if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
1302                         return false;
1303                 }
1304         }
1305
1306         return true;
1307 }
1308
1309 int
1310 AudioEngine::prepare_for_latency_measurement ()
1311 {
1312         if (!_backend) {
1313                 return -1;
1314         }
1315
1316         if (_backend->can_change_systemic_latency_when_running()) {
1317                 if (start()) {
1318                         return -1;
1319                 }
1320                 _backend->set_systemic_input_latency (0);
1321                 _backend->set_systemic_output_latency (0);
1322                 return 0;
1323         }
1324
1325         if (running()) {
1326                 _stopped_for_latency = true;
1327                 stop (true);
1328         }
1329
1330         if (start (true)) {
1331                 return -1;
1332         }
1333         _started_for_latency = true;
1334
1335         return 0;
1336 }
1337
1338 int
1339 AudioEngine::start_latency_detection (bool for_midi)
1340 {
1341         if (prepare_for_latency_measurement ()) {
1342                 return -1;
1343         }
1344
1345         PortEngine& pe (port_engine());
1346
1347         delete _mtdm;
1348         _mtdm = 0;
1349
1350         delete _mididm;
1351         _mididm = 0;
1352
1353         /* find the ports we will connect to */
1354
1355         PortEngine::PortHandle out = pe.get_port_by_name (_latency_output_name);
1356         PortEngine::PortHandle in = pe.get_port_by_name (_latency_input_name);
1357
1358         if (!out || !in) {
1359                 stop (true);
1360                 return -1;
1361         }
1362
1363         /* create the ports we will use to read/write data */
1364         if (for_midi) {
1365                 if ((_latency_output_port = pe.register_port ("latency_out", DataType::MIDI, IsOutput)) == 0) {
1366                         stop (true);
1367                         return -1;
1368                 }
1369                 if (pe.connect (_latency_output_port, _latency_output_name)) {
1370                         pe.unregister_port (_latency_output_port);
1371                         stop (true);
1372                         return -1;
1373                 }
1374
1375                 const string portname ("latency_in");
1376                 if ((_latency_input_port = pe.register_port (portname, DataType::MIDI, IsInput)) == 0) {
1377                         pe.unregister_port (_latency_input_port);
1378                         pe.unregister_port (_latency_output_port);
1379                         stop (true);
1380                         return -1;
1381                 }
1382                 if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1383                         pe.unregister_port (_latency_input_port);
1384                         pe.unregister_port (_latency_output_port);
1385                         stop (true);
1386                         return -1;
1387                 }
1388
1389                 _mididm = new MIDIDM (sample_rate());
1390
1391         } else {
1392
1393                 if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
1394                         stop (true);
1395                         return -1;
1396                 }
1397                 if (pe.connect (_latency_output_port, _latency_output_name)) {
1398                         pe.unregister_port (_latency_output_port);
1399                         stop (true);
1400                         return -1;
1401                 }
1402
1403                 const string portname ("latency_in");
1404                 if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
1405                         pe.unregister_port (_latency_input_port);
1406                         pe.unregister_port (_latency_output_port);
1407                         stop (true);
1408                         return -1;
1409                 }
1410                 if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1411                         pe.unregister_port (_latency_input_port);
1412                         pe.unregister_port (_latency_output_port);
1413                         stop (true);
1414                         return -1;
1415                 }
1416
1417                 _mtdm = new MTDM (sample_rate());
1418
1419         }
1420
1421         LatencyRange lr;
1422         _latency_signal_latency = 0;
1423         lr = pe.get_latency_range (in, false);
1424         _latency_signal_latency = lr.max;
1425         lr = pe.get_latency_range (out, true);
1426         _latency_signal_latency += lr.max;
1427
1428         /* all created and connected, lets go */
1429         _latency_flush_frames = samples_per_cycle();
1430         _measuring_latency = for_midi ? MeasureMIDI : MeasureAudio;
1431
1432         return 0;
1433 }
1434
1435 void
1436 AudioEngine::stop_latency_detection ()
1437 {
1438         _measuring_latency = MeasureNone;
1439
1440         if (_latency_output_port) {
1441                 port_engine().unregister_port (_latency_output_port);
1442                 _latency_output_port = 0;
1443         }
1444         if (_latency_input_port) {
1445                 port_engine().unregister_port (_latency_input_port);
1446                 _latency_input_port = 0;
1447         }
1448
1449         if (!_backend->can_change_systemic_latency_when_running()) {
1450                 stop (true);
1451         }
1452
1453         if (_stopped_for_latency) {
1454                 start ();
1455         }
1456
1457         _stopped_for_latency = false;
1458         _started_for_latency = false;
1459 }
1460
1461 void
1462 AudioEngine::set_latency_output_port (const string& name)
1463 {
1464         _latency_output_name = name;
1465 }
1466
1467 void
1468 AudioEngine::set_latency_input_port (const string& name)
1469 {
1470         _latency_input_name = name;
1471 }