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
  27 #include <glibmm/timer.h>
  28 #include <glibmm/pattern.h>
  29 #include <glibmm/module.h>
  30
  31 #include "pbd/epa.h"
  32 #include "pbd/file_utils.h"
  33 #include "pbd/pthread_utils.h"
  34 #include "pbd/stacktrace.h"
  35 #include "pbd/unknown_type.h"
  36
  37 #include "midi++/port.h"
  38 #include "midi++/mmc.h"
  39
  40 #include "ardour/async_midi_port.h"
  41 #include "ardour/audio_port.h"
  42 #include "ardour/audio_backend.h"
  43 #include "ardour/audioengine.h"
  44 #include "ardour/backend_search_path.h"
  45 #include "ardour/buffer.h"
  46 #include "ardour/cycle_timer.h"
  47 #include "ardour/internal_send.h"
  48 #include "ardour/meter.h"
  49 #include "ardour/midi_port.h"
  50 #include "ardour/midiport_manager.h"
  51 #include "ardour/mtdm.h"
  52 #include "ardour/port.h"
  53 #include "ardour/process_thread.h"
  54 #include "ardour/session.h"
  55
  56 #include "i18n.h"
  57
  58 using namespace std;
  59 using namespace ARDOUR;
  60 using namespace PBD;
  61
  62 gint AudioEngine::m_meter_exit;
  63 AudioEngine* AudioEngine::_instance = 0;
  64
  65 AudioEngine::AudioEngine ()
  66         : session_remove_pending (false)
  67         , session_removal_countdown (-1)
  68         , _running (false)
  69         , _freewheeling (false)
  70         , monitor_check_interval (INT32_MAX)
  71         , last_monitor_check (0)
  72         , _processed_frames (0)
  73         , m_meter_thread (0)
  74         , _main_thread (0)
  75         , _mtdm (0)
  76         , _measuring_latency (false)
  77         , _latency_input_port (0)
  78         , _latency_output_port (0)
  79         , _latency_flush_frames (0)
  80         , _latency_signal_latency (0)
  81         , _stopped_for_latency (false)
  82         , _in_destructor (false)
  83 {
  84         g_atomic_int_set (&m_meter_exit, 0);
  85         discover_backends ();
  86 }
  87
  88 AudioEngine::~AudioEngine ()
  89 {
  90         _in_destructor = true;
  91         stop_metering_thread ();
  92         drop_backend ();
  93 }
  94
  95 AudioEngine*
  96 AudioEngine::create ()
  97 {
  98         if (_instance) {
  99                 return _instance;
 100         }
 101
 102         _instance = new AudioEngine ();
 103
 104         return _instance;
 105 }
 106
 107 void
 108 _thread_init_callback (void * /*arg*/)
 109 {
 110         /* make sure that anybody who needs to know about this thread
 111            knows about it.
 112         */
 113
 114         pthread_set_name (X_("audioengine"));
 115
 116         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
 117         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
 118
 119         SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
 120
 121         AsyncMIDIPort::set_process_thread (pthread_self());
 122 }
 123
 124 void
 125 AudioEngine::split_cycle (pframes_t offset)
 126 {
 127         /* caller must hold process lock */
 128
 129         Port::increment_global_port_buffer_offset (offset);
 130
 131         /* tell all Ports that we're going to start a new (split) cycle */
 132
 133         boost::shared_ptr<Ports> p = ports.reader();
 134
 135         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 136                 i->second->cycle_split ();
 137         }
 138 }
 139
 140 int
 141 AudioEngine::sample_rate_change (pframes_t nframes)
 142 {
 143         /* check for monitor input change every 1/10th of second */
 144
 145         monitor_check_interval = nframes / 10;
 146         last_monitor_check = 0;
 147
 148         if (_session) {
 149                 _session->set_frame_rate (nframes);
 150         }
 151
 152         SampleRateChanged (nframes); /* EMIT SIGNAL */
 153
 154         return 0;
 155 }
 156
 157 int
 158 AudioEngine::buffer_size_change (pframes_t bufsiz)
 159 {
 160         if (_session) {
 161                 _session->set_block_size (bufsiz);
 162                 last_monitor_check = 0;
 163         }
 164
 165         return 0;
 166 }
 167
 168 /** Method called by our ::process_thread when there is work to be done.
 169  *  @param nframes Number of frames to process.
 170  */
 171 int
 172 AudioEngine::process_callback (pframes_t nframes)
 173 {
 174         Glib::Threads::Mutex::Lock tm (_process_lock, Glib::Threads::TRY_LOCK);
 175
 176         PT_TIMING_REF;
 177         PT_TIMING_CHECK (1);
 178
 179         /// The number of frames that will have been processed when we've finished
 180         pframes_t next_processed_frames;
 181
 182         /* handle wrap around of total frames counter */
 183
 184         if (max_framepos - _processed_frames < nframes) {
 185                 next_processed_frames = nframes - (max_framepos - _processed_frames);
 186         } else {
 187                 next_processed_frames = _processed_frames + nframes;
 188         }
 189
 190         if (!tm.locked()) {
 191                 /* return having done nothing */
 192                 _processed_frames = next_processed_frames;
 193                 return 0;
 194         }
 195
 196         bool return_after_remove_check = false;
 197
 198         if (_measuring_latency && _mtdm) {
 199                 /* run a normal cycle from the perspective of the PortManager
 200                    so that we get silence on all registered ports.
 201
 202                    we overwrite the silence on the two ports used for latency
 203                    measurement.
 204                 */
 205
 206                 PortManager::cycle_start (nframes);
 207                 PortManager::silence (nframes);
 208
 209                 if (_latency_input_port && _latency_output_port) {
 210                         PortEngine& pe (port_engine());
 211
 212                         Sample* in = (Sample*) pe.get_buffer (_latency_input_port, nframes);
 213                         Sample* out = (Sample*) pe.get_buffer (_latency_output_port, nframes);
 214
 215                         _mtdm->process (nframes, in, out);
 216                 }
 217
 218                 PortManager::cycle_end (nframes);
 219                 return_after_remove_check = true;
 220
 221         } else if (_latency_flush_frames) {
 222
 223                 /* wait for the appropriate duration for the MTDM signal to
 224                  * drain from the ports before we revert to normal behaviour.
 225                  */
 226
 227                 PortManager::cycle_start (nframes);
 228                 PortManager::silence (nframes);
 229                 PortManager::cycle_end (nframes);
 230
 231                 if (_latency_flush_frames > nframes) {
 232                         _latency_flush_frames -= nframes;
 233                 } else {
 234                         _latency_flush_frames = 0;
 235                 }
 236
 237                 return_after_remove_check = true;
 238         }
 239
 240         if (session_remove_pending) {
 241
 242                 /* perform the actual session removal */
 243
 244                 if (session_removal_countdown < 0) {
 245
 246                         /* fade out over 1 second */
 247                         session_removal_countdown = sample_rate()/2;
 248                         session_removal_gain = 1.0;
 249                         session_removal_gain_step = 1.0/session_removal_countdown;
 250
 251                 } else if (session_removal_countdown > 0) {
 252
 253                         /* we'll be fading audio out.
 254
 255                            if this is the last time we do this as part
 256                            of session removal, do a MIDI panic now
 257                            to get MIDI stopped. This relies on the fact
 258                            that "immediate data" (aka "out of band data") from
 259                            MIDI tracks is *appended* after any other data,
 260                            so that it emerges after any outbound note ons, etc.
 261                         */
 262
 263                         if (session_removal_countdown <= nframes) {
 264                                 _session->midi_panic ();
 265                         }
 266
 267                 } else {
 268                         /* fade out done */
 269                         _session = 0;
 270                         session_removal_countdown = -1; // reset to "not in progress"
 271                         session_remove_pending = false;
 272                         session_removed.signal(); // wakes up thread that initiated session removal
 273                 }
 274         }
 275
 276         if (return_after_remove_check) {
 277                 return 0;
 278         }
 279
 280         if (_session == 0) {
 281
 282                 if (!_freewheeling) {
 283                         PortManager::cycle_start (nframes);
 284                         PortManager::cycle_end (nframes);
 285                 }
 286
 287                 _processed_frames = next_processed_frames;
 288
 289                 return 0;
 290         }
 291
 292         /* tell all relevant objects that we're starting a new cycle */
 293
 294         InternalSend::CycleStart (nframes);
 295
 296         /* tell all Ports that we're starting a new cycle */
 297
 298         PortManager::cycle_start (nframes);
 299
 300         /* test if we are freewheeling and there are freewheel signals connected.
 301            ardour should act normally even when freewheeling unless /it/ is
 302            exporting (which is what Freewheel.empty() tests for).
 303         */
 304
 305         if (_freewheeling && !Freewheel.empty()) {
 306                 Freewheel (nframes);
 307         } else {
 308                 if (_session) {
 309                         _session->process (nframes);
 310                 }
 311         }
 312
 313         if (_freewheeling) {
 314                 return 0;
 315         }
 316
 317         if (!_running) {
 318                 _processed_frames = next_processed_frames;
 319                 return 0;
 320         }
 321
 322         if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 323
 324                 PortManager::check_monitoring ();
 325                 last_monitor_check = next_processed_frames;
 326         }
 327
 328         if (_session->silent()) {
 329                 PortManager::silence (nframes);
 330         }
 331
 332         if (session_remove_pending && session_removal_countdown) {
 333
 334                 PortManager::fade_out (session_removal_gain, session_removal_gain_step, nframes);
 335
 336                 if (session_removal_countdown > nframes) {
 337                         session_removal_countdown -= nframes;
 338                 } else {
 339                         session_removal_countdown = 0;
 340                 }
 341
 342                 session_removal_gain -= (nframes * session_removal_gain_step);
 343         }
 344
 345         PortManager::cycle_end (nframes);
 346
 347         _processed_frames = next_processed_frames;
 348
 349         PT_TIMING_CHECK (2);
 350
 351         return 0;
 352 }
 353
 354
 355 void
 356 AudioEngine::stop_metering_thread ()
 357 {
 358         if (m_meter_thread) {
 359                 g_atomic_int_set (&m_meter_exit, 1);
 360                 m_meter_thread->join ();
 361                 m_meter_thread = 0;
 362         }
 363 }
 364
 365 void
 366 AudioEngine::start_metering_thread ()
 367 {
 368         if (m_meter_thread == 0) {
 369                 g_atomic_int_set (&m_meter_exit, 0);
 370                 m_meter_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::meter_thread, this));
 371         }
 372 }
 373
 374 void
 375 AudioEngine::meter_thread ()
 376 {
 377         pthread_set_name (X_("meter"));
 378
 379         while (true) {
 380                 Glib::usleep (10000); /* 1/100th sec interval */
 381                 if (g_atomic_int_get(&m_meter_exit)) {
 382                         break;
 383                 }
 384                 Metering::Meter ();
 385         }
 386 }
 387
 388 void
 389 AudioEngine::set_session (Session *s)
 390 {
 391         Glib::Threads::Mutex::Lock pl (_process_lock);
 392
 393         SessionHandlePtr::set_session (s);
 394
 395         if (_session) {
 396
 397                 pframes_t blocksize = samples_per_cycle ();
 398
 399                 PortManager::cycle_start (blocksize);
 400
 401                 _session->process (blocksize);
 402                 _session->process (blocksize);
 403                 _session->process (blocksize);
 404                 _session->process (blocksize);
 405                 _session->process (blocksize);
 406                 _session->process (blocksize);
 407                 _session->process (blocksize);
 408                 _session->process (blocksize);
 409
 410                 PortManager::cycle_end (blocksize);
 411         }
 412 }
 413
 414 void
 415 AudioEngine::remove_session ()
 416 {
 417         Glib::Threads::Mutex::Lock lm (_process_lock);
 418
 419         if (_running) {
 420
 421                 if (_session) {
 422                         session_remove_pending = true;
 423                         session_removal_countdown = 0;
 424                         session_removed.wait(_process_lock);
 425                 }
 426
 427         } else {
 428                 SessionHandlePtr::set_session (0);
 429         }
 430
 431         remove_all_ports ();
 432 }
 433
 434
 435 void
 436 AudioEngine::died ()
 437 {
 438         /* called from a signal handler for SIGPIPE */
 439
 440         stop_metering_thread ();
 441
 442         _running = false;
 443 }
 444
 445 int
 446 AudioEngine::reset_timebase ()
 447 {
 448         if (_session) {
 449                 if (_session->config.get_jack_time_master()) {
 450                         _backend->set_time_master (true);
 451                 } else {
 452                         _backend->set_time_master (false);
 453                 }
 454         }
 455         return 0;
 456 }
 457
 458
 459 void
 460 AudioEngine::destroy ()
 461 {
 462         delete _instance;
 463         _instance = 0;
 464 }
 465
 466 int
 467 AudioEngine::discover_backends ()
 468 {
 469         vector<std::string> backend_modules;
 470
 471         _backends.clear ();
 472
 473         Glib::PatternSpec so_extension_pattern("*backend.so");
 474         Glib::PatternSpec dylib_extension_pattern("*backend.dylib");
 475
 476 #if defined(PLATFORM_WINDOWS) && defined(DEBUGGABLE_BACKENDS)
 477         #if defined(DEBUG) || defined(_DEBUG)
 478                 Glib::PatternSpec dll_extension_pattern("*backendD.dll");
 479         #else
 480                 Glib::PatternSpec dll_extension_pattern("*backendRDC.dll");
 481         #endif
 482 #else
 483         Glib::PatternSpec dll_extension_pattern("*backend.dll");
 484 #endif
 485
 486         find_matching_files_in_search_path (backend_search_path (),
 487                                             so_extension_pattern, backend_modules);
 488
 489         find_matching_files_in_search_path (backend_search_path (),
 490                                             dylib_extension_pattern, backend_modules);
 491
 492         find_matching_files_in_search_path (backend_search_path (),
 493                                             dll_extension_pattern, backend_modules);
 494
 495         DEBUG_TRACE (DEBUG::Panning, string_compose (_("looking for backends in %1\n"), backend_search_path().to_string()));
 496
 497         for (vector<std::string>::iterator i = backend_modules.begin(); i != backend_modules.end(); ++i) {
 498
 499                 AudioBackendInfo* info;
 500
 501                 if ((info = backend_discover (*i)) != 0) {
 502                         _backends.insert (make_pair (info->name, info));
 503                 }
 504         }
 505
 506         return _backends.size();
 507 }
 508
 509 AudioBackendInfo*
 510 AudioEngine::backend_discover (const string& path)
 511 {
 512         Glib::Module module (path);
 513         AudioBackendInfo* info;
 514         AudioBackendInfo* (*dfunc)(void);
 515         void* func = 0;
 516
 517         if (!module) {
 518                 error << string_compose(_("AudioEngine: cannot load module \"%1\" (%2)"), path,
 519                                         Glib::Module::get_last_error()) << endmsg;
 520                 return 0;
 521         }
 522
 523         if (!module.get_symbol ("descriptor", func)) {
 524                 error << string_compose(_("AudioEngine: backend at \"%1\" has no descriptor function."), path) << endmsg;
 525                 error << Glib::Module::get_last_error() << endmsg;
 526                 return 0;
 527         }
 528
 529         module.make_resident ();
 530
 531         dfunc = (AudioBackendInfo* (*)(void))func;
 532         info = dfunc();
 533
 534         return info;
 535 }
 536
 537 vector<const AudioBackendInfo*>
 538 AudioEngine::available_backends() const
 539 {
 540         vector<const AudioBackendInfo*> r;
 541
 542         for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
 543                 r.push_back (i->second);
 544         }
 545
 546         return r;
 547 }
 548
 549 string
 550 AudioEngine::current_backend_name() const
 551 {
 552         if (_backend) {
 553                 return _backend->name();
 554         }
 555         return string();
 556 }
 557
 558 void
 559 AudioEngine::drop_backend ()
 560 {
 561         if (_backend) {
 562                 _backend->stop ();
 563                 _backend.reset ();
 564         }
 565 }
 566
 567 boost::shared_ptr<AudioBackend>
 568 AudioEngine::set_default_backend ()
 569 {
 570         if (_backends.empty()) {
 571                 return boost::shared_ptr<AudioBackend>();
 572         }
 573
 574         return set_backend (_backends.begin()->first, "", "");
 575 }
 576
 577 boost::shared_ptr<AudioBackend>
 578 AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
 579 {
 580         BackendMap::iterator b = _backends.find (name);
 581
 582         if (b == _backends.end()) {
 583                 return boost::shared_ptr<AudioBackend>();
 584         }
 585
 586         drop_backend ();
 587
 588         try {
 589                 if (b->second->instantiate (arg1, arg2)) {
 590                         throw failed_constructor ();
 591                 }
 592
 593                 _backend = b->second->factory (*this);
 594
 595         } catch (exception& e) {
 596                 error << string_compose (_("Could not create backend for %1: %2"), name, e.what()) << endmsg;
 597                 return boost::shared_ptr<AudioBackend>();
 598         }
 599
 600         return _backend;
 601 }
 602
 603 /* BACKEND PROXY WRAPPERS */
 604
 605 int
 606 AudioEngine::start (bool for_latency)
 607 {
 608         if (!_backend) {
 609                 return -1;
 610         }
 611
 612         if (_running) {
 613                 return 0;
 614         }
 615
 616         _processed_frames = 0;
 617         last_monitor_check = 0;
 618
 619         if (_backend->start (for_latency)) {
 620                 return -1;
 621         }
 622
 623         _running = true;
 624
 625         if (_session) {
 626                 _session->set_frame_rate (_backend->sample_rate());
 627
 628                 if (_session->config.get_jack_time_master()) {
 629                         _backend->set_time_master (true);
 630                 }
 631         }
 632
 633         start_metering_thread ();
 634
 635         if (!for_latency) {
 636                 Running(); /* EMIT SIGNAL */
 637         }
 638
 639         return 0;
 640 }
 641
 642 int
 643 AudioEngine::stop (bool for_latency)
 644 {
 645         if (!_backend) {
 646                 return 0;
 647         }
 648
 649         Glib::Threads::Mutex::Lock lm (_process_lock);
 650
 651         if (_backend->stop ()) {
 652                 return -1;
 653         }
 654
 655         _running = false;
 656         _processed_frames = 0;
 657         _measuring_latency = false;
 658         _latency_output_port = 0;
 659         _latency_input_port = 0;
 660         _started_for_latency = false;
 661         stop_metering_thread ();
 662
 663         Port::PortDrop ();
 664
 665         if (!for_latency) {
 666                 Stopped (); /* EMIT SIGNAL */
 667         }
 668
 669         return 0;
 670 }
 671
 672 int
 673 AudioEngine::pause ()
 674 {
 675         if (!_backend) {
 676                 return 0;
 677         }
 678
 679         if (_backend->pause ()) {
 680                 return -1;
 681         }
 682
 683         _running = false;
 684
 685         Stopped(); /* EMIT SIGNAL */
 686         return 0;
 687 }
 688
 689 int
 690 AudioEngine::freewheel (bool start_stop)
 691 {
 692         if (!_backend) {
 693                 return -1;
 694         }
 695
 696         /* _freewheeling will be set when first Freewheel signal occurs */
 697
 698         return _backend->freewheel (start_stop);
 699 }
 700
 701 float
 702 AudioEngine::get_cpu_load() const
 703 {
 704         if (!_backend) {
 705                 return 0.0;
 706         }
 707         return _backend->cpu_load ();
 708 }
 709
 710 bool
 711 AudioEngine::is_realtime() const
 712 {
 713         if (!_backend) {
 714                 return false;
 715         }
 716
 717         return _backend->is_realtime();
 718 }
 719
 720 bool
 721 AudioEngine::connected() const
 722 {
 723         if (!_backend) {
 724                 return false;
 725         }
 726
 727         return _backend->available();
 728 }
 729
 730 void
 731 AudioEngine::transport_start ()
 732 {
 733         if (!_backend) {
 734                 return;
 735         }
 736         return _backend->transport_start ();
 737 }
 738
 739 void
 740 AudioEngine::transport_stop ()
 741 {
 742         if (!_backend) {
 743                 return;
 744         }
 745         return _backend->transport_stop ();
 746 }
 747
 748 TransportState
 749 AudioEngine::transport_state ()
 750 {
 751         if (!_backend) {
 752                 return TransportStopped;
 753         }
 754         return _backend->transport_state ();
 755 }
 756
 757 void
 758 AudioEngine::transport_locate (framepos_t pos)
 759 {
 760         if (!_backend) {
 761                 return;
 762         }
 763         return _backend->transport_locate (pos);
 764 }
 765
 766 framepos_t
 767 AudioEngine::transport_frame()
 768 {
 769         if (!_backend) {
 770                 return 0;
 771         }
 772         return _backend->transport_frame ();
 773 }
 774
 775 framecnt_t
 776 AudioEngine::sample_rate () const
 777 {
 778         if (!_backend) {
 779                 return 0;
 780         }
 781         return _backend->sample_rate ();
 782 }
 783
 784 pframes_t
 785 AudioEngine::samples_per_cycle () const
 786 {
 787         if (!_backend) {
 788                 return 0;
 789         }
 790         return _backend->buffer_size ();
 791 }
 792
 793 int
 794 AudioEngine::usecs_per_cycle () const
 795 {
 796         if (!_backend) {
 797                 return -1;
 798         }
 799         return _backend->usecs_per_cycle ();
 800 }
 801
 802 size_t
 803 AudioEngine::raw_buffer_size (DataType t)
 804 {
 805         if (!_backend) {
 806                 return -1;
 807         }
 808         return _backend->raw_buffer_size (t);
 809 }
 810
 811 pframes_t
 812 AudioEngine::sample_time ()
 813 {
 814         if (!_backend) {
 815                 return 0;
 816         }
 817         return _backend->sample_time ();
 818 }
 819
 820 pframes_t
 821 AudioEngine::sample_time_at_cycle_start ()
 822 {
 823         if (!_backend) {
 824                 return 0;
 825         }
 826         return _backend->sample_time_at_cycle_start ();
 827 }
 828
 829 pframes_t
 830 AudioEngine::samples_since_cycle_start ()
 831 {
 832         if (!_backend) {
 833                 return 0;
 834         }
 835         return _backend->samples_since_cycle_start ();
 836 }
 837
 838 bool
 839 AudioEngine::get_sync_offset (pframes_t& offset) const
 840 {
 841         if (!_backend) {
 842                 return false;
 843         }
 844         return _backend->get_sync_offset (offset);
 845 }
 846
 847 int
 848 AudioEngine::create_process_thread (boost::function<void()> func)
 849 {
 850         if (!_backend) {
 851                 return -1;
 852         }
 853         return _backend->create_process_thread (func);
 854 }
 855
 856 int
 857 AudioEngine::join_process_threads ()
 858 {
 859         if (!_backend) {
 860                 return -1;
 861         }
 862         return _backend->join_process_threads ();
 863 }
 864
 865 bool
 866 AudioEngine::in_process_thread ()
 867 {
 868         if (!_backend) {
 869                 return false;
 870         }
 871         return _backend->in_process_thread ();
 872 }
 873
 874 uint32_t
 875 AudioEngine::process_thread_count ()
 876 {
 877         if (!_backend) {
 878                 return 0;
 879         }
 880         return _backend->process_thread_count ();
 881 }
 882
 883 int
 884 AudioEngine::set_device_name (const std::string& name)
 885 {
 886         if (!_backend) {
 887                 return -1;
 888         }
 889         return _backend->set_device_name  (name);
 890 }
 891
 892 int
 893 AudioEngine::set_sample_rate (float sr)
 894 {
 895         if (!_backend) {
 896                 return -1;
 897         }
 898         return _backend->set_sample_rate  (sr);
 899 }
 900
 901 int
 902 AudioEngine::set_buffer_size (uint32_t bufsiz)
 903 {
 904         if (!_backend) {
 905                 return -1;
 906         }
 907         return _backend->set_buffer_size  (bufsiz);
 908 }
 909
 910 int
 911 AudioEngine::set_sample_format (SampleFormat sf)
 912 {
 913         if (!_backend) {
 914                 return -1;
 915         }
 916         return _backend->set_sample_format  (sf);
 917 }
 918
 919 int
 920 AudioEngine::set_interleaved (bool yn)
 921 {
 922         if (!_backend) {
 923                 return -1;
 924         }
 925         return _backend->set_interleaved  (yn);
 926 }
 927
 928 int
 929 AudioEngine::set_input_channels (uint32_t ic)
 930 {
 931         if (!_backend) {
 932                 return -1;
 933         }
 934         return _backend->set_input_channels  (ic);
 935 }
 936
 937 int
 938 AudioEngine::set_output_channels (uint32_t oc)
 939 {
 940         if (!_backend) {
 941                 return -1;
 942         }
 943         return _backend->set_output_channels (oc);
 944 }
 945
 946 int
 947 AudioEngine::set_systemic_input_latency (uint32_t il)
 948 {
 949         if (!_backend) {
 950                 return -1;
 951         }
 952         return _backend->set_systemic_input_latency  (il);
 953 }
 954
 955 int
 956 AudioEngine::set_systemic_output_latency (uint32_t ol)
 957 {
 958         if (!_backend) {
 959                 return -1;
 960         }
 961         return _backend->set_systemic_output_latency  (ol);
 962 }
 963
 964 /* END OF BACKEND PROXY API */
 965
 966 void
 967 AudioEngine::thread_init_callback (void* arg)
 968 {
 969         /* make sure that anybody who needs to know about this thread
 970            knows about it.
 971         */
 972
 973         pthread_set_name (X_("audioengine"));
 974
 975         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
 976         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("AudioEngine"), 128);
 977
 978         SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
 979
 980         AsyncMIDIPort::set_process_thread (pthread_self());
 981
 982         if (arg) {
 983                 /* the special thread created/managed by the backend */
 984                 AudioEngine::instance()->_main_thread = new ProcessThread;
 985         }
 986 }
 987
 988 int
 989 AudioEngine::sync_callback (TransportState state, framepos_t position)
 990 {
 991         if (_session) {
 992                 return _session->backend_sync_callback (state, position);
 993         }
 994         return 0;
 995 }
 996
 997 void
 998 AudioEngine::freewheel_callback (bool onoff)
 999 {
1000         _freewheeling = onoff;
1001 }
1002
1003 void
1004 AudioEngine::latency_callback (bool for_playback)
1005 {
1006         if (_session) {
1007                 _session->update_latency (for_playback);
1008         }
1009 }
1010
1011 void
1012 AudioEngine::update_latencies ()
1013 {
1014         if (_backend) {
1015                 _backend->update_latencies ();
1016         }
1017 }
1018
1019 void
1020 AudioEngine::halted_callback (const char* why)
1021 {
1022         if (_in_destructor) {
1023                 /* everything is under control */
1024                 return;
1025         }
1026
1027         stop_metering_thread ();
1028         _running = false;
1029
1030         Port::PortDrop (); /* EMIT SIGNAL */
1031
1032         if (!_started_for_latency) {
1033                 Halted (why);      /* EMIT SIGNAL */
1034         }
1035 }
1036
1037 bool
1038 AudioEngine::setup_required () const
1039 {
1040         /* If there is only a single backend and it claims to be configured
1041          * already there is no setup to be done.
1042          *
1043          * Primarily for a case where there is only a JACK backend and
1044          * JACK is already running.
1045          */
1046
1047         if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
1048                 return false;
1049         }
1050
1051         return true;
1052 }
1053
1054 MTDM*
1055 AudioEngine::mtdm()
1056 {
1057         return _mtdm;
1058 }
1059
1060 int
1061 AudioEngine::prepare_for_latency_measurement ()
1062 {
1063         if (running()) {
1064                 _stopped_for_latency = true;
1065                 stop (true);
1066         }
1067
1068         if (start (true)) {
1069                 _started_for_latency = true;
1070                 return -1;
1071         }
1072
1073         return 0;
1074 }
1075
1076 int
1077 AudioEngine::start_latency_detection ()
1078 {
1079         if (!running()) {
1080                 if (prepare_for_latency_measurement ()) {
1081                         return -1;
1082                 }
1083         }
1084
1085         PortEngine& pe (port_engine());
1086
1087         delete _mtdm;
1088         _mtdm = 0;
1089
1090         /* find the ports we will connect to */
1091
1092         PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
1093         PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
1094
1095         if (!out || !in) {
1096                 stop (true);
1097                 return -1;
1098         }
1099
1100         /* create the ports we will use to read/write data */
1101
1102         if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
1103                 stop (true);
1104                 return -1;
1105         }
1106         if (pe.connect (_latency_output_port, _latency_output_name)) {
1107                 pe.unregister_port (_latency_output_port);
1108                 stop (true);
1109                 return -1;
1110         }
1111
1112         const string portname ("latency_in");
1113         if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
1114                 pe.unregister_port (_latency_output_port);
1115                 stop (true);
1116                 return -1;
1117         }
1118         if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1119                 pe.unregister_port (_latency_output_port);
1120                 stop (true);
1121                 return -1;
1122         }
1123
1124         LatencyRange lr;
1125         _latency_signal_latency = 0;
1126         lr = pe.get_latency_range (in, false);
1127         _latency_signal_latency = lr.max;
1128         lr = pe.get_latency_range (out, true);
1129         _latency_signal_latency += lr.max;
1130
1131         /* all created and connected, lets go */
1132
1133         _mtdm = new MTDM (sample_rate());
1134         _measuring_latency = true;
1135         _latency_flush_frames = samples_per_cycle();
1136
1137         return 0;
1138 }
1139
1140 void
1141 AudioEngine::stop_latency_detection ()
1142 {
1143         _measuring_latency = false;
1144
1145         if (_latency_output_port) {
1146                 port_engine().unregister_port (_latency_output_port);
1147                 _latency_output_port = 0;
1148         }
1149         if (_latency_input_port) {
1150                 port_engine().unregister_port (_latency_input_port);
1151                 _latency_input_port = 0;
1152         }
1153
1154         stop (true);
1155
1156         if (_stopped_for_latency) {
1157                 start ();
1158         }
1159
1160         _stopped_for_latency = false;
1161         _started_for_latency = false;
1162 }
1163
1164 void
1165 AudioEngine::set_latency_output_port (const string& name)
1166 {
1167         _latency_output_name = name;
1168 }
1169
1170 void
1171 AudioEngine::set_latency_input_port (const string& name)
1172 {
1173         _latency_input_name = name;
1174 }