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