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::freewheel (bool start_stop)
 665 {
 666         if (!_backend) {
 667                 return -1;
 668         }
 669
 670         /* _freewheeling will be set when first Freewheel signal occurs */
 671
 672         return _backend->freewheel (start_stop);
 673 }
 674
 675 float
 676 AudioEngine::get_cpu_load() const
 677 {
 678         if (!_backend) {
 679                 return 0.0;
 680         }
 681         return _backend->cpu_load ();
 682 }
 683
 684 bool
 685 AudioEngine::is_realtime() const
 686 {
 687         if (!_backend) {
 688                 return false;
 689         }
 690
 691         return _backend->is_realtime();
 692 }
 693
 694 bool
 695 AudioEngine::connected() const
 696 {
 697         if (!_backend) {
 698                 return false;
 699         }
 700
 701         return _backend->available();
 702 }
 703
 704 void
 705 AudioEngine::transport_start ()
 706 {
 707         if (!_backend) {
 708                 return;
 709         }
 710         return _backend->transport_start ();
 711 }
 712
 713 void
 714 AudioEngine::transport_stop ()
 715 {
 716         if (!_backend) {
 717                 return;
 718         }
 719         return _backend->transport_stop ();
 720 }
 721
 722 TransportState
 723 AudioEngine::transport_state ()
 724 {
 725         if (!_backend) {
 726                 return TransportStopped;
 727         }
 728         return _backend->transport_state ();
 729 }
 730
 731 void
 732 AudioEngine::transport_locate (framepos_t pos)
 733 {
 734         if (!_backend) {
 735                 return;
 736         }
 737         return _backend->transport_locate (pos);
 738 }
 739
 740 framepos_t
 741 AudioEngine::transport_frame()
 742 {
 743         if (!_backend) {
 744                 return 0;
 745         }
 746         return _backend->transport_frame ();
 747 }
 748
 749 framecnt_t
 750 AudioEngine::sample_rate () const
 751 {
 752         if (!_backend) {
 753                 return 0;
 754         }
 755         return _backend->sample_rate ();
 756 }
 757
 758 pframes_t
 759 AudioEngine::samples_per_cycle () const
 760 {
 761         if (!_backend) {
 762                 return 0;
 763         }
 764         return _backend->buffer_size ();
 765 }
 766
 767 int
 768 AudioEngine::usecs_per_cycle () const
 769 {
 770         if (!_backend) {
 771                 return -1;
 772         }
 773         return _backend->usecs_per_cycle ();
 774 }
 775
 776 size_t
 777 AudioEngine::raw_buffer_size (DataType t)
 778 {
 779         if (!_backend) {
 780                 return -1;
 781         }
 782         return _backend->raw_buffer_size (t);
 783 }
 784
 785 pframes_t
 786 AudioEngine::sample_time ()
 787 {
 788         if (!_backend) {
 789                 return 0;
 790         }
 791         return _backend->sample_time ();
 792 }
 793
 794 pframes_t
 795 AudioEngine::sample_time_at_cycle_start ()
 796 {
 797         if (!_backend) {
 798                 return 0;
 799         }
 800         return _backend->sample_time_at_cycle_start ();
 801 }
 802
 803 pframes_t
 804 AudioEngine::samples_since_cycle_start ()
 805 {
 806         if (!_backend) {
 807                 return 0;
 808         }
 809         return _backend->samples_since_cycle_start ();
 810 }
 811
 812 bool
 813 AudioEngine::get_sync_offset (pframes_t& offset) const
 814 {
 815         if (!_backend) {
 816                 return false;
 817         }
 818         return _backend->get_sync_offset (offset);
 819 }
 820
 821 int
 822 AudioEngine::create_process_thread (boost::function<void()> func)
 823 {
 824         if (!_backend) {
 825                 return -1;
 826         }
 827         return _backend->create_process_thread (func);
 828 }
 829
 830 int
 831 AudioEngine::join_process_threads ()
 832 {
 833         if (!_backend) {
 834                 return -1;
 835         }
 836         return _backend->join_process_threads ();
 837 }
 838
 839 bool
 840 AudioEngine::in_process_thread ()
 841 {
 842         if (!_backend) {
 843                 return false;
 844         }
 845         return _backend->in_process_thread ();
 846 }
 847
 848 uint32_t
 849 AudioEngine::process_thread_count ()
 850 {
 851         if (!_backend) {
 852                 return 0;
 853         }
 854         return _backend->process_thread_count ();
 855 }
 856
 857 int
 858 AudioEngine::set_device_name (const std::string& name)
 859 {
 860         if (!_backend) {
 861                 return -1;
 862         }
 863         return _backend->set_device_name  (name);
 864 }
 865
 866 int
 867 AudioEngine::set_sample_rate (float sr)
 868 {
 869         if (!_backend) {
 870                 return -1;
 871         }
 872         return _backend->set_sample_rate  (sr);
 873 }
 874
 875 int
 876 AudioEngine::set_buffer_size (uint32_t bufsiz)
 877 {
 878         if (!_backend) {
 879                 return -1;
 880         }
 881         return _backend->set_buffer_size  (bufsiz);
 882 }
 883
 884 int
 885 AudioEngine::set_sample_format (SampleFormat sf)
 886 {
 887         if (!_backend) {
 888                 return -1;
 889         }
 890         return _backend->set_sample_format  (sf);
 891 }
 892
 893 int
 894 AudioEngine::set_interleaved (bool yn)
 895 {
 896         if (!_backend) {
 897                 return -1;
 898         }
 899         return _backend->set_interleaved  (yn);
 900 }
 901
 902 int
 903 AudioEngine::set_input_channels (uint32_t ic)
 904 {
 905         if (!_backend) {
 906                 return -1;
 907         }
 908         return _backend->set_input_channels  (ic);
 909 }
 910
 911 int
 912 AudioEngine::set_output_channels (uint32_t oc)
 913 {
 914         if (!_backend) {
 915                 return -1;
 916         }
 917         return _backend->set_output_channels (oc);
 918 }
 919
 920 int
 921 AudioEngine::set_systemic_input_latency (uint32_t il)
 922 {
 923         if (!_backend) {
 924                 return -1;
 925         }
 926         return _backend->set_systemic_input_latency  (il);
 927 }
 928
 929 int
 930 AudioEngine::set_systemic_output_latency (uint32_t ol)
 931 {
 932         if (!_backend) {
 933                 return -1;
 934         }
 935         return _backend->set_systemic_output_latency  (ol);
 936 }
 937
 938 /* END OF BACKEND PROXY API */
 939
 940 void
 941 AudioEngine::thread_init_callback (void* arg)
 942 {
 943         /* make sure that anybody who needs to know about this thread
 944            knows about it.
 945         */
 946
 947         pthread_set_name (X_("audioengine"));
 948
 949         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
 950         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("AudioEngine"), 128);
 951
 952         SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
 953
 954         AsyncMIDIPort::set_process_thread (pthread_self());
 955
 956         if (arg) {
 957                 /* the special thread created/managed by the backend */
 958                 AudioEngine::instance()->_main_thread = new ProcessThread;
 959         }
 960 }
 961
 962 int
 963 AudioEngine::sync_callback (TransportState state, framepos_t position)
 964 {
 965         if (_session) {
 966                 return _session->backend_sync_callback (state, position);
 967         }
 968         return 0;
 969 }
 970
 971 void
 972 AudioEngine::freewheel_callback (bool onoff)
 973 {
 974         _freewheeling = onoff;
 975 }
 976
 977 void
 978 AudioEngine::latency_callback (bool for_playback)
 979 {
 980         if (_session) {
 981                 _session->update_latency (for_playback);
 982         }
 983 }
 984
 985 void
 986 AudioEngine::update_latencies ()
 987 {
 988         if (_backend) {
 989                 _backend->update_latencies ();
 990         }
 991 }
 992
 993 void
 994 AudioEngine::halted_callback (const char* why)
 995 {
 996         if (_in_destructor) {
 997                 /* everything is under control */
 998                 return;
 999         }
1000
1001         stop_metering_thread ();
1002         _running = false;
1003
1004         Port::PortDrop (); /* EMIT SIGNAL */
1005
1006         if (!_started_for_latency) {
1007                 Halted (why);      /* EMIT SIGNAL */
1008         }
1009 }
1010
1011 bool
1012 AudioEngine::setup_required () const
1013 {
1014         /* If there is only a single backend and it claims to be configured
1015          * already there is no setup to be done.
1016          *
1017          * Primarily for a case where there is only a JACK backend and
1018          * JACK is already running.
1019          */
1020
1021         if (_backends.size() == 1 && _backends.begin()->second->already_configured()) {
1022                 return false;
1023         }
1024
1025         return true;
1026 }
1027
1028 MTDM*
1029 AudioEngine::mtdm()
1030 {
1031         return _mtdm;
1032 }
1033
1034 int
1035 AudioEngine::prepare_for_latency_measurement ()
1036 {
1037         if (running()) {
1038                 _stopped_for_latency = true;
1039                 stop (true);
1040         }
1041
1042         if (start (true)) {
1043                 _started_for_latency = true;
1044                 return -1;
1045         }
1046
1047         return 0;
1048 }
1049
1050 int
1051 AudioEngine::start_latency_detection ()
1052 {
1053         if (!running()) {
1054                 if (prepare_for_latency_measurement ()) {
1055                         return -1;
1056                 }
1057         }
1058
1059         PortEngine& pe (port_engine());
1060
1061         delete _mtdm;
1062         _mtdm = 0;
1063
1064         /* find the ports we will connect to */
1065
1066         PortEngine::PortHandle out = pe.get_port_by_name (_latency_output_name);
1067         PortEngine::PortHandle in = pe.get_port_by_name (_latency_input_name);
1068
1069         if (!out || !in) {
1070                 stop (true);
1071                 return -1;
1072         }
1073
1074         /* create the ports we will use to read/write data */
1075
1076         if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
1077                 stop (true);
1078                 return -1;
1079         }
1080         if (pe.connect (_latency_output_port, _latency_output_name)) {
1081                 pe.unregister_port (_latency_output_port);
1082                 stop (true);
1083                 return -1;
1084         }
1085
1086         const string portname ("latency_in");
1087         if ((_latency_input_port = pe.register_port (portname, DataType::AUDIO, IsInput)) == 0) {
1088                 pe.unregister_port (_latency_output_port);
1089                 stop (true);
1090                 return -1;
1091         }
1092         if (pe.connect (_latency_input_name, make_port_name_non_relative (portname))) {
1093                 pe.unregister_port (_latency_output_port);
1094                 stop (true);
1095                 return -1;
1096         }
1097
1098         LatencyRange lr;
1099         _latency_signal_latency = 0;
1100         lr = pe.get_latency_range (in, false);
1101         _latency_signal_latency = lr.max;
1102         lr = pe.get_latency_range (out, true);
1103         _latency_signal_latency += lr.max;
1104
1105         /* all created and connected, lets go */
1106
1107         _mtdm = new MTDM (sample_rate());
1108         _measuring_latency = true;
1109         _latency_flush_frames = samples_per_cycle();
1110
1111         return 0;
1112 }
1113
1114 void
1115 AudioEngine::stop_latency_detection ()
1116 {
1117         _measuring_latency = false;
1118
1119         if (_latency_output_port) {
1120                 port_engine().unregister_port (_latency_output_port);
1121                 _latency_output_port = 0;
1122         }
1123         if (_latency_input_port) {
1124                 port_engine().unregister_port (_latency_input_port);
1125                 _latency_input_port = 0;
1126         }
1127
1128         stop (true);
1129
1130         if (_stopped_for_latency) {
1131                 start ();
1132         }
1133
1134         _stopped_for_latency = false;
1135         _started_for_latency = false;
1136 }
1137
1138 void
1139 AudioEngine::set_latency_output_port (const string& name)
1140 {
1141         _latency_output_name = name;
1142 }
1143
1144 void
1145 AudioEngine::set_latency_input_port (const string& name)
1146 {
1147         _latency_input_name = name;
1148 }