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