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