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