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