libs/ardour/audioengine.cc

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