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