libs/ardour/jack_audiobackend.cc

   1 /*
   2     Copyright (C) 2013 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <math.h>
  21
  22 #include <boost/scoped_ptr.hpp>
  23 #include <glibmm/timer.h>
  24
  25 #include "pbd/error.h"
  26
  27 #include "midi++/manager.h"
  28
  29 #include "ardour/audioengine.h"
  30 #include "ardour/types.h"
  31 #include "ardour/jack_audiobackend.h"
  32 #include "ardour/jack_connection.h"
  33 #include "ardour/jack_portengine.h"
  34
  35 #include "i18n.h"
  36
  37 using namespace ARDOUR;
  38 using namespace PBD;
  39 using std::string;
  40 using std::vector;
  41
  42 #define GET_PRIVATE_JACK_POINTER(localvar)  jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return; }
  43 #define GET_PRIVATE_JACK_POINTER_RET(localvar,r) jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return r; }
  44
  45 JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnection> jc)
  46         : AudioBackend (e)
  47         , _jack_connection (jc)
  48         , _running (false)
  49         , _freewheeling (false)
  50         , _target_sample_rate (48000)
  51         , _target_buffer_size (1024)
  52         , _target_sample_format (FormatFloat)
  53         , _target_interleaved (false)
  54         , _target_input_channels (-1)
  55         , _target_output_channels (-1)
  56         , _target_systemic_input_latency (0)
  57         , _target_systemic_output_latency (0)
  58 {
  59 }
  60
  61 string
  62 JACKAudioBackend::name() const
  63 {
  64         return X_("JACK");
  65 }
  66
  67 void*
  68 JACKAudioBackend::private_handle() const
  69 {
  70         return _jack_connection->jack();
  71 }
  72
  73 bool
  74 JACKAudioBackend::connected() const
  75 {
  76         return (private_handle() != 0);
  77 }
  78
  79 bool
  80 JACKAudioBackend::is_realtime () const
  81 {
  82         GET_PRIVATE_JACK_POINTER_RET (_priv_jack,false);
  83         return jack_is_realtime (_priv_jack);
  84 }
  85
  86 vector<string>
  87 JACKAudioBackend::enumerate_devices () const
  88 {
  89         vector<string> devices;
  90         return devices;
  91 }
  92
  93 vector<float>
  94 JACKAudioBackend::available_sample_rates (const string& /*device*/) const
  95 {
  96         vector<float> f;
  97
  98         if (connected()) {
  99                 f.push_back (sample_rate());
 100                 return f;
 101         }
 102
 103         /* if JACK is not already running, just list a bunch of reasonable
 104            values and let the future sort it all out.
 105         */
 106
 107         f.push_back (8000.0);
 108         f.push_back (16000.0);
 109         f.push_back (24000.0);
 110         f.push_back (32000.0);
 111         f.push_back (44100.0);
 112         f.push_back (48000.0);
 113         f.push_back (88200.0);
 114         f.push_back (96000.0);
 115         f.push_back (192000.0);
 116         f.push_back (384000.0);
 117
 118         return f;
 119 }
 120
 121 vector<uint32_t>
 122 JACKAudioBackend::available_buffer_sizes (const string& /*device*/) const
 123 {
 124         vector<uint32_t> s;
 125
 126         if (connected()) {
 127                 s.push_back (buffer_size());
 128                 return s;
 129         }
 130
 131         s.push_back (8);
 132         s.push_back (16);
 133         s.push_back (32);
 134         s.push_back (64);
 135         s.push_back (128);
 136         s.push_back (256);
 137         s.push_back (512);
 138         s.push_back (1024);
 139         s.push_back (2048);
 140         s.push_back (4096);
 141         s.push_back (8192);
 142
 143         return s;
 144 }
 145
 146 uint32_t
 147 JACKAudioBackend::available_input_channel_count (const string& /*device*/) const
 148 {
 149         return 128;
 150 }
 151
 152 uint32_t
 153 JACKAudioBackend::available_output_channel_count (const string& /*device*/) const
 154 {
 155         return 128;
 156 }
 157
 158 /* -- parameter setting -- */
 159
 160 int
 161 JACKAudioBackend::set_device_name (const string& dev)
 162 {
 163         if (connected()) {
 164                 /* need to stop and restart JACK for this to work, at present */
 165                 return -1;
 166         }
 167
 168         _target_device = dev;
 169         return 0;
 170 }
 171
 172 int
 173 JACKAudioBackend::set_sample_rate (float sr)
 174 {
 175         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 176
 177         if (!connected()) {
 178                 _target_sample_rate = sr;
 179                 return 0;
 180         }
 181
 182         if (sr == jack_get_sample_rate (_priv_jack)) {
 183                 return 0;
 184         }
 185
 186         return -1;
 187 }
 188
 189 int
 190 JACKAudioBackend::set_buffer_size (uint32_t nframes)
 191 {
 192         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 193
 194         if (!connected()) {
 195                 _target_buffer_size = nframes;
 196                 return 0;
 197         }
 198
 199         if (nframes == jack_get_buffer_size (_priv_jack)) {
 200                 return 0;
 201         }
 202
 203         return jack_set_buffer_size (_priv_jack, nframes);
 204 }
 205
 206 int
 207 JACKAudioBackend::set_sample_format (SampleFormat sf)
 208 {
 209         /* as far as JACK clients are concerned, the hardware is always
 210          * floating point format.
 211          */
 212         if (sf == FormatFloat) {
 213                 return 0;
 214         }
 215         return -1;
 216 }
 217
 218 int
 219 JACKAudioBackend::set_interleaved (bool yn)
 220 {
 221         /* as far as JACK clients are concerned, the hardware is always
 222          * non-interleaved
 223          */
 224         if (!yn) {
 225                 return 0;
 226         }
 227         return -1;
 228 }
 229
 230 int
 231 JACKAudioBackend::set_input_channels (uint32_t cnt)
 232 {
 233         if (connected()) {
 234                 return -1;
 235         }
 236
 237         _target_input_channels = cnt;
 238
 239         return 0;
 240 }
 241
 242 int
 243 JACKAudioBackend::set_output_channels (uint32_t cnt)
 244 {
 245         if (connected()) {
 246                 return -1;
 247         }
 248
 249         _target_output_channels = cnt;
 250
 251         return 0;
 252 }
 253
 254 int
 255 JACKAudioBackend::set_systemic_input_latency (uint32_t l)
 256 {
 257         if (connected()) {
 258                 return -1;
 259         }
 260
 261         _target_systemic_input_latency = l;
 262
 263         return 0;
 264 }
 265
 266 int
 267 JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 268 {
 269         if (connected()) {
 270                 return -1;
 271         }
 272
 273         _target_systemic_output_latency = l;
 274
 275         return 0;
 276 }
 277
 278 /* --- Parameter retrieval --- */
 279
 280 std::string
 281 JACKAudioBackend::device_name () const
 282 {
 283         return string();
 284 }
 285
 286 float
 287 JACKAudioBackend::sample_rate () const
 288 {
 289         if (connected()) {
 290                 return _current_sample_rate;
 291         }
 292         return _target_sample_rate;
 293 }
 294
 295 uint32_t
 296 JACKAudioBackend::buffer_size () const
 297 {
 298         if (connected()) {
 299                 return _current_buffer_size;
 300         }
 301         return _target_buffer_size;
 302 }
 303
 304 SampleFormat
 305 JACKAudioBackend::sample_format () const
 306 {
 307         return FormatFloat;
 308 }
 309
 310 bool
 311 JACKAudioBackend::interleaved () const
 312 {
 313         return false;
 314 }
 315
 316 uint32_t
 317 JACKAudioBackend::input_channels () const
 318 {
 319         if (connected()) {
 320                 return n_physical (JackPortIsInput).n_audio();
 321         }
 322         return _target_input_channels;
 323 }
 324
 325 uint32_t
 326 JACKAudioBackend::output_channels () const
 327 {
 328         if (connected()) {
 329                 return n_physical (JackPortIsOutput).n_audio();
 330         }
 331         return _target_output_channels;
 332 }
 333
 334 uint32_t
 335 JACKAudioBackend::systemic_input_latency () const
 336 {
 337         return _current_systemic_output_latency;
 338 }
 339
 340 uint32_t
 341 JACKAudioBackend::systemic_output_latency () const
 342 {
 343         return _current_systemic_output_latency;
 344 }
 345
 346 size_t
 347 JACKAudioBackend::raw_buffer_size(DataType t)
 348 {
 349         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 350         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 351 }
 352
 353 /* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
 354
 355 int
 356 JACKAudioBackend::start ()
 357 {
 358         if (!connected()) {
 359                 _jack_connection->open ();
 360         }
 361
 362         engine.reestablish_ports ();
 363
 364         if (!jack_port_type_get_buffer_size) {
 365                 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 366         }
 367
 368         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 369
 370         engine.sample_rate_change (jack_get_sample_rate (_priv_jack));
 371
 372         /* testing the nullity of this function name is a proxy for
 373          * whether jack_activate() will definitely call the buffer size
 374          * callback. with older versions of JACK, this function symbol
 375          * will be null.  this is sort of reliable, but not clean since
 376          * weak symbol support is highly platform and compiler
 377          * specific.
 378          */
 379         if (!jack_port_type_get_buffer_size) {
 380                 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 381         }
 382
 383         set_jack_callbacks ();
 384
 385         if (jack_activate (_priv_jack) == 0) {
 386                 _running = true;
 387         } else {
 388                 // error << _("cannot activate JACK client") << endmsg;
 389         }
 390
 391         engine.reconnect_ports ();
 392
 393         return 0;
 394 }
 395
 396 int
 397 JACKAudioBackend::stop ()
 398 {
 399         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 400
 401         _jack_connection->close ();
 402
 403         _current_buffer_size = 0;
 404         _current_sample_rate = 0;
 405
 406         _raw_buffer_sizes.clear();
 407
 408         return 0;
 409 }
 410
 411 int
 412 JACKAudioBackend::pause ()
 413 {
 414         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 415
 416         if (_priv_jack) {
 417                 jack_deactivate (_priv_jack);
 418         }
 419
 420         return 0;
 421 }
 422
 423 int
 424 JACKAudioBackend::freewheel (bool onoff)
 425 {
 426         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 427
 428         if (onoff == _freewheeling) {
 429                 /* already doing what has been asked for */
 430
 431                 return 0;
 432         }
 433
 434         if (jack_set_freewheel (_priv_jack, onoff) == 0) {
 435                 _freewheeling = true;
 436                 return 0;
 437         }
 438
 439         return -1;
 440 }
 441
 442 /* --- TRANSPORT STATE MANAGEMENT --- */
 443
 444 void
 445 JACKAudioBackend::transport_stop ()
 446 {
 447         GET_PRIVATE_JACK_POINTER (_priv_jack);
 448         jack_transport_stop (_priv_jack);
 449 }
 450
 451 void
 452 JACKAudioBackend::transport_start ()
 453 {
 454         GET_PRIVATE_JACK_POINTER (_priv_jack);
 455         jack_transport_start (_priv_jack);
 456 }
 457
 458 void
 459 JACKAudioBackend::transport_locate (framepos_t where)
 460 {
 461         GET_PRIVATE_JACK_POINTER (_priv_jack);
 462         jack_transport_locate (_priv_jack, where);
 463 }
 464
 465 framepos_t
 466 JACKAudioBackend::transport_frame () const
 467 {
 468         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 469         return jack_get_current_transport_frame (_priv_jack);
 470 }
 471
 472 TransportState
 473 JACKAudioBackend::transport_state () const
 474 {
 475         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
 476         jack_position_t pos;
 477         return (TransportState) jack_transport_query (_priv_jack, &pos);
 478 }
 479
 480 int
 481 JACKAudioBackend::set_time_master (bool yn)
 482 {
 483         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 484         if (yn) {
 485                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 486         } else {
 487                 return jack_release_timebase (_priv_jack);
 488         }
 489 }
 490
 491 /* process-time */
 492
 493 bool
 494 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 495 {
 496
 497 #ifdef HAVE_JACK_VIDEO_SUPPORT
 498
 499         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
 500
 501         jack_position_t pos;
 502
 503         if (_priv_jack) {
 504                 (void) jack_transport_query (_priv_jack, &pos);
 505
 506                 if (pos.valid & JackVideoFrameOffset) {
 507                         offset = pos.video_offset;
 508                         return true;
 509                 }
 510         }
 511 #else
 512         /* keep gcc happy */
 513         offset = 0;
 514 #endif
 515
 516         return false;
 517 }
 518
 519 pframes_t
 520 JACKAudioBackend::sample_time ()
 521 {
 522         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 523         return jack_frame_time (_priv_jack);
 524 }
 525
 526 pframes_t
 527 JACKAudioBackend::sample_time_at_cycle_start ()
 528 {
 529         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 530         return jack_last_frame_time (_priv_jack);
 531 }
 532
 533 pframes_t
 534 JACKAudioBackend::samples_since_cycle_start ()
 535 {
 536         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 537         return jack_frames_since_cycle_start (_priv_jack);
 538 }
 539
 540 /* JACK Callbacks */
 541
 542 static void
 543 ardour_jack_error (const char* msg)
 544 {
 545         error << "JACK: " << msg << endmsg;
 546 }
 547
 548 void
 549 JACKAudioBackend::set_jack_callbacks ()
 550 {
 551         GET_PRIVATE_JACK_POINTER (_priv_jack);
 552
 553         jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
 554
 555         jack_set_process_thread (_priv_jack, _process_thread, this);
 556         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 557         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 558         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 559         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 560         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 561
 562 #ifdef HAVE_JACK_SESSION
 563         if( jack_set_session_callback)
 564                 jack_set_session_callback (_priv_jack, _session_callback, this);
 565 #endif
 566
 567         if (jack_set_latency_callback) {
 568                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 569         }
 570
 571         jack_set_error_function (ardour_jack_error);
 572 }
 573
 574 void
 575 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 576                                       jack_position_t* pos, int new_position, void *arg)
 577 {
 578         static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 579 }
 580
 581 void
 582 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t /*nframes*/,
 583                                           jack_position_t* pos, int /*new_position*/)
 584 {
 585         TransportState tstate;
 586         framepos_t position;
 587
 588         switch (state) {
 589         case JackTransportStopped:
 590                 tstate = TransportStopped;
 591                 break;
 592         case JackTransportRolling:
 593                 tstate = TransportRolling;
 594                 break;
 595         case JackTransportLooping:
 596                 tstate = TransportLooping;
 597                 break;
 598         case JackTransportStarting:
 599                 tstate = TransportStarting;
 600                 break;
 601         }
 602
 603         if (pos) {
 604                 position = pos->frame;
 605         }
 606
 607         // engine.timebase_callback (tstate, nframes, position, new_position);
 608 }
 609
 610 int
 611 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 612 {
 613         return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
 614 }
 615
 616 int
 617 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 618 {
 619         TransportState tstate;
 620
 621         switch (state) {
 622         case JackTransportStopped:
 623                 tstate = TransportStopped;
 624                 break;
 625         case JackTransportRolling:
 626                 tstate = TransportRolling;
 627                 break;
 628         case JackTransportLooping:
 629                 tstate = TransportLooping;
 630                 break;
 631         case JackTransportStarting:
 632                 tstate = TransportStarting;
 633                 break;
 634         }
 635
 636         return engine.sync_callback (tstate, pos->frame);
 637
 638         return true;
 639 }
 640
 641 int
 642 JACKAudioBackend::_xrun_callback (void *arg)
 643 {
 644         JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
 645         if (ae->connected()) {
 646                 ae->engine.Xrun (); /* EMIT SIGNAL */
 647         }
 648         return 0;
 649 }
 650
 651 #ifdef HAVE_JACK_SESSION
 652 void
 653 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 654 {
 655         JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
 656         if (ae->connected()) {
 657                 ae->engine.JackSessionEvent (event); /* EMIT SIGNAL */
 658         }
 659 }
 660 #endif
 661
 662 void
 663 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 664 {
 665         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 666 }
 667
 668 void
 669 JACKAudioBackend::freewheel_callback (int onoff)
 670 {
 671         _freewheeling = onoff;
 672         engine.freewheel_callback (onoff);
 673 }
 674
 675 void
 676 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 677 {
 678         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 679 }
 680
 681 int
 682 JACKAudioBackend::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
 683 {
 684         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 685         ThreadData* td = new ThreadData (this, f, stacksize);
 686
 687         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
 688                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 689                 return -1;
 690         }
 691
 692         return 0;
 693 }
 694
 695 void*
 696 JACKAudioBackend::_start_process_thread (void* arg)
 697 {
 698         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 699         boost::function<void()> f = td->f;
 700         delete td;
 701
 702         f ();
 703
 704         return 0;
 705 }
 706
 707 void*
 708 JACKAudioBackend::_process_thread (void *arg)
 709 {
 710         return static_cast<JACKAudioBackend*> (arg)->process_thread ();
 711 }
 712
 713 void*
 714 JACKAudioBackend::process_thread ()
 715 {
 716         /* JACK doesn't do this for us when we use the wait API
 717          */
 718
 719         AudioEngine::thread_init_callback (this);
 720
 721         while (1) {
 722                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 723
 724                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 725
 726                 if (engine.process_callback (nframes)) {
 727                         return 0;
 728                 }
 729
 730                 jack_cycle_signal (_priv_jack, 0);
 731         }
 732
 733         return 0;
 734 }
 735
 736 int
 737 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 738 {
 739         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 740 }
 741
 742 int
 743 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 744 {
 745         _current_sample_rate = nframes;
 746         return engine.sample_rate_change (nframes);
 747 }
 748
 749 void
 750 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 751 {
 752         engine.latency_callback (mode == JackPlaybackLatency);
 753 }
 754
 755 int
 756 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 757 {
 758         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 759 }
 760
 761 int
 762 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 763 {
 764         /* if the size has not changed, this should be a no-op */
 765
 766         if (nframes == _current_buffer_size) {
 767                 return 0;
 768         }
 769
 770         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 771
 772         _current_buffer_size = nframes;
 773         _current_usecs_per_cycle = (int) floor ((((double) nframes / sample_rate())) * 1000000.0);
 774
 775         if (jack_port_type_get_buffer_size) {
 776                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 777                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 778         } else {
 779
 780                 /* Old version of JACK.
 781
 782                    These crude guesses, see below where we try to get the right answers.
 783
 784                    Note that our guess for MIDI deliberatey tries to overestimate
 785                    by a little. It would be nicer if we could get the actual
 786                    size from a port, but we have to use this estimate in the
 787                    event that there are no MIDI ports currently. If there are
 788                    the value will be adjusted below.
 789                 */
 790
 791                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 792                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 793         }
 794
 795         engine.buffer_size_change (nframes);
 796
 797         return 0;
 798 }
 799
 800 void
 801 JACKAudioBackend::disconnected (const char* why)
 802 {
 803         /* called from jack shutdown handler  */
 804
 805         bool was_running = _running;
 806
 807         _running = false;
 808         _current_buffer_size = 0;
 809         _current_sample_rate = 0;
 810
 811         if (was_running) {
 812                 engine.halted_callback (why); /* EMIT SIGNAL */
 813         }
 814 }
 815 float
 816 JACKAudioBackend::cpu_load() const
 817 {
 818         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 819         return jack_cpu_load (_priv_jack);
 820 }
 821
 822 void
 823 JACKAudioBackend::update_latencies ()
 824 {
 825         GET_PRIVATE_JACK_POINTER (_priv_jack);
 826         jack_recompute_total_latencies (_priv_jack);
 827 }