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() || _session == 0) {
 480                 /* return having done nothing */
 481                 _processed_frames = next_processed_frames;
 482                 return 0;
 483         }
 484
 485         if (session_remove_pending) {
 486                 /* perform the actual session removal */
 487                 _session = 0;
 488                 session_remove_pending = false;
 489                 session_removed.signal();
 490                 _processed_frames = next_processed_frames;
 491                 return 0;
 492         }
 493
 494         /* tell all relevant objects that we're starting a new cycle */
 495
 496         InternalSend::CycleStart (nframes);
 497         Port::set_global_port_buffer_offset (0);
 498         Port::set_cycle_framecnt (nframes);
 499
 500         /* tell all Ports that we're starting a new cycle */
 501
 502         boost::shared_ptr<Ports> p = ports.reader();
 503
 504         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 505                 i->second->cycle_start (nframes);
 506         }
 507
 508         /* test if we are freewheeling and there are freewheel signals connected.
 509            ardour should act normally even when freewheeling unless /it/ is exporting */
 510
 511
 512         if (_freewheeling && !Freewheel.empty()) {
 513                 /* emit the Freewheel signal and stop freewheeling in the event of trouble
 514                  */
 515                 boost::optional<int> r = Freewheel (nframes);
 516                 if (r.get_value_or (0)) {
 517                         jack_set_freewheel (_priv_jack, false);
 518                 }
 519
 520         } else {
 521                 if (_session) {
 522                         _session->process (nframes);
 523                 }
 524         }
 525
 526         if (_freewheeling) {
 527                 return 0;
 528         }
 529
 530         if (!_running) {
 531                 _processed_frames = next_processed_frames;
 532                 return 0;
 533         }
 534
 535         if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 536
 537                 boost::shared_ptr<Ports> p = ports.reader();
 538
 539                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 540
 541                         bool x;
 542
 543                         if (i->second->last_monitor() != (x = i->second->jack_monitoring_input ())) {
 544                                 i->second->set_last_monitor (x);
 545                                 /* XXX I think this is dangerous, due to
 546                                    a likely mutex in the signal handlers ...
 547                                 */
 548                                 i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
 549                         }
 550                 }
 551                 last_monitor_check = next_processed_frames;
 552         }
 553
 554         if (_session->silent()) {
 555
 556                 boost::shared_ptr<Ports> p = ports.reader();
 557
 558                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 559
 560                         if (i->second->sends_output()) {
 561                                 i->second->get_buffer(nframes).silence(nframes);
 562                         }
 563                 }
 564         }
 565
 566         // Finalize ports
 567
 568         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 569                 i->second->cycle_end (nframes);
 570         }
 571
 572         _processed_frames = next_processed_frames;
 573
 574         PT_TIMING_CHECK (2);
 575
 576         return 0;
 577 }
 578
 579 int
 580 AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
 581 {
 582         return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
 583 }
 584
 585 int
 586 AudioEngine::jack_sample_rate_callback (pframes_t nframes)
 587 {
 588         _frame_rate = nframes;
 589         _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
 590
 591         /* check for monitor input change every 1/10th of second */
 592
 593         monitor_check_interval = nframes / 10;
 594         last_monitor_check = 0;
 595
 596         if (_session) {
 597                 _session->set_frame_rate (nframes);
 598         }
 599
 600         SampleRateChanged (nframes); /* EMIT SIGNAL */
 601
 602         return 0;
 603 }
 604
 605 void
 606 AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
 607 {
 608         if (_session) {
 609                 _session->update_latency (mode == JackPlaybackLatency);
 610         }
 611 }
 612
 613 int
 614 AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
 615 {
 616         return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
 617 }
 618
 619 int
 620 AudioEngine::jack_bufsize_callback (pframes_t nframes)
 621 {
 622         /* if the size has not changed, this should be a no-op */
 623
 624         if (nframes == _buffer_size) {
 625                 return 0;
 626         }
 627
 628         GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
 629
 630         _buffer_size = nframes;
 631         _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
 632         last_monitor_check = 0;
 633
 634         if (jack_port_type_get_buffer_size) {
 635                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 636                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 637         } else {
 638
 639                 /* Old version of JACK.
 640
 641                    These crude guesses, see below where we try to get the right answers.
 642
 643                    Note that our guess for MIDI deliberatey tries to overestimate
 644                    by a little. It would be nicer if we could get the actual
 645                    size from a port, but we have to use this estimate in the
 646                    event that there are no MIDI ports currently. If there are
 647                    the value will be adjusted below.
 648                 */
 649
 650                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 651                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 652         }
 653
 654         {
 655                 Glib::Mutex::Lock lm (_process_lock);
 656
 657                 boost::shared_ptr<Ports> p = ports.reader();
 658
 659                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 660                         i->second->reset();
 661                 }
 662         }
 663
 664         if (_session) {
 665                 _session->set_block_size (_buffer_size);
 666         }
 667
 668         return 0;
 669 }
 670
 671 void
 672 AudioEngine::stop_metering_thread ()
 673 {
 674         if (m_meter_thread) {
 675                 g_atomic_int_set (&m_meter_exit, 1);
 676                 m_meter_thread->join ();
 677                 m_meter_thread = 0;
 678         }
 679 }
 680
 681 void
 682 AudioEngine::start_metering_thread ()
 683 {
 684         if (m_meter_thread == 0) {
 685                 g_atomic_int_set (&m_meter_exit, 0);
 686                 m_meter_thread = Glib::Thread::create (boost::bind (&AudioEngine::meter_thread, this),
 687                                                        500000, true, true, Glib::THREAD_PRIORITY_NORMAL);
 688         }
 689 }
 690
 691 void
 692 AudioEngine::meter_thread ()
 693 {
 694         pthread_set_name (X_("meter"));
 695
 696         while (true) {
 697                 Glib::usleep (10000); /* 1/100th sec interval */
 698                 if (g_atomic_int_get(&m_meter_exit)) {
 699                         break;
 700                 }
 701                 Metering::Meter ();
 702         }
 703 }
 704
 705 void
 706 AudioEngine::set_session (Session *s)
 707 {
 708         Glib::Mutex::Lock pl (_process_lock);
 709
 710         SessionHandlePtr::set_session (s);
 711
 712         if (_session) {
 713
 714                 start_metering_thread ();
 715
 716                 pframes_t blocksize = jack_get_buffer_size (_jack);
 717
 718                 /* page in as much of the session process code as we
 719                    can before we really start running.
 720                 */
 721
 722                 boost::shared_ptr<Ports> p = ports.reader();
 723
 724                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 725                         i->second->cycle_start (blocksize);
 726                 }
 727
 728                 _session->process (blocksize);
 729                 _session->process (blocksize);
 730                 _session->process (blocksize);
 731                 _session->process (blocksize);
 732                 _session->process (blocksize);
 733                 _session->process (blocksize);
 734                 _session->process (blocksize);
 735                 _session->process (blocksize);
 736
 737                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 738                         i->second->cycle_end (blocksize);
 739                 }
 740         }
 741 }
 742
 743 void
 744 AudioEngine::remove_session ()
 745 {
 746         Glib::Mutex::Lock lm (_process_lock);
 747
 748         if (_running) {
 749
 750                 stop_metering_thread ();
 751
 752                 if (_session) {
 753                         session_remove_pending = true;
 754                         session_removed.wait(_process_lock);
 755                 }
 756
 757         } else {
 758                 SessionHandlePtr::set_session (0);
 759         }
 760
 761         remove_all_ports ();
 762 }
 763
 764 void
 765 AudioEngine::port_registration_failure (const std::string& portname)
 766 {
 767         GET_PRIVATE_JACK_POINTER (_jack);
 768         string full_portname = jack_client_name;
 769         full_portname += ':';
 770         full_portname += portname;
 771
 772
 773         jack_port_t* p = jack_port_by_name (_priv_jack, full_portname.c_str());
 774         string reason;
 775
 776         if (p) {
 777                 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
 778         } else {
 779                 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);
 780         }
 781
 782         throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
 783 }
 784
 785 boost::shared_ptr<Port>
 786 AudioEngine::register_port (DataType dtype, const string& portname, bool input)
 787 {
 788         boost::shared_ptr<Port> newport;
 789
 790         try {
 791                 if (dtype == DataType::AUDIO) {
 792                         newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 793                 } else if (dtype == DataType::MIDI) {
 794                         newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 795                 } else {
 796                         throw PortRegistrationFailure("unable to create port (unknown type)");
 797                 }
 798
 799                 RCUWriter<Ports> writer (ports);
 800                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 801                 ps->insert (make_pair (make_port_name_relative (portname), newport));
 802
 803                 /* writer goes out of scope, forces update */
 804
 805                 return newport;
 806         }
 807
 808         catch (PortRegistrationFailure& err) {
 809                 throw err;
 810         } catch (std::exception& e) {
 811                 throw PortRegistrationFailure(string_compose(
 812                                 _("unable to create port: %1"), e.what()).c_str());
 813         } catch (...) {
 814                 throw PortRegistrationFailure("unable to create port (unknown error)");
 815         }
 816 }
 817
 818 boost::shared_ptr<Port>
 819 AudioEngine::register_input_port (DataType type, const string& portname)
 820 {
 821         return register_port (type, portname, true);
 822 }
 823
 824 boost::shared_ptr<Port>
 825 AudioEngine::register_output_port (DataType type, const string& portname)
 826 {
 827         return register_port (type, portname, false);
 828 }
 829
 830 int
 831 AudioEngine::unregister_port (boost::shared_ptr<Port> port)
 832 {
 833         /* caller must hold process lock */
 834
 835         if (!_running) {
 836                 /* probably happening when the engine has been halted by JACK,
 837                    in which case, there is nothing we can do here.
 838                    */
 839                 return 0;
 840         }
 841
 842         {
 843                 RCUWriter<Ports> writer (ports);
 844                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 845                 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
 846
 847                 if (x != ps->end()) {
 848                         ps->erase (x);
 849                 }
 850
 851                 /* writer goes out of scope, forces update */
 852         }
 853
 854         ports.flush ();
 855
 856         return 0;
 857 }
 858
 859 int
 860 AudioEngine::connect (const string& source, const string& destination)
 861 {
 862         int ret;
 863
 864         if (!_running) {
 865                 if (!_has_run) {
 866                         fatal << _("connect called before engine was started") << endmsg;
 867                         /*NOTREACHED*/
 868                 } else {
 869                         return -1;
 870                 }
 871         }
 872
 873         string s = make_port_name_non_relative (source);
 874         string d = make_port_name_non_relative (destination);
 875
 876
 877         boost::shared_ptr<Port> src = get_port_by_name (s);
 878         boost::shared_ptr<Port> dst = get_port_by_name (d);
 879
 880         if (src) {
 881                 ret = src->connect (d);
 882         } else if (dst) {
 883                 ret = dst->connect (s);
 884         } else {
 885                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 886                 ret = -1;
 887         }
 888
 889         if (ret > 0) {
 890                 /* already exists - no error, no warning */
 891         } else if (ret < 0) {
 892                 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
 893                                         source, s, destination, d)
 894                       << endmsg;
 895         }
 896
 897         return ret;
 898 }
 899
 900 int
 901 AudioEngine::disconnect (const string& source, const string& destination)
 902 {
 903         int ret;
 904
 905         if (!_running) {
 906                 if (!_has_run) {
 907                         fatal << _("disconnect called before engine was started") << endmsg;
 908                         /*NOTREACHED*/
 909                 } else {
 910                         return -1;
 911                 }
 912         }
 913
 914         string s = make_port_name_non_relative (source);
 915         string d = make_port_name_non_relative (destination);
 916
 917         boost::shared_ptr<Port> src = get_port_by_name (s);
 918         boost::shared_ptr<Port> dst = get_port_by_name (d);
 919
 920         if (src) {
 921                         ret = src->disconnect (d);
 922         } else if (dst) {
 923                         ret = dst->disconnect (s);
 924         } else {
 925                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 926                 ret = -1;
 927         }
 928         return ret;
 929 }
 930
 931 int
 932 AudioEngine::disconnect (boost::shared_ptr<Port> port)
 933 {
 934         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
 935
 936         if (!_running) {
 937                 if (!_has_run) {
 938                         fatal << _("disconnect called before engine was started") << endmsg;
 939                         /*NOTREACHED*/
 940                 } else {
 941                         return -1;
 942                 }
 943         }
 944
 945         return port->disconnect_all ();
 946 }
 947
 948 ARDOUR::framecnt_t
 949 AudioEngine::frame_rate () const
 950 {
 951         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 952         if (_frame_rate == 0) {
 953                 return (_frame_rate = jack_get_sample_rate (_priv_jack));
 954         } else {
 955                 return _frame_rate;
 956         }
 957 }
 958
 959 size_t
 960 AudioEngine::raw_buffer_size (DataType t)
 961 {
 962         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 963         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 964 }
 965
 966 ARDOUR::pframes_t
 967 AudioEngine::frames_per_cycle () const
 968 {
 969         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
 970         if (_buffer_size == 0) {
 971                 return jack_get_buffer_size (_jack);
 972         } else {
 973                 return _buffer_size;
 974         }
 975 }
 976
 977 /** @param name Full or short name of port
 978  *  @return Corresponding Port or 0.
 979  */
 980
 981 boost::shared_ptr<Port>
 982 AudioEngine::get_port_by_name (const string& portname)
 983 {
 984         if (!_running) {
 985                 if (!_has_run) {
 986                         fatal << _("get_port_by_name() called before engine was started") << endmsg;
 987                         /*NOTREACHED*/
 988                 } else {
 989                         boost::shared_ptr<Port> ();
 990                 }
 991         }
 992
 993         if (!port_is_mine (portname)) {
 994                 /* not an ardour port */
 995                 return boost::shared_ptr<Port> ();
 996         }
 997
 998         boost::shared_ptr<Ports> pr = ports.reader();
 999         std::string rel = make_port_name_relative (portname);
1000         Ports::iterator x = pr->find (rel);
1001
1002         if (x != pr->end()) {
1003                 /* its possible that the port was renamed by some 3rd party and
1004                    we don't know about it. check for this (the check is quick
1005                    and cheap), and if so, rename the port (which will alter
1006                    the port map as a side effect).
1007                 */
1008                 const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port()));
1009                 if (check != rel) {
1010                         x->second->set_name (check);
1011                 }
1012                 return x->second;
1013         }
1014
1015         return boost::shared_ptr<Port> ();
1016 }
1017
1018 void
1019 AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
1020 {
1021         RCUWriter<Ports> writer (ports);
1022         boost::shared_ptr<Ports> p = writer.get_copy();
1023         Ports::iterator x = p->find (old_relative_name);
1024
1025         if (x != p->end()) {
1026                 boost::shared_ptr<Port> port = x->second;
1027                 p->erase (x);
1028                 p->insert (make_pair (new_relative_name, port));
1029         }
1030 }
1031
1032 const char **
1033 AudioEngine::get_ports (const string& port_name_pattern, const string& type_name_pattern, uint32_t flags)
1034 {
1035         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1036         if (!_running) {
1037                 if (!_has_run) {
1038                         fatal << _("get_ports called before engine was started") << endmsg;
1039                         /*NOTREACHED*/
1040                 } else {
1041                         return 0;
1042                 }
1043         }
1044         return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
1045 }
1046
1047 void
1048 AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
1049 {
1050         /* called from jack shutdown handler  */
1051
1052         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1053         bool was_running = ae->_running;
1054
1055         ae->stop_metering_thread ();
1056
1057         ae->_running = false;
1058         ae->_buffer_size = 0;
1059         ae->_frame_rate = 0;
1060         ae->_jack = 0;
1061
1062         if (was_running) {
1063 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
1064                 switch (code) {
1065                 case JackBackendError:
1066                         ae->Halted(reason); /* EMIT SIGNAL */
1067                         break;
1068                 default:
1069                         ae->Halted(""); /* EMIT SIGNAL */
1070                 }
1071 #else
1072                 ae->Halted(""); /* EMIT SIGNAL */
1073 #endif
1074         }
1075 }
1076
1077 void
1078 AudioEngine::halted (void *arg)
1079 {
1080         cerr << "HALTED by JACK\n";
1081
1082         /* called from jack shutdown handler  */
1083
1084         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1085         bool was_running = ae->_running;
1086
1087         ae->stop_metering_thread ();
1088
1089         ae->_running = false;
1090         ae->_buffer_size = 0;
1091         ae->_frame_rate = 0;
1092         ae->_jack = 0;
1093
1094         if (was_running) {
1095                 ae->Halted(""); /* EMIT SIGNAL */
1096                 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1097         }
1098 }
1099
1100 void
1101 AudioEngine::died ()
1102 {
1103         /* called from a signal handler for SIGPIPE */
1104
1105         stop_metering_thread ();
1106
1107         _running = false;
1108         _buffer_size = 0;
1109         _frame_rate = 0;
1110         _jack = 0;
1111 }
1112
1113 bool
1114 AudioEngine::can_request_hardware_monitoring ()
1115 {
1116         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1117         const char ** ports;
1118
1119         if ((ports = jack_get_ports (_priv_jack, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortCanMonitor)) == 0) {
1120                 return false;
1121         }
1122
1123         free (ports);
1124
1125         return true;
1126 }
1127
1128 ChanCount
1129 AudioEngine::n_physical (unsigned long flags) const
1130 {
1131         ChanCount c;
1132
1133         GET_PRIVATE_JACK_POINTER_RET (_jack, c);
1134
1135         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1136         if (ports == 0) {
1137                 return c;
1138         }
1139
1140         for (uint32_t i = 0; ports[i]; ++i) {
1141                 if (!strstr (ports[i], "Midi-Through")) {
1142                         DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
1143                         c.set (t, c.get (t) + 1);
1144                 }
1145         }
1146
1147         free (ports);
1148
1149         return c;
1150 }
1151
1152 ChanCount
1153 AudioEngine::n_physical_inputs () const
1154 {
1155         return n_physical (JackPortIsInput);
1156 }
1157
1158 ChanCount
1159 AudioEngine::n_physical_outputs () const
1160 {
1161         return n_physical (JackPortIsOutput);
1162 }
1163
1164 void
1165 AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
1166 {
1167         GET_PRIVATE_JACK_POINTER (_jack);
1168         const char ** ports;
1169
1170         if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
1171                 return;
1172         }
1173
1174         if (ports) {
1175                 for (uint32_t i = 0; ports[i]; ++i) {
1176                         if (strstr (ports[i], "Midi-Through")) {
1177                                 continue;
1178                         }
1179                         phy.push_back (ports[i]);
1180                 }
1181                 free (ports);
1182         }
1183 }
1184
1185 /** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
1186  *  a physical input connector.
1187  */
1188 void
1189 AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
1190 {
1191         get_physical (type, JackPortIsOutput, ins);
1192 }
1193
1194 /** Get physical ports for which JackPortIsInput is set; ie those that correspond to
1195  *  a physical output connector.
1196  */
1197 void
1198 AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
1199 {
1200         get_physical (type, JackPortIsInput, outs);
1201 }
1202
1203 void
1204 AudioEngine::transport_stop ()
1205 {
1206         GET_PRIVATE_JACK_POINTER (_jack);
1207         jack_transport_stop (_priv_jack);
1208 }
1209
1210 void
1211 AudioEngine::transport_start ()
1212 {
1213         GET_PRIVATE_JACK_POINTER (_jack);
1214         jack_transport_start (_priv_jack);
1215 }
1216
1217 void
1218 AudioEngine::transport_locate (framepos_t where)
1219 {
1220         GET_PRIVATE_JACK_POINTER (_jack);
1221         jack_transport_locate (_priv_jack, where);
1222 }
1223
1224 AudioEngine::TransportState
1225 AudioEngine::transport_state ()
1226 {
1227         GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
1228         jack_position_t pos;
1229         return (TransportState) jack_transport_query (_priv_jack, &pos);
1230 }
1231
1232 int
1233 AudioEngine::reset_timebase ()
1234 {
1235         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1236         if (_session) {
1237                 if (_session->config.get_jack_time_master()) {
1238                         return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
1239                 } else {
1240                         return jack_release_timebase (_jack);
1241                 }
1242         }
1243         return 0;
1244 }
1245
1246 int
1247 AudioEngine::freewheel (bool onoff)
1248 {
1249         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1250
1251         if (onoff != _freewheeling) {
1252                 return jack_set_freewheel (_priv_jack, onoff);
1253
1254         } else {
1255                 /* already doing what has been asked for */
1256                 return 0;
1257         }
1258 }
1259
1260 void
1261 AudioEngine::remove_all_ports ()
1262 {
1263         /* make sure that JACK callbacks that will be invoked as we cleanup
1264          * ports know that they have nothing to do.
1265          */
1266
1267         port_remove_in_progress = true;
1268
1269         /* process lock MUST be held by caller
1270         */
1271
1272         {
1273                 RCUWriter<Ports> writer (ports);
1274                 boost::shared_ptr<Ports> ps = writer.get_copy ();
1275                 ps->clear ();
1276         }
1277
1278         /* clear dead wood list in RCU */
1279
1280         ports.flush ();
1281
1282         port_remove_in_progress = false;
1283 }
1284
1285 int
1286 AudioEngine::connect_to_jack (string client_name, string session_uuid)
1287 {
1288         EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
1289         boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
1290         jack_options_t options = JackNullOption;
1291         jack_status_t status;
1292         const char *server_name = NULL;
1293
1294         /* revert all environment settings back to whatever they were when ardour started
1295          */
1296
1297         if (global_epa) {
1298                 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
1299                 global_epa->restore ();
1300         }
1301
1302         jack_client_name = client_name; /* might be reset below */
1303 #ifdef HAVE_JACK_SESSION
1304         if (! session_uuid.empty())
1305             _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
1306         else
1307 #endif
1308             _jack = jack_client_open (jack_client_name.c_str(), options, &status, server_name);
1309
1310         if (_jack == NULL) {
1311                 // error message is not useful here
1312                 return -1;
1313         }
1314
1315         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1316
1317         if (status & JackNameNotUnique) {
1318                 jack_client_name = jack_get_client_name (_priv_jack);
1319         }
1320
1321         return 0;
1322 }
1323
1324 int
1325 AudioEngine::disconnect_from_jack ()
1326 {
1327         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1328
1329         if (_running) {
1330                 stop_metering_thread ();
1331         }
1332
1333         {
1334                 Glib::Mutex::Lock lm (_process_lock);
1335                 jack_client_close (_priv_jack);
1336                 _jack = 0;
1337         }
1338
1339         _buffer_size = 0;
1340         _frame_rate = 0;
1341         _raw_buffer_sizes.clear();
1342
1343         if (_running) {
1344                 _running = false;
1345                 Stopped(); /* EMIT SIGNAL */
1346                 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1347         }
1348
1349         return 0;
1350 }
1351
1352 int
1353 AudioEngine::reconnect_to_jack ()
1354 {
1355         if (_running) {
1356                 disconnect_from_jack ();
1357                 /* XXX give jackd a chance */
1358                 Glib::usleep (250000);
1359         }
1360
1361         if (connect_to_jack (jack_client_name, "")) {
1362                 error << _("failed to connect to JACK") << endmsg;
1363                 return -1;
1364         }
1365
1366         Ports::iterator i;
1367
1368         boost::shared_ptr<Ports> p = ports.reader ();
1369
1370         for (i = p->begin(); i != p->end(); ++i) {
1371                 if (i->second->reestablish ()) {
1372                         break;
1373                 }
1374         }
1375
1376         if (i != p->end()) {
1377                 /* failed */
1378                 remove_all_ports ();
1379                 return -1;
1380         }
1381
1382         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1383
1384         MIDI::Manager::instance()->reestablish (_priv_jack);
1385
1386         if (_session) {
1387                 _session->reset_jack_connection (_priv_jack);
1388                 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
1389                 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
1390         }
1391
1392         last_monitor_check = 0;
1393
1394         set_jack_callbacks ();
1395
1396         if (jack_activate (_priv_jack) == 0) {
1397                 _running = true;
1398                 _has_run = true;
1399         } else {
1400                 return -1;
1401         }
1402
1403         /* re-establish connections */
1404
1405         for (i = p->begin(); i != p->end(); ++i) {
1406                 i->second->reconnect ();
1407         }
1408
1409         MIDI::Manager::instance()->reconnect ();
1410
1411         Running (); /* EMIT SIGNAL*/
1412
1413         start_metering_thread ();
1414
1415         return 0;
1416 }
1417
1418 int
1419 AudioEngine::request_buffer_size (pframes_t nframes)
1420 {
1421         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1422
1423         if (nframes == jack_get_buffer_size (_priv_jack)) {
1424                 return 0;
1425         }
1426
1427         return jack_set_buffer_size (_priv_jack, nframes);
1428 }
1429
1430 string
1431 AudioEngine::make_port_name_relative (string portname) const
1432 {
1433         string::size_type len;
1434         string::size_type n;
1435
1436         len = portname.length();
1437
1438         for (n = 0; n < len; ++n) {
1439                 if (portname[n] == ':') {
1440                         break;
1441                 }
1442         }
1443
1444         if ((n != len) && (portname.substr (0, n) == jack_client_name)) {
1445                 return portname.substr (n+1);
1446         }
1447
1448         return portname;
1449 }
1450
1451 string
1452 AudioEngine::make_port_name_non_relative (string portname) const
1453 {
1454         string str;
1455
1456         if (portname.find_first_of (':') != string::npos) {
1457                 return portname;
1458         }
1459
1460         str  = jack_client_name;
1461         str += ':';
1462         str += portname;
1463
1464         return str;
1465 }
1466
1467 bool
1468 AudioEngine::port_is_mine (const string& portname) const
1469 {
1470         if (portname.find_first_of (':') != string::npos) {
1471                 if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
1472                         return false;
1473                 }
1474         }
1475         return true;
1476 }
1477
1478 bool
1479 AudioEngine::is_realtime () const
1480 {
1481         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1482         return jack_is_realtime (_priv_jack);
1483 }
1484
1485 int
1486 AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
1487 {
1488         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1489         ThreadData* td = new ThreadData (this, f, stacksize);
1490
1491         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
1492                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
1493                 return -1;
1494         }
1495
1496         return 0;
1497 }
1498
1499 void*
1500 AudioEngine::_start_process_thread (void* arg)
1501 {
1502         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
1503         boost::function<void()> f = td->f;
1504         delete td;
1505
1506         f ();
1507
1508         return 0;
1509 }
1510
1511 bool
1512 AudioEngine::port_is_physical (const std::string& portname) const
1513 {
1514         GET_PRIVATE_JACK_POINTER_RET(_jack, false);
1515
1516         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1517
1518         if (!port) {
1519                 return false;
1520         }
1521
1522         return jack_port_flags (port) & JackPortIsPhysical;
1523 }
1524
1525 void
1526 AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
1527 {
1528         GET_PRIVATE_JACK_POINTER(_jack);
1529
1530         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1531
1532         if (!port) {
1533                 return;
1534         }
1535
1536         jack_port_request_monitor (port, yn);
1537 }
1538
1539 void
1540 AudioEngine::update_latencies ()
1541 {
1542         if (jack_recompute_total_latencies) {
1543                 GET_PRIVATE_JACK_POINTER (_jack);
1544                 jack_recompute_total_latencies (_priv_jack);
1545         }
1546 }
1547
1548 void
1549 AudioEngine::destroy ()
1550 {
1551         delete _instance;
1552         _instance = 0;
1553 }