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