libs/ardour/audioengine.cc

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