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