libs/ardour/audioengine.cc

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