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