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         Glib::PatternSpec dll_extension_pattern("*backend.dll");
 476
 477         find_matching_files_in_search_path (backend_search_path (),
 478                                             so_extension_pattern, backend_modules);
 479
 480         find_matching_files_in_search_path (backend_search_path (),
 481                                             dylib_extension_pattern, backend_modules);
 482
 483         find_matching_files_in_search_path (backend_search_path (),
 484                                             dll_extension_pattern, backend_modules);
 485
 486         DEBUG_TRACE (DEBUG::Panning, string_compose (_("looking for backends in %1\n"), backend_search_path().to_string()));
 487
 488         for (vector<std::string>::iterator i = backend_modules.begin(); i != backend_modules.end(); ++i) {
 489
 490                 AudioBackendInfo* info;
 491
 492                 if ((info = backend_discover (*i)) != 0) {
 493                         _backends.insert (make_pair (info->name, info));
 494                 }
 495         }
 496
 497         return _backends.size();
 498 }
 499
 500 AudioBackendInfo*
 501 AudioEngine::backend_discover (const string& path)
 502 {
 503         Glib::Module module (path);
 504         AudioBackendInfo* info;
 505         AudioBackendInfo* (*dfunc)(void);
 506         void* func = 0;
 507
 508         if (!module) {
 509                 error << string_compose(_("AudioEngine: cannot load module \"%1\" (%2)"), path,
 510                                         Glib::Module::get_last_error()) << endmsg;
 511                 return 0;
 512         }
 513
 514         if (!module.get_symbol ("descriptor", func)) {
 515                 error << string_compose(_("AudioEngine: backend at \"%1\" has no descriptor function."), path) << endmsg;
 516                 error << Glib::Module::get_last_error() << endmsg;
 517                 return 0;
 518         }
 519
 520         module.make_resident ();
 521
 522         dfunc = (AudioBackendInfo* (*)(void))func;
 523         info = dfunc();
 524
 525         return info;
 526 }
 527
 528 vector<const AudioBackendInfo*>
 529 AudioEngine::available_backends() const
 530 {
 531         vector<const AudioBackendInfo*> r;
 532
 533         for (BackendMap::const_iterator i = _backends.begin(); i != _backends.end(); ++i) {
 534                 r.push_back (i->second);
 535         }
 536
 537         return r;
 538 }
 539
 540 string
 541 AudioEngine::current_backend_name() const
 542 {
 543         if (_backend) {
 544                 return _backend->name();
 545         }
 546         return string();
 547 }
 548
 549 void
 550 AudioEngine::drop_backend ()
 551 {
 552         if (_backend) {
 553                 _backend->stop ();
 554                 _backend.reset ();
 555         }
 556 }
 557
 558 boost::shared_ptr<AudioBackend>
 559 AudioEngine::set_default_backend ()
 560 {
 561         if (_backends.empty()) {
 562                 return boost::shared_ptr<AudioBackend>();
 563         }
 564
 565         return set_backend (_backends.begin()->first, "", "");
 566 }
 567
 568 boost::shared_ptr<AudioBackend>
 569 AudioEngine::set_backend (const std::string& name, const std::string& arg1, const std::string& arg2)
 570 {
 571         BackendMap::iterator b = _backends.find (name);
 572
 573         if (b == _backends.end()) {
 574                 return boost::shared_ptr<AudioBackend>();
 575         }
 576
 577         drop_backend ();
 578
 579         try {
 580                 if (b->second->instantiate (arg1, arg2)) {
 581                         throw failed_constructor ();
 582                 }
 583
 584                 _backend = b->second->factory (*this);
 585
 586         } catch (exception& e) {
 587                 error << string_compose (_("Could not create backend for %1: %2"), name, e.what()) << endmsg;
 588                 return boost::shared_ptr<AudioBackend>();
 589         }
 590
 591         return _backend;
 592 }
 593
 594 /* BACKEND PROXY WRAPPERS */
 595
 596 int
 597 AudioEngine::start (bool for_latency)
 598 {
 599         if (!_backend) {
 600                 return -1;
 601         }
 602
 603         if (_running) {
 604                 return 0;
 605         }
 606
 607         _processed_frames = 0;
 608         last_monitor_check = 0;
 609
 610         if (_backend->start (for_latency)) {
 611                 return -1;
 612         }
 613
 614         _running = true;
 615
 616         if (_session) {
 617                 _session->set_frame_rate (_backend->sample_rate());
 618
 619                 if (_session->config.get_jack_time_master()) {
 620                         _backend->set_time_master (true);
 621                 }
 622         }
 623
 624         start_metering_thread ();
 625
 626         if (!for_latency) {
 627                 Running(); /* EMIT SIGNAL */
 628         }
 629
 630         return 0;
 631 }
 632
 633 int
 634 AudioEngine::stop (bool for_latency)
 635 {
 636         if (!_backend) {
 637                 return 0;
 638         }
 639
 640         Glib::Threads::Mutex::Lock lm (_process_lock);
 641
 642         if (_backend->stop ()) {
 643                 return -1;
 644         }
 645
 646         _running = false;
 647         _processed_frames = 0;
 648         _measuring_latency = false;
 649         _latency_output_port = 0;
 650         _latency_input_port = 0;
 651         _started_for_latency = false;
 652         stop_metering_thread ();
 653
 654         Port::PortDrop ();
 655
 656         if (!for_latency) {
 657                 Stopped (); /* EMIT SIGNAL */
 658         }
 659
 660         return 0;
 661 }
 662
 663 int
 664 AudioEngine::pause ()
 665 {
 666         if (!_backend) {
 667                 return 0;
 668         }
 669
 670         if (_backend->pause ()) {
 671                 return -1;
 672         }
 673
 674         _running = false;
 675
 676         Stopped(); /* EMIT SIGNAL */
 677         return 0;
 678 }
 679
 680 int
 681 AudioEngine::freewheel (bool start_stop)
 682 {
 683         if (!_backend) {
 684                 return -1;
 685         }
 686
 687         /* _freewheeling will be set when first Freewheel signal occurs */
 688
 689         return _backend->freewheel (start_stop);
 690 }
 691
 692 float
 693 AudioEngine::get_cpu_load() const
 694 {
 695         if (!_backend) {
 696                 return 0.0;
 697         }
 698         return _backend->cpu_load ();
 699 }
 700
 701 bool
 702 AudioEngine::is_realtime() const
 703 {
 704         if (!_backend) {
 705                 return false;
 706         }
 707
 708         return _backend->is_realtime();
 709 }
 710
 711 bool
 712 AudioEngine::connected() const
 713 {
 714         if (!_backend) {
 715                 return false;
 716         }
 717
 718         return _backend->available();
 719 }
 720
 721 void
 722 AudioEngine::transport_start ()
 723 {
 724         if (!_backend) {
 725                 return;
 726         }
 727         return _backend->transport_start ();
 728 }
 729
 730 void
 731 AudioEngine::transport_stop ()
 732 {
 733         if (!_backend) {
 734                 return;
 735         }
 736         return _backend->transport_stop ();
 737 }
 738
 739 TransportState
 740 AudioEngine::transport_state ()
 741 {
 742         if (!_backend) {
 743                 return TransportStopped;
 744         }
 745         return _backend->transport_state ();
 746 }
 747
 748 void
 749 AudioEngine::transport_locate (framepos_t pos)
 750 {
 751         if (!_backend) {
 752                 return;
 753         }
 754         return _backend->transport_locate (pos);
 755 }
 756
 757 framepos_t
 758 AudioEngine::transport_frame()
 759 {
 760         if (!_backend) {
 761                 return 0;
 762         }
 763         return _backend->transport_frame ();
 764 }
 765
 766 framecnt_t
 767 AudioEngine::sample_rate () const
 768 {
 769         if (!_backend) {
 770                 return 0;
 771         }
 772         return _backend->sample_rate ();
 773 }
 774
 775 pframes_t
 776 AudioEngine::samples_per_cycle () const
 777 {
 778         if (!_backend) {
 779                 return 0;
 780         }
 781         return _backend->buffer_size ();
 782 }
 783
 784 int
 785 AudioEngine::usecs_per_cycle () const
 786 {
 787         if (!_backend) {
 788                 return -1;
 789         }
 790         return _backend->usecs_per_cycle ();
 791 }
 792
 793 size_t
 794 AudioEngine::raw_buffer_size (DataType t)
 795 {
 796         if (!_backend) {
 797                 return -1;
 798         }
 799         return _backend->raw_buffer_size (t);
 800 }
 801
 802 pframes_t
 803 AudioEngine::sample_time ()
 804 {
 805         if (!_backend) {
 806                 return 0;
 807         }
 808         return _backend->sample_time ();
 809 }
 810
 811 pframes_t
 812 AudioEngine::sample_time_at_cycle_start ()
 813 {
 814         if (!_backend) {
 815                 return 0;
 816         }
 817         return _backend->sample_time_at_cycle_start ();
 818 }
 819
 820 pframes_t
 821 AudioEngine::samples_since_cycle_start ()
 822 {
 823         if (!_backend) {
 824                 return 0;
 825         }
 826         return _backend->samples_since_cycle_start ();
 827 }
 828
 829 bool
 830 AudioEngine::get_sync_offset (pframes_t& offset) const
 831 {
 832         if (!_backend) {
 833                 return false;
 834         }
 835         return _backend->get_sync_offset (offset);
 836 }
 837
 838 int
 839 AudioEngine::create_process_thread (boost::function<void()> func)
 840 {
 841         if (!_backend) {
 842                 return -1;
 843         }
 844         return _backend->create_process_thread (func);
 845 }
 846
 847 int
 848 AudioEngine::join_process_threads ()
 849 {
 850         if (!_backend) {
 851                 return -1;
 852         }
 853         return _backend->join_process_threads ();
 854 }
 855
 856 bool
 857 AudioEngine::in_process_thread ()
 858 {
 859         if (!_backend) {
 860                 return false;
 861         }
 862         return _backend->in_process_thread ();
 863 }
 864
 865 uint32_t
 866 AudioEngine::process_thread_count ()
 867 {
 868         if (!_backend) {
 869                 return 0;
 870         }
 871         return _backend->process_thread_count ();
 872 }
 873
 874 int
 875 AudioEngine::set_device_name (const std::string& name)
 876 {
 877         if (!_backend) {
 878                 return -1;
 879         }
 880         return _backend->set_device_name  (name);
 881 }
 882
 883 int
 884 AudioEngine::set_sample_rate (float sr)
 885 {
 886         if (!_backend) {
 887                 return -1;
 888         }
 889         return _backend->set_sample_rate  (sr);
 890 }
 891
 892 int
 893 AudioEngine::set_buffer_size (uint32_t bufsiz)
 894 {
 895         if (!_backend) {
 896                 return -1;
 897         }
 898         return _backend->set_buffer_size  (bufsiz);
 899 }
 900
 901 int
 902 AudioEngine::set_sample_format (SampleFormat sf)
 903 {
 904         if (!_backend) {
 905                 return -1;
 906         }
 907         return _backend->set_sample_format  (sf);
 908 }
 909
 910 int
 911 AudioEngine::set_interleaved (bool yn)
 912 {
 913         if (!_backend) {
 914                 return -1;
 915         }
 916         return _backend->set_interleaved  (yn);
 917 }
 918
 919 int
 920 AudioEngine::set_input_channels (uint32_t ic)
 921 {
 922         if (!_backend) {
 923                 return -1;
 924         }
 925         return _backend->set_input_channels  (ic);
 926 }
 927
 928 int
 929 AudioEngine::set_output_channels (uint32_t oc)
 930 {
 931         if (!_backend) {
 932                 return -1;
 933         }
 934         return _backend->set_output_channels (oc);
 935 }
 936
 937 int
 938 AudioEngine::set_systemic_input_latency (uint32_t il)
 939 {
 940         if (!_backend) {
 941                 return -1;
 942         }
 943         return _backend->set_systemic_input_latency  (il);
 944 }
 945
 946 int
 947 AudioEngine::set_systemic_output_latency (uint32_t ol)
 948 {
 949         if (!_backend) {
 950                 return -1;
 951         }
 952         return _backend->set_systemic_output_latency  (ol);
 953 }
 954
 955 /* END OF BACKEND PROXY API */
 956
 957 void
 958 AudioEngine::thread_init_callback (void* arg)
 959 {
 960         /* make sure that anybody who needs to know about this thread
 961            knows about it.
 962         */
 963
 964         pthread_set_name (X_("audioengine"));
 965
 966         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
 967         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("AudioEngine"), 128);
 968
 969         SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
 970
 971         AsyncMIDIPort::set_process_thread (pthread_self());
 972
 973         if (arg) {
 974                 /* the special thread created/managed by the backend */
 975                 AudioEngine::instance()->_main_thread = new ProcessThread;
 976         }
 977 }
 978
 979 int
 980 AudioEngine::sync_callback (TransportState state, framepos_t position)
 981 {
 982         if (_session) {
 983                 return _session->backend_sync_callback (state, position);
 984         }
 985         return 0;
 986 }
 987
 988 void
 989 AudioEngine::freewheel_callback (bool onoff)
 990 {
 991         _freewheeling = onoff;
 992 }
 993
 994 void
 995 AudioEngine::latency_callback (bool for_playback)
 996 {
 997         if (_session) {
 998                 _session->update_latency (for_playback);
 999         }
1000 }
1001
1002 void
1003 AudioEngine::update_latencies ()
1004 {
1005         if (_backend) {
1006                 _backend->update_latencies ();
1007         }
1008 }
1009
1010 void
1011 AudioEngine::halted_callback (const char* why)
1012 {
1013         if (_in_destructor) {
1014                 /* everything is under control */
1015                 return;
1016         }
1017
1018         stop_metering_thread ();
1019         _running = false;
1020
1021         Port::PortDrop (); /* EMIT SIGNAL */
1022
1023         if (!_started_for_latency) {
1024                 Halted (why);      /* EMIT SIGNAL */
1025         }
1026 }
1027
1028 bool
1029 AudioEngine::setup_required () const
1030 {
1031         /* If there is only a single backend and it claims to be configured
1032          * already there is no setup to be done.
1033          *
1034          * Primarily for a case where there is only a JACK backend and
1035          * JACK is already running.
1036          */
1037
1038         if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
1039                 return false;
1040         }
1041
1042         return true;
1043 }
1044
1045 MTDM*
1046 AudioEngine::mtdm()
1047 {
1048         return _mtdm;
1049 }
1050
1051 int
1052 AudioEngine::prepare_for_latency_measurement ()
1053 {
1054         if (running()) {
1055                 _stopped_for_latency = true;
1056                 stop (true);
1057         }
1058
1059         if (start (true)) {
1060                 _started_for_latency = true;
1061                 return -1;
1062         }
1063
1064         return 0;
1065 }
1066
1067 int
1068 AudioEngine::start_latency_detection ()
1069 {
1070         if (!running()) {
1071                 if (prepare_for_latency_measurement ()) {
1072                         return -1;
1073                 }
1074         }
1075
1076         PortEngine& pe (port_engine());
1077
1078         delete _mtdm;
1079         _mtdm = 0;
1080
1081         /* find the ports we will connect to */
1082
1083         PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
1084         PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
1085
1086         if (!out || !in) {
1087                 stop (true);
1088                 return -1;
1089         }
1090
1091         /* create the ports we will use to read/write data */
1092
1093         if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
1094                 stop (true);
1095                 return -1;
1096         }
1097         if (pe.connect (_latency_output_port, _latency_output_name)) {
1098                 pe.unregister_port (_latency_output_port);
1099                 stop (true);
1100                 return -1;
1101         }
1102
1103         const string portname ("latency_in");
1104         if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
1105                 pe.unregister_port (_latency_output_port);
1106                 stop (true);
1107                 return -1;
1108         }
1109         if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1110                 pe.unregister_port (_latency_output_port);
1111                 stop (true);
1112                 return -1;
1113         }
1114
1115         LatencyRange lr;
1116         _latency_signal_latency = 0;
1117         lr = pe.get_latency_range (in, false);
1118         _latency_signal_latency = lr.max;
1119         lr = pe.get_latency_range (out, true);
1120         _latency_signal_latency += lr.max;
1121
1122         /* all created and connected, lets go */
1123
1124         _mtdm = new MTDM (sample_rate());
1125         _measuring_latency = true;
1126         _latency_flush_frames = samples_per_cycle();
1127
1128         return 0;
1129 }
1130
1131 void
1132 AudioEngine::stop_latency_detection ()
1133 {
1134         _measuring_latency = false;
1135
1136         if (_latency_output_port) {
1137                 port_engine().unregister_port (_latency_output_port);
1138                 _latency_output_port = 0;
1139         }
1140         if (_latency_input_port) {
1141                 port_engine().unregister_port (_latency_input_port);
1142                 _latency_input_port = 0;
1143         }
1144
1145         stop (true);
1146
1147         if (_stopped_for_latency) {
1148                 start ();
1149         }
1150
1151         _stopped_for_latency = false;
1152         _started_for_latency = false;
1153 }
1154
1155 void
1156 AudioEngine::set_latency_output_port (const string& name)
1157 {
1158         _latency_output_name = name;
1159 }
1160
1161 void
1162 AudioEngine::set_latency_input_port (const string& name)
1163 {
1164         _latency_input_name = name;
1165 }