libs/ardour/audioengine.cc

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