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