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
  29 #include "pbd/pthread_utils.h"
  30 #include "pbd/stacktrace.h"
  31 #include "pbd/unknown_type.h"
  32 #include "pbd/epa.h"
  33
  34 #include <jack/weakjack.h>
  35
  36 #include "midi++/port.h"
  37 #include "midi++/jack_midi_port.h"
  38 #include "midi++/mmc.h"
  39 #include "midi++/manager.h"
  40
  41 #include "ardour/audio_port.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/buffer.h"
  44 #include "ardour/cycle_timer.h"
  45 #include "ardour/internal_send.h"
  46 #include "ardour/meter.h"
  47 #include "ardour/midi_port.h"
  48 #include "ardour/port.h"
  49 #include "ardour/process_thread.h"
  50 #include "ardour/session.h"
  51
  52 #include "i18n.h"
  53
  54 using namespace std;
  55 using namespace ARDOUR;
  56 using namespace PBD;
  57
  58 gint AudioEngine::m_meter_exit;
  59 AudioEngine* AudioEngine::_instance = 0;
  60
  61 #define GET_PRIVATE_JACK_POINTER(j)  jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
  62 #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
  63
  64 AudioEngine::AudioEngine (string client_name, string session_uuid)
  65         : ports (new Ports)
  66 {
  67         _instance = this; /* singleton */
  68
  69         session_remove_pending = false;
  70         _running = false;
  71         _has_run = false;
  72         last_monitor_check = 0;
  73         monitor_check_interval = INT32_MAX;
  74         _processed_frames = 0;
  75         _usecs_per_cycle = 0;
  76         _jack = 0;
  77         _frame_rate = 0;
  78         _buffer_size = 0;
  79         _freewheeling = false;
  80         _pre_freewheel_mmc_enabled = false;
  81         _main_thread = 0;
  82         port_remove_in_progress = false;
  83
  84         m_meter_thread = 0;
  85         g_atomic_int_set (&m_meter_exit, 0);
  86
  87         if (connect_to_jack (client_name, session_uuid)) {
  88                 throw NoBackendAvailable ();
  89         }
  90
  91         Port::set_engine (this);
  92 }
  93
  94 AudioEngine::~AudioEngine ()
  95 {
  96         {
  97                 Glib::Mutex::Lock tm (_process_lock);
  98                 session_removed.signal ();
  99
 100                 if (_running) {
 101                         jack_client_close (_jack);
 102                         _jack = 0;
 103                 }
 104
 105                 stop_metering_thread ();
 106         }
 107 }
 108
 109 jack_client_t*
 110 AudioEngine::jack() const
 111 {
 112         return _jack;
 113 }
 114
 115 void
 116 _thread_init_callback (void * /*arg*/)
 117 {
 118         /* make sure that anybody who needs to know about this thread
 119            knows about it.
 120         */
 121
 122         pthread_set_name (X_("audioengine"));
 123
 124         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
 125         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
 126
 127         SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
 128
 129         MIDI::JackMIDIPort::set_process_thread (pthread_self());
 130 }
 131
 132 static void
 133 ardour_jack_error (const char* msg)
 134 {
 135         error << "JACK: " << msg << endmsg;
 136 }
 137
 138 void
 139 AudioEngine::set_jack_callbacks ()
 140 {
 141         GET_PRIVATE_JACK_POINTER (_jack);
 142
 143         if (jack_on_info_shutdown) {
 144                 jack_on_info_shutdown (_priv_jack, halted_info, this);
 145         } else {
 146                 jack_on_shutdown (_priv_jack, halted, this);
 147         }
 148
 149         jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
 150         jack_set_process_thread (_priv_jack, _process_thread, this);
 151         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 152         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 153         jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
 154         jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
 155         jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
 156         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 157         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 158         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 159
 160         if (_session && _session->config.get_jack_time_master()) {
 161                 jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 162         }
 163
 164 #ifdef HAVE_JACK_SESSION
 165         if( jack_set_session_callback)
 166                 jack_set_session_callback (_priv_jack, _session_callback, this);
 167 #endif
 168
 169         if (jack_set_latency_callback) {
 170                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 171         }
 172
 173         jack_set_error_function (ardour_jack_error);
 174 }
 175
 176 int
 177 AudioEngine::start ()
 178 {
 179         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 180
 181         if (!_running) {
 182
 183                 if (!jack_port_type_get_buffer_size) {
 184                         warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 185                 }
 186
 187                 if (_session) {
 188                         BootMessage (_("Connect session to engine"));
 189                         _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
 190                 }
 191
 192                 /* a proxy for whether jack_activate() will definitely call the buffer size
 193                  * callback. with older versions of JACK, this function symbol will be null.
 194                  * this is reliable, but not clean.
 195                  */
 196
 197                 if (!jack_port_type_get_buffer_size) {
 198                         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 199                 }
 200
 201                 _processed_frames = 0;
 202                 last_monitor_check = 0;
 203
 204                 set_jack_callbacks ();
 205
 206                 if (jack_activate (_priv_jack) == 0) {
 207                         _running = true;
 208                         _has_run = true;
 209                         Running(); /* EMIT SIGNAL */
 210                 } else {
 211                         // error << _("cannot activate JACK client") << endmsg;
 212                 }
 213         }
 214
 215         return _running ? 0 : -1;
 216 }
 217
 218 int
 219 AudioEngine::stop (bool forever)
 220 {
 221         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 222
 223         if (_priv_jack) {
 224                 if (forever) {
 225                         disconnect_from_jack ();
 226                 } else {
 227                         jack_deactivate (_priv_jack);
 228                         Stopped(); /* EMIT SIGNAL */
 229                         MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
 230                 }
 231         }
 232
 233         if (forever) {
 234                 stop_metering_thread ();
 235         }
 236
 237         return _running ? -1 : 0;
 238 }
 239
 240
 241 bool
 242 AudioEngine::get_sync_offset (pframes_t& offset) const
 243 {
 244
 245 #ifdef HAVE_JACK_VIDEO_SUPPORT
 246
 247         GET_PRIVATE_JACK_POINTER_RET (_jack, false);
 248
 249         jack_position_t pos;
 250
 251         if (_priv_jack) {
 252                 (void) jack_transport_query (_priv_jack, &pos);
 253
 254                 if (pos.valid & JackVideoFrameOffset) {
 255                         offset = pos.video_offset;
 256                         return true;
 257                 }
 258         }
 259 #else
 260         /* keep gcc happy */
 261         offset = 0;
 262 #endif
 263
 264         return false;
 265 }
 266
 267 void
 268 AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 269                                       jack_position_t* pos, int new_position, void *arg)
 270 {
 271         static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 272 }
 273
 274 void
 275 AudioEngine::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 276                                      jack_position_t* pos, int new_position)
 277 {
 278         if (_jack && _session && _session->synced_to_jack()) {
 279                 _session->jack_timebase_callback (state, nframes, pos, new_position);
 280         }
 281 }
 282
 283 int
 284 AudioEngine::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 285 {
 286         return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
 287 }
 288
 289 int
 290 AudioEngine::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 291 {
 292         if (_jack && _session) {
 293                 return _session->jack_sync_callback (state, pos);
 294         }
 295
 296         return true;
 297 }
 298
 299 int
 300 AudioEngine::_xrun_callback (void *arg)
 301 {
 302         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 303         if (ae->connected()) {
 304                 ae->Xrun (); /* EMIT SIGNAL */
 305         }
 306         return 0;
 307 }
 308
 309 #ifdef HAVE_JACK_SESSION
 310 void
 311 AudioEngine::_session_callback (jack_session_event_t *event, void *arg)
 312 {
 313         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 314         if (ae->connected()) {
 315                 ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
 316         }
 317 }
 318 #endif
 319
 320 int
 321 AudioEngine::_graph_order_callback (void *arg)
 322 {
 323         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 324
 325         if (ae->connected() && !ae->port_remove_in_progress) {
 326                 ae->GraphReordered (); /* EMIT SIGNAL */
 327         }
 328
 329         return 0;
 330 }
 331
 332 void*
 333 AudioEngine::_process_thread (void *arg)
 334 {
 335         return static_cast<AudioEngine *> (arg)->process_thread ();
 336 }
 337
 338 void
 339 AudioEngine::_freewheel_callback (int onoff, void *arg)
 340 {
 341         static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
 342 }
 343
 344 void
 345 AudioEngine::freewheel_callback (int onoff)
 346 {
 347         _freewheeling = onoff;
 348
 349         if (onoff) {
 350                 _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
 351                 MIDI::Manager::instance()->mmc()->enable_send (false);
 352         } else {
 353                 MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
 354         }
 355 }
 356
 357 void
 358 AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
 359 {
 360         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 361
 362         if (!ae->port_remove_in_progress) {
 363                 ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
 364         }
 365 }
 366
 367 void
 368 AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 369 {
 370         return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
 371 }
 372
 373 void
 374 AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
 375 {
 376         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 377
 378         if (ae->port_remove_in_progress) {
 379                 return;
 380         }
 381
 382         GET_PRIVATE_JACK_POINTER (ae->_jack);
 383
 384         jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
 385         jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
 386
 387         boost::shared_ptr<Port> port_a;
 388         boost::shared_ptr<Port> port_b;
 389
 390         boost::shared_ptr<Ports> pr = ae->ports.reader ();
 391         Ports::iterator i = pr->begin ();
 392         while (i != pr->end() && (port_a == 0 || port_b == 0)) {
 393                 if (jack_port_a == i->second->jack_port()) {
 394                         port_a = i->second;
 395                 } else if (jack_port_b == i->second->jack_port()) {
 396                         port_b = i->second;
 397                 }
 398                 ++i;
 399         }
 400
 401         ae->PortConnectedOrDisconnected (
 402                 port_a, jack_port_name (jack_port_a),
 403                 port_b, jack_port_name (jack_port_b),
 404                 conn == 0 ? false : true
 405                 ); /* EMIT SIGNAL */
 406 }
 407
 408 void
 409 AudioEngine::split_cycle (pframes_t offset)
 410 {
 411         /* caller must hold process lock */
 412
 413         Port::increment_global_port_buffer_offset (offset);
 414
 415         /* tell all Ports that we're going to start a new (split) cycle */
 416
 417         boost::shared_ptr<Ports> p = ports.reader();
 418
 419         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 420                 i->second->cycle_split ();
 421         }
 422 }
 423
 424 void*
 425 AudioEngine::process_thread ()
 426 {
 427         /* JACK doesn't do this for us when we use the wait API
 428          */
 429
 430         _thread_init_callback (0);
 431
 432         _main_thread = new ProcessThread;
 433
 434         while (1) {
 435                 GET_PRIVATE_JACK_POINTER_RET(_jack,0);
 436
 437                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 438
 439                 if (process_callback (nframes)) {
 440                         return 0;
 441                 }
 442
 443                 jack_cycle_signal (_priv_jack, 0);
 444         }
 445
 446         return 0;
 447 }
 448
 449 /** Method called by our ::process_thread when there is work to be done.
 450  *  @param nframes Number of frames to process.
 451  */
 452 int
 453 AudioEngine::process_callback (pframes_t nframes)
 454 {
 455         GET_PRIVATE_JACK_POINTER_RET(_jack,0);
 456         Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK);
 457
 458         PT_TIMING_REF;
 459         PT_TIMING_CHECK (1);
 460
 461         /// The number of frames that will have been processed when we've finished
 462         pframes_t next_processed_frames;
 463
 464         /* handle wrap around of total frames counter */
 465
 466         if (max_framepos - _processed_frames < nframes) {
 467                 next_processed_frames = nframes - (max_framepos - _processed_frames);
 468         } else {
 469                 next_processed_frames = _processed_frames + nframes;
 470         }
 471
 472         if (!tm.locked()) {
 473                 /* return having done nothing */
 474                 _processed_frames = next_processed_frames;
 475                 return 0;
 476         }
 477
 478         if (_session == 0) {
 479                 if (!_freewheeling) {
 480                         MIDI::Manager::instance()->cycle_start(nframes);
 481                         MIDI::Manager::instance()->cycle_end();
 482                 }
 483                 _processed_frames = next_processed_frames;
 484                 return 0;
 485         }
 486
 487         if (session_remove_pending) {
 488                 /* perform the actual session removal */
 489                 _session = 0;
 490                 session_remove_pending = false;
 491                 session_removed.signal();
 492                 _processed_frames = next_processed_frames;
 493                 return 0;
 494         }
 495
 496         /* tell all relevant objects that we're starting a new cycle */
 497
 498         InternalSend::CycleStart (nframes);
 499         Port::set_global_port_buffer_offset (0);
 500         Port::set_cycle_framecnt (nframes);
 501
 502         /* tell all Ports that we're starting a new cycle */
 503
 504         boost::shared_ptr<Ports> p = ports.reader();
 505
 506         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 507                 i->second->cycle_start (nframes);
 508         }
 509
 510         /* test if we are freewheeling and there are freewheel signals connected.
 511            ardour should act normally even when freewheeling unless /it/ is exporting */
 512
 513
 514         if (_freewheeling && !Freewheel.empty()) {
 515                 /* emit the Freewheel signal and stop freewheeling in the event of trouble
 516                  */
 517                 boost::optional<int> r = Freewheel (nframes);
 518                 if (r.get_value_or (0)) {
 519                         jack_set_freewheel (_priv_jack, false);
 520                 }
 521
 522         } else {
 523                 MIDI::Manager::instance()->cycle_start(nframes);
 524
 525                 if (_session) {
 526                         _session->process (nframes);
 527                 }
 528
 529                 MIDI::Manager::instance()->cycle_end();
 530         }
 531
 532         if (_freewheeling) {
 533                 return 0;
 534         }
 535
 536         if (!_running) {
 537                 _processed_frames = next_processed_frames;
 538                 return 0;
 539         }
 540
 541         if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 542
 543                 boost::shared_ptr<Ports> p = ports.reader();
 544
 545                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 546
 547                         bool x;
 548
 549                         if (i->second->last_monitor() != (x = i->second->jack_monitoring_input ())) {
 550                                 i->second->set_last_monitor (x);
 551                                 /* XXX I think this is dangerous, due to
 552                                    a likely mutex in the signal handlers ...
 553                                 */
 554                                 i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
 555                         }
 556                 }
 557                 last_monitor_check = next_processed_frames;
 558         }
 559
 560         if (_session->silent()) {
 561
 562                 boost::shared_ptr<Ports> p = ports.reader();
 563
 564                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 565
 566                         if (i->second->sends_output()) {
 567                                 i->second->get_buffer(nframes).silence(nframes);
 568                         }
 569                 }
 570         }
 571
 572         // Finalize ports
 573
 574         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 575                 i->second->cycle_end (nframes);
 576         }
 577
 578         _processed_frames = next_processed_frames;
 579
 580         PT_TIMING_CHECK (2);
 581
 582         return 0;
 583 }
 584
 585 int
 586 AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
 587 {
 588         return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
 589 }
 590
 591 int
 592 AudioEngine::jack_sample_rate_callback (pframes_t nframes)
 593 {
 594         _frame_rate = nframes;
 595         _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
 596
 597         /* check for monitor input change every 1/10th of second */
 598
 599         monitor_check_interval = nframes / 10;
 600         last_monitor_check = 0;
 601
 602         if (_session) {
 603                 _session->set_frame_rate (nframes);
 604         }
 605
 606         SampleRateChanged (nframes); /* EMIT SIGNAL */
 607
 608         return 0;
 609 }
 610
 611 void
 612 AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
 613 {
 614         if (_session) {
 615                 _session->update_latency (mode == JackPlaybackLatency);
 616         }
 617 }
 618
 619 int
 620 AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
 621 {
 622         return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
 623 }
 624
 625 int
 626 AudioEngine::jack_bufsize_callback (pframes_t nframes)
 627 {
 628         /* if the size has not changed, this should be a no-op */
 629
 630         if (nframes == _buffer_size) {
 631                 return 0;
 632         }
 633
 634         GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
 635
 636         _buffer_size = nframes;
 637         _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
 638         last_monitor_check = 0;
 639
 640         if (jack_port_type_get_buffer_size) {
 641                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 642                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 643         } else {
 644
 645                 /* Old version of JACK.
 646
 647                    These crude guesses, see below where we try to get the right answers.
 648
 649                    Note that our guess for MIDI deliberatey tries to overestimate
 650                    by a little. It would be nicer if we could get the actual
 651                    size from a port, but we have to use this estimate in the
 652                    event that there are no MIDI ports currently. If there are
 653                    the value will be adjusted below.
 654                 */
 655
 656                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 657                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 658         }
 659
 660         {
 661                 Glib::Mutex::Lock lm (_process_lock);
 662
 663                 boost::shared_ptr<Ports> p = ports.reader();
 664
 665                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 666                         i->second->reset();
 667                 }
 668         }
 669
 670         if (_session) {
 671                 _session->set_block_size (_buffer_size);
 672         }
 673
 674         return 0;
 675 }
 676
 677 void
 678 AudioEngine::stop_metering_thread ()
 679 {
 680         if (m_meter_thread) {
 681                 g_atomic_int_set (&m_meter_exit, 1);
 682                 m_meter_thread->join ();
 683                 m_meter_thread = 0;
 684         }
 685 }
 686
 687 void
 688 AudioEngine::start_metering_thread ()
 689 {
 690         if (m_meter_thread == 0) {
 691                 g_atomic_int_set (&m_meter_exit, 0);
 692                 m_meter_thread = Glib::Thread::create (boost::bind (&AudioEngine::meter_thread, this),
 693                                                        500000, true, true, Glib::THREAD_PRIORITY_NORMAL);
 694         }
 695 }
 696
 697 void
 698 AudioEngine::meter_thread ()
 699 {
 700         pthread_set_name (X_("meter"));
 701
 702         while (true) {
 703                 Glib::usleep (10000); /* 1/100th sec interval */
 704                 if (g_atomic_int_get(&m_meter_exit)) {
 705                         break;
 706                 }
 707                 Metering::Meter ();
 708         }
 709 }
 710
 711 void
 712 AudioEngine::set_session (Session *s)
 713 {
 714         Glib::Mutex::Lock pl (_process_lock);
 715
 716         SessionHandlePtr::set_session (s);
 717
 718         if (_session) {
 719
 720                 start_metering_thread ();
 721
 722                 pframes_t blocksize = jack_get_buffer_size (_jack);
 723
 724                 /* page in as much of the session process code as we
 725                    can before we really start running.
 726                 */
 727
 728                 boost::shared_ptr<Ports> p = ports.reader();
 729
 730                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 731                         i->second->cycle_start (blocksize);
 732                 }
 733
 734                 _session->process (blocksize);
 735                 _session->process (blocksize);
 736                 _session->process (blocksize);
 737                 _session->process (blocksize);
 738                 _session->process (blocksize);
 739                 _session->process (blocksize);
 740                 _session->process (blocksize);
 741                 _session->process (blocksize);
 742
 743                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 744                         i->second->cycle_end (blocksize);
 745                 }
 746         }
 747 }
 748
 749 void
 750 AudioEngine::remove_session ()
 751 {
 752         Glib::Mutex::Lock lm (_process_lock);
 753
 754         if (_running) {
 755
 756                 stop_metering_thread ();
 757
 758                 if (_session) {
 759                         session_remove_pending = true;
 760                         session_removed.wait(_process_lock);
 761                 }
 762
 763         } else {
 764                 SessionHandlePtr::set_session (0);
 765         }
 766
 767         remove_all_ports ();
 768 }
 769
 770 void
 771 AudioEngine::port_registration_failure (const std::string& portname)
 772 {
 773         GET_PRIVATE_JACK_POINTER (_jack);
 774         string full_portname = jack_client_name;
 775         full_portname += ':';
 776         full_portname += portname;
 777
 778
 779         jack_port_t* p = jack_port_by_name (_priv_jack, full_portname.c_str());
 780         string reason;
 781
 782         if (p) {
 783                 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
 784         } else {
 785                 reason = string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME);
 786         }
 787
 788         throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
 789 }
 790
 791 boost::shared_ptr<Port>
 792 AudioEngine::register_port (DataType dtype, const string& portname, bool input)
 793 {
 794         boost::shared_ptr<Port> newport;
 795
 796         try {
 797                 if (dtype == DataType::AUDIO) {
 798                         newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 799                 } else if (dtype == DataType::MIDI) {
 800                         newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 801                 } else {
 802                         throw PortRegistrationFailure("unable to create port (unknown type)");
 803                 }
 804
 805                 RCUWriter<Ports> writer (ports);
 806                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 807                 ps->insert (make_pair (make_port_name_relative (portname), newport));
 808
 809                 /* writer goes out of scope, forces update */
 810
 811                 return newport;
 812         }
 813
 814         catch (PortRegistrationFailure& err) {
 815                 throw err;
 816         } catch (std::exception& e) {
 817                 throw PortRegistrationFailure(string_compose(
 818                                 _("unable to create port: %1"), e.what()).c_str());
 819         } catch (...) {
 820                 throw PortRegistrationFailure("unable to create port (unknown error)");
 821         }
 822 }
 823
 824 boost::shared_ptr<Port>
 825 AudioEngine::register_input_port (DataType type, const string& portname)
 826 {
 827         return register_port (type, portname, true);
 828 }
 829
 830 boost::shared_ptr<Port>
 831 AudioEngine::register_output_port (DataType type, const string& portname)
 832 {
 833         return register_port (type, portname, false);
 834 }
 835
 836 int
 837 AudioEngine::unregister_port (boost::shared_ptr<Port> port)
 838 {
 839         /* caller must hold process lock */
 840
 841         if (!_running) {
 842                 /* probably happening when the engine has been halted by JACK,
 843                    in which case, there is nothing we can do here.
 844                    */
 845                 return 0;
 846         }
 847
 848         {
 849                 RCUWriter<Ports> writer (ports);
 850                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 851                 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
 852
 853                 if (x != ps->end()) {
 854                         ps->erase (x);
 855                 }
 856
 857                 /* writer goes out of scope, forces update */
 858         }
 859
 860         ports.flush ();
 861
 862         return 0;
 863 }
 864
 865 int
 866 AudioEngine::connect (const string& source, const string& destination)
 867 {
 868         int ret;
 869
 870         if (!_running) {
 871                 if (!_has_run) {
 872                         fatal << _("connect called before engine was started") << endmsg;
 873                         /*NOTREACHED*/
 874                 } else {
 875                         return -1;
 876                 }
 877         }
 878
 879         string s = make_port_name_non_relative (source);
 880         string d = make_port_name_non_relative (destination);
 881
 882
 883         boost::shared_ptr<Port> src = get_port_by_name (s);
 884         boost::shared_ptr<Port> dst = get_port_by_name (d);
 885
 886         if (src) {
 887                 ret = src->connect (d);
 888         } else if (dst) {
 889                 ret = dst->connect (s);
 890         } else {
 891                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 892                 ret = -1;
 893         }
 894
 895         if (ret > 0) {
 896                 /* already exists - no error, no warning */
 897         } else if (ret < 0) {
 898                 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
 899                                         source, s, destination, d)
 900                       << endmsg;
 901         }
 902
 903         return ret;
 904 }
 905
 906 int
 907 AudioEngine::disconnect (const string& source, const string& destination)
 908 {
 909         int ret;
 910
 911         if (!_running) {
 912                 if (!_has_run) {
 913                         fatal << _("disconnect called before engine was started") << endmsg;
 914                         /*NOTREACHED*/
 915                 } else {
 916                         return -1;
 917                 }
 918         }
 919
 920         string s = make_port_name_non_relative (source);
 921         string d = make_port_name_non_relative (destination);
 922
 923         boost::shared_ptr<Port> src = get_port_by_name (s);
 924         boost::shared_ptr<Port> dst = get_port_by_name (d);
 925
 926         if (src) {
 927                         ret = src->disconnect (d);
 928         } else if (dst) {
 929                         ret = dst->disconnect (s);
 930         } else {
 931                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 932                 ret = -1;
 933         }
 934         return ret;
 935 }
 936
 937 int
 938 AudioEngine::disconnect (boost::shared_ptr<Port> port)
 939 {
 940         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
 941
 942         if (!_running) {
 943                 if (!_has_run) {
 944                         fatal << _("disconnect called before engine was started") << endmsg;
 945                         /*NOTREACHED*/
 946                 } else {
 947                         return -1;
 948                 }
 949         }
 950
 951         return port->disconnect_all ();
 952 }
 953
 954 ARDOUR::framecnt_t
 955 AudioEngine::frame_rate () const
 956 {
 957         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 958         if (_frame_rate == 0) {
 959                 return (_frame_rate = jack_get_sample_rate (_priv_jack));
 960         } else {
 961                 return _frame_rate;
 962         }
 963 }
 964
 965 size_t
 966 AudioEngine::raw_buffer_size (DataType t)
 967 {
 968         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 969         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 970 }
 971
 972 ARDOUR::pframes_t
 973 AudioEngine::frames_per_cycle () const
 974 {
 975         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
 976         if (_buffer_size == 0) {
 977                 return jack_get_buffer_size (_jack);
 978         } else {
 979                 return _buffer_size;
 980         }
 981 }
 982
 983 /** @param name Full or short name of port
 984  *  @return Corresponding Port or 0.
 985  */
 986
 987 boost::shared_ptr<Port>
 988 AudioEngine::get_port_by_name (const string& portname)
 989 {
 990         if (!_running) {
 991                 if (!_has_run) {
 992                         fatal << _("get_port_by_name() called before engine was started") << endmsg;
 993                         /*NOTREACHED*/
 994                 } else {
 995                         boost::shared_ptr<Port> ();
 996                 }
 997         }
 998
 999         if (!port_is_mine (portname)) {
1000                 /* not an ardour port */
1001                 return boost::shared_ptr<Port> ();
1002         }
1003
1004         boost::shared_ptr<Ports> pr = ports.reader();
1005         std::string rel = make_port_name_relative (portname);
1006         Ports::iterator x = pr->find (rel);
1007
1008         if (x != pr->end()) {
1009                 /* its possible that the port was renamed by some 3rd party and
1010                    we don't know about it. check for this (the check is quick
1011                    and cheap), and if so, rename the port (which will alter
1012                    the port map as a side effect).
1013                 */
1014                 const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port()));
1015                 if (check != rel) {
1016                         x->second->set_name (check);
1017                 }
1018                 return x->second;
1019         }
1020
1021         return boost::shared_ptr<Port> ();
1022 }
1023
1024 void
1025 AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
1026 {
1027         RCUWriter<Ports> writer (ports);
1028         boost::shared_ptr<Ports> p = writer.get_copy();
1029         Ports::iterator x = p->find (old_relative_name);
1030
1031         if (x != p->end()) {
1032                 boost::shared_ptr<Port> port = x->second;
1033                 p->erase (x);
1034                 p->insert (make_pair (new_relative_name, port));
1035         }
1036 }
1037
1038 const char **
1039 AudioEngine::get_ports (const string& port_name_pattern, const string& type_name_pattern, uint32_t flags)
1040 {
1041         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1042         if (!_running) {
1043                 if (!_has_run) {
1044                         fatal << _("get_ports called before engine was started") << endmsg;
1045                         /*NOTREACHED*/
1046                 } else {
1047                         return 0;
1048                 }
1049         }
1050         return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
1051 }
1052
1053 void
1054 AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
1055 {
1056         /* called from jack shutdown handler  */
1057
1058         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1059         bool was_running = ae->_running;
1060
1061         ae->stop_metering_thread ();
1062
1063         ae->_running = false;
1064         ae->_buffer_size = 0;
1065         ae->_frame_rate = 0;
1066         ae->_jack = 0;
1067
1068         if (was_running) {
1069 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
1070                 switch (code) {
1071                 case JackBackendError:
1072                         ae->Halted(reason); /* EMIT SIGNAL */
1073                         break;
1074                 default:
1075                         ae->Halted(""); /* EMIT SIGNAL */
1076                 }
1077 #else
1078                 ae->Halted(""); /* EMIT SIGNAL */
1079 #endif
1080         }
1081 }
1082
1083 void
1084 AudioEngine::halted (void *arg)
1085 {
1086         cerr << "HALTED by JACK\n";
1087
1088         /* called from jack shutdown handler  */
1089
1090         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1091         bool was_running = ae->_running;
1092
1093         ae->stop_metering_thread ();
1094
1095         ae->_running = false;
1096         ae->_buffer_size = 0;
1097         ae->_frame_rate = 0;
1098         ae->_jack = 0;
1099
1100         if (was_running) {
1101                 ae->Halted(""); /* EMIT SIGNAL */
1102                 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
1103         }
1104 }
1105
1106 void
1107 AudioEngine::died ()
1108 {
1109         /* called from a signal handler for SIGPIPE */
1110
1111         stop_metering_thread ();
1112
1113         _running = false;
1114         _buffer_size = 0;
1115         _frame_rate = 0;
1116         _jack = 0;
1117 }
1118
1119 bool
1120 AudioEngine::can_request_hardware_monitoring ()
1121 {
1122         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1123         const char ** ports;
1124
1125         if ((ports = jack_get_ports (_priv_jack, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortCanMonitor)) == 0) {
1126                 return false;
1127         }
1128
1129         free (ports);
1130
1131         return true;
1132 }
1133
1134 ChanCount
1135 AudioEngine::n_physical (unsigned long flags) const
1136 {
1137         ChanCount c;
1138
1139         GET_PRIVATE_JACK_POINTER_RET (_jack, c);
1140
1141         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1142         if (ports == 0) {
1143                 return c;
1144         }
1145
1146         for (uint32_t i = 0; ports[i]; ++i) {
1147                 if (!strstr (ports[i], "Midi-Through")) {
1148                         DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
1149                         c.set (t, c.get (t) + 1);
1150                 }
1151         }
1152
1153         free (ports);
1154
1155         return c;
1156 }
1157
1158 ChanCount
1159 AudioEngine::n_physical_inputs () const
1160 {
1161         return n_physical (JackPortIsInput);
1162 }
1163
1164 ChanCount
1165 AudioEngine::n_physical_outputs () const
1166 {
1167         return n_physical (JackPortIsOutput);
1168 }
1169
1170 void
1171 AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
1172 {
1173         GET_PRIVATE_JACK_POINTER (_jack);
1174         const char ** ports;
1175
1176         if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
1177                 return;
1178         }
1179
1180         if (ports) {
1181                 for (uint32_t i = 0; ports[i]; ++i) {
1182                         if (strstr (ports[i], "Midi-Through")) {
1183                                 continue;
1184                         }
1185                         phy.push_back (ports[i]);
1186                 }
1187                 free (ports);
1188         }
1189 }
1190
1191 /** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
1192  *  a physical input connector.
1193  */
1194 void
1195 AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
1196 {
1197         get_physical (type, JackPortIsOutput, ins);
1198 }
1199
1200 /** Get physical ports for which JackPortIsInput is set; ie those that correspond to
1201  *  a physical output connector.
1202  */
1203 void
1204 AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
1205 {
1206         get_physical (type, JackPortIsInput, outs);
1207 }
1208
1209 void
1210 AudioEngine::transport_stop ()
1211 {
1212         GET_PRIVATE_JACK_POINTER (_jack);
1213         jack_transport_stop (_priv_jack);
1214 }
1215
1216 void
1217 AudioEngine::transport_start ()
1218 {
1219         GET_PRIVATE_JACK_POINTER (_jack);
1220         jack_transport_start (_priv_jack);
1221 }
1222
1223 void
1224 AudioEngine::transport_locate (framepos_t where)
1225 {
1226         GET_PRIVATE_JACK_POINTER (_jack);
1227         jack_transport_locate (_priv_jack, where);
1228 }
1229
1230 AudioEngine::TransportState
1231 AudioEngine::transport_state ()
1232 {
1233         GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
1234         jack_position_t pos;
1235         return (TransportState) jack_transport_query (_priv_jack, &pos);
1236 }
1237
1238 int
1239 AudioEngine::reset_timebase ()
1240 {
1241         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1242         if (_session) {
1243                 if (_session->config.get_jack_time_master()) {
1244                         return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
1245                 } else {
1246                         return jack_release_timebase (_jack);
1247                 }
1248         }
1249         return 0;
1250 }
1251
1252 int
1253 AudioEngine::freewheel (bool onoff)
1254 {
1255         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1256
1257         if (onoff != _freewheeling) {
1258                 return jack_set_freewheel (_priv_jack, onoff);
1259
1260         } else {
1261                 /* already doing what has been asked for */
1262                 return 0;
1263         }
1264 }
1265
1266 void
1267 AudioEngine::remove_all_ports ()
1268 {
1269         /* make sure that JACK callbacks that will be invoked as we cleanup
1270          * ports know that they have nothing to do.
1271          */
1272
1273         port_remove_in_progress = true;
1274
1275         /* process lock MUST be held by caller
1276         */
1277
1278         {
1279                 RCUWriter<Ports> writer (ports);
1280                 boost::shared_ptr<Ports> ps = writer.get_copy ();
1281                 ps->clear ();
1282         }
1283
1284         /* clear dead wood list in RCU */
1285
1286         ports.flush ();
1287
1288         port_remove_in_progress = false;
1289 }
1290
1291 int
1292 AudioEngine::connect_to_jack (string client_name, string session_uuid)
1293 {
1294         EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
1295         boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
1296         jack_status_t status;
1297
1298         /* revert all environment settings back to whatever they were when ardour started
1299          */
1300
1301         if (global_epa) {
1302                 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
1303                 global_epa->restore ();
1304         }
1305
1306         jack_client_name = client_name; /* might be reset below */
1307 #ifdef HAVE_JACK_SESSION
1308         if (! session_uuid.empty())
1309             _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
1310         else
1311 #endif
1312         _jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0);
1313
1314         if (_jack == NULL) {
1315                 // error message is not useful here
1316                 return -1;
1317         }
1318
1319         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1320
1321         if (status & JackNameNotUnique) {
1322                 jack_client_name = jack_get_client_name (_priv_jack);
1323         }
1324
1325         return 0;
1326 }
1327
1328 int
1329 AudioEngine::disconnect_from_jack ()
1330 {
1331         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1332
1333         if (_running) {
1334                 stop_metering_thread ();
1335         }
1336
1337         {
1338                 Glib::Mutex::Lock lm (_process_lock);
1339                 jack_client_close (_priv_jack);
1340                 _jack = 0;
1341         }
1342
1343         _buffer_size = 0;
1344         _frame_rate = 0;
1345         _raw_buffer_sizes.clear();
1346
1347         if (_running) {
1348                 _running = false;
1349                 Stopped(); /* EMIT SIGNAL */
1350                 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
1351         }
1352
1353         return 0;
1354 }
1355
1356 int
1357 AudioEngine::reconnect_to_jack ()
1358 {
1359         if (_running) {
1360                 disconnect_from_jack ();
1361                 /* XXX give jackd a chance */
1362                 Glib::usleep (250000);
1363         }
1364
1365         if (connect_to_jack (jack_client_name, "")) {
1366                 error << _("failed to connect to JACK") << endmsg;
1367                 return -1;
1368         }
1369
1370         Ports::iterator i;
1371
1372         boost::shared_ptr<Ports> p = ports.reader ();
1373
1374         for (i = p->begin(); i != p->end(); ++i) {
1375                 if (i->second->reestablish ()) {
1376                         break;
1377                 }
1378         }
1379
1380         if (i != p->end()) {
1381                 /* failed */
1382                 remove_all_ports ();
1383                 return -1;
1384         }
1385
1386         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1387
1388         MIDI::Manager::instance()->reestablish (_priv_jack);
1389
1390         if (_session) {
1391                 _session->reset_jack_connection (_priv_jack);
1392                 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
1393                 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
1394         }
1395
1396         last_monitor_check = 0;
1397
1398         set_jack_callbacks ();
1399
1400         if (jack_activate (_priv_jack) == 0) {
1401                 _running = true;
1402                 _has_run = true;
1403         } else {
1404                 return -1;
1405         }
1406
1407         /* re-establish connections */
1408
1409         for (i = p->begin(); i != p->end(); ++i) {
1410                 i->second->reconnect ();
1411         }
1412
1413         MIDI::Manager::instance()->reconnect ();
1414
1415         Running (); /* EMIT SIGNAL*/
1416
1417         start_metering_thread ();
1418
1419         return 0;
1420 }
1421
1422 int
1423 AudioEngine::request_buffer_size (pframes_t nframes)
1424 {
1425         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1426
1427         if (nframes == jack_get_buffer_size (_priv_jack)) {
1428                 return 0;
1429         }
1430
1431         return jack_set_buffer_size (_priv_jack, nframes);
1432 }
1433
1434 string
1435 AudioEngine::make_port_name_relative (string portname) const
1436 {
1437         string::size_type len;
1438         string::size_type n;
1439
1440         len = portname.length();
1441
1442         for (n = 0; n < len; ++n) {
1443                 if (portname[n] == ':') {
1444                         break;
1445                 }
1446         }
1447
1448         if ((n != len) && (portname.substr (0, n) == jack_client_name)) {
1449                 return portname.substr (n+1);
1450         }
1451
1452         return portname;
1453 }
1454
1455 string
1456 AudioEngine::make_port_name_non_relative (string portname) const
1457 {
1458         string str;
1459
1460         if (portname.find_first_of (':') != string::npos) {
1461                 return portname;
1462         }
1463
1464         str  = jack_client_name;
1465         str += ':';
1466         str += portname;
1467
1468         return str;
1469 }
1470
1471 bool
1472 AudioEngine::port_is_mine (const string& portname) const
1473 {
1474         if (portname.find_first_of (':') != string::npos) {
1475                 if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
1476                         return false;
1477                 }
1478         }
1479         return true;
1480 }
1481
1482 bool
1483 AudioEngine::is_realtime () const
1484 {
1485         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1486         return jack_is_realtime (_priv_jack);
1487 }
1488
1489 int
1490 AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
1491 {
1492         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1493         ThreadData* td = new ThreadData (this, f, stacksize);
1494
1495         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
1496                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
1497                 return -1;
1498         }
1499
1500         return 0;
1501 }
1502
1503 void*
1504 AudioEngine::_start_process_thread (void* arg)
1505 {
1506         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
1507         boost::function<void()> f = td->f;
1508         delete td;
1509
1510         f ();
1511
1512         return 0;
1513 }
1514
1515 bool
1516 AudioEngine::port_is_physical (const std::string& portname) const
1517 {
1518         GET_PRIVATE_JACK_POINTER_RET(_jack, false);
1519
1520         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1521
1522         if (!port) {
1523                 return false;
1524         }
1525
1526         return jack_port_flags (port) & JackPortIsPhysical;
1527 }
1528
1529 void
1530 AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
1531 {
1532         GET_PRIVATE_JACK_POINTER(_jack);
1533
1534         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1535
1536         if (!port) {
1537                 return;
1538         }
1539
1540         jack_port_request_monitor (port, yn);
1541 }
1542
1543 void
1544 AudioEngine::update_latencies ()
1545 {
1546         if (jack_recompute_total_latencies) {
1547                 GET_PRIVATE_JACK_POINTER (_jack);
1548                 jack_recompute_total_latencies (_priv_jack);
1549         }
1550 }
1551
1552 void
1553 AudioEngine::destroy ()
1554 {
1555         delete _instance;
1556         _instance = 0;
1557 }