libs/ardour/audioengine.cc

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