libs/ardour/audioengine.cc

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