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