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