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