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