libs/ardour/audioengine.cc

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