libs/ardour/audioengine.cc

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