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