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