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 (bool for_latency_measurement)
 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, for_latency_measurement)) {
 509                 /* error, somehow - we will still try to start JACK
 510                  * automatically but it will be without our preferred options
 511                  */
 512                 std::cerr << "get_jack_command_line_string () failed: using default settings." << std::endl;
 513                 return;
 514         }
 515
 516         std::cerr << "JACK command line will be: " << cmdline << std::endl;
 517
 518         write_jack_config_file (get_jack_server_user_config_file_path(), cmdline);
 519 }
 520
 521 /* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
 522
 523 int
 524 JACKAudioBackend::_start (bool for_latency_measurement)
 525 {
 526         if (!available()) {
 527
 528                 if (_jack_connection->in_control()) {
 529                         /* we will be starting JACK, so set up the
 530                            command that JACK will use when it (auto-)starts
 531                         */
 532                         setup_jack_startup_command (for_latency_measurement);
 533                 }
 534
 535                 if (_jack_connection->open ()) {
 536                         return -1;
 537                 }
 538         }
 539
 540         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 541
 542         /* get the buffer size and sample rates established */
 543
 544         jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
 545         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 546
 547         /* Now that we have buffer size and sample rate established, the engine
 548            can go ahead and do its stuff
 549         */
 550
 551         engine.reestablish_ports ();
 552
 553         if (!jack_port_type_get_buffer_size) {
 554                 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 555         }
 556
 557         set_jack_callbacks ();
 558
 559         if (jack_activate (_priv_jack) == 0) {
 560                 _running = true;
 561         } else {
 562                 // error << _("cannot activate JACK client") << endmsg;
 563         }
 564
 565         engine.reconnect_ports ();
 566
 567         return 0;
 568 }
 569
 570 int
 571 JACKAudioBackend::stop ()
 572 {
 573         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 574
 575         _jack_connection->close ();
 576
 577         _current_buffer_size = 0;
 578         _current_sample_rate = 0;
 579
 580         _raw_buffer_sizes.clear();
 581
 582         return 0;
 583 }
 584
 585 int
 586 JACKAudioBackend::freewheel (bool onoff)
 587 {
 588         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 589
 590         if (onoff == _freewheeling) {
 591                 /* already doing what has been asked for */
 592
 593                 return 0;
 594         }
 595
 596         if (jack_set_freewheel (_priv_jack, onoff) == 0) {
 597                 _freewheeling = onoff;
 598                 return 0;
 599         }
 600
 601         return -1;
 602 }
 603
 604 /* --- TRANSPORT STATE MANAGEMENT --- */
 605
 606 void
 607 JACKAudioBackend::transport_stop ()
 608 {
 609         GET_PRIVATE_JACK_POINTER (_priv_jack);
 610         jack_transport_stop (_priv_jack);
 611 }
 612
 613 void
 614 JACKAudioBackend::transport_start ()
 615 {
 616         GET_PRIVATE_JACK_POINTER (_priv_jack);
 617         jack_transport_start (_priv_jack);
 618 }
 619
 620 void
 621 JACKAudioBackend::transport_locate (framepos_t where)
 622 {
 623         GET_PRIVATE_JACK_POINTER (_priv_jack);
 624         jack_transport_locate (_priv_jack, where);
 625 }
 626
 627 framepos_t
 628 JACKAudioBackend::transport_frame () const
 629 {
 630         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 631         return jack_get_current_transport_frame (_priv_jack);
 632 }
 633
 634 TransportState
 635 JACKAudioBackend::transport_state () const
 636 {
 637         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
 638         jack_position_t pos;
 639         return (TransportState) jack_transport_query (_priv_jack, &pos);
 640 }
 641
 642 int
 643 JACKAudioBackend::set_time_master (bool yn)
 644 {
 645         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 646         if (yn) {
 647                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 648         } else {
 649                 return jack_release_timebase (_priv_jack);
 650         }
 651 }
 652
 653 /* process-time */
 654
 655 bool
 656 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 657 {
 658
 659 #ifdef HAVE_JACK_VIDEO_SUPPORT
 660
 661         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
 662
 663         jack_position_t pos;
 664
 665         if (_priv_jack) {
 666                 (void) jack_transport_query (_priv_jack, &pos);
 667
 668                 if (pos.valid & JackVideoFrameOffset) {
 669                         offset = pos.video_offset;
 670                         return true;
 671                 }
 672         }
 673 #else
 674         /* keep gcc happy */
 675         offset = 0;
 676 #endif
 677
 678         return false;
 679 }
 680
 681 pframes_t
 682 JACKAudioBackend::sample_time ()
 683 {
 684         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 685         return jack_frame_time (_priv_jack);
 686 }
 687
 688 pframes_t
 689 JACKAudioBackend::sample_time_at_cycle_start ()
 690 {
 691         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 692         return jack_last_frame_time (_priv_jack);
 693 }
 694
 695 pframes_t
 696 JACKAudioBackend::samples_since_cycle_start ()
 697 {
 698         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 699         return jack_frames_since_cycle_start (_priv_jack);
 700 }
 701
 702 /* JACK Callbacks */
 703
 704 static void
 705 ardour_jack_error (const char* msg)
 706 {
 707         error << "JACK: " << msg << endmsg;
 708 }
 709
 710 void
 711 JACKAudioBackend::set_jack_callbacks ()
 712 {
 713         GET_PRIVATE_JACK_POINTER (_priv_jack);
 714
 715         jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
 716
 717         jack_set_process_thread (_priv_jack, _process_thread, this);
 718         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 719         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 720         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 721         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 722         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 723
 724 #ifdef HAVE_JACK_SESSION
 725         if( jack_set_session_callback)
 726                 jack_set_session_callback (_priv_jack, _session_callback, this);
 727 #endif
 728
 729         if (jack_set_latency_callback) {
 730                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 731         }
 732
 733         jack_set_error_function (ardour_jack_error);
 734 }
 735
 736 void
 737 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 738                                       jack_position_t* pos, int new_position, void *arg)
 739 {
 740         static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 741 }
 742
 743 void
 744 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 745                                           jack_position_t* pos, int new_position)
 746 {
 747         ARDOUR::Session* session = engine.session();
 748
 749         if (session) {
 750                 JACKSession jsession (session);
 751                 jsession.timebase_callback (state, nframes, pos, new_position);
 752         }
 753 }
 754
 755 int
 756 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 757 {
 758         return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
 759 }
 760
 761 int
 762 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 763 {
 764         TransportState tstate;
 765
 766         switch (state) {
 767         case JackTransportStopped:
 768                 tstate = TransportStopped;
 769                 break;
 770         case JackTransportRolling:
 771                 tstate = TransportRolling;
 772                 break;
 773         case JackTransportLooping:
 774                 tstate = TransportLooping;
 775                 break;
 776         case JackTransportStarting:
 777                 tstate = TransportStarting;
 778                 break;
 779         }
 780
 781         return engine.sync_callback (tstate, pos->frame);
 782
 783         return true;
 784 }
 785
 786 int
 787 JACKAudioBackend::_xrun_callback (void *arg)
 788 {
 789         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 790         if (jab->available()) {
 791                 jab->engine.Xrun (); /* EMIT SIGNAL */
 792         }
 793         return 0;
 794 }
 795
 796 void
 797 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 798 {
 799         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 800         ARDOUR::Session* session = jab->engine.session();
 801
 802         if (session) {
 803                 JACKSession jsession (session);
 804                 jsession.session_event (event);
 805         }
 806 }
 807
 808 void
 809 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 810 {
 811         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 812 }
 813
 814 void
 815 JACKAudioBackend::freewheel_callback (int onoff)
 816 {
 817         _freewheeling = onoff;
 818         engine.freewheel_callback (onoff);
 819 }
 820
 821 void
 822 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 823 {
 824         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 825 }
 826
 827 int
 828 JACKAudioBackend::create_process_thread (boost::function<void()> f)
 829 {
 830         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 831
 832         jack_native_thread_t thread_id;
 833         ThreadData* td = new ThreadData (this, f, thread_stack_size());
 834
 835         if (jack_client_create_thread (_priv_jack, &thread_id, jack_client_real_time_priority (_priv_jack),
 836                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 837                 return -1;
 838         }
 839
 840         _jack_threads.push_back(thread_id);
 841         return 0;
 842 }
 843
 844 int
 845 JACKAudioBackend::join_process_threads ()
 846 {
 847         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 848
 849         int ret = 0;
 850
 851         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 852              i != _jack_threads.end(); i++) {
 853
 854 #if defined(USING_JACK2_EXPANSION_OF_JACK_API) || defined(PLATFORM_WINDOWS)
 855                 if (jack_client_stop_thread (_priv_jack, *i) != 0) {
 856 #else
 857                 void* status;
 858                 if (pthread_join (*i, &status) != 0) {
 859 #endif
 860                         error << "AudioEngine: cannot stop process thread" << endmsg;
 861                         ret += -1;
 862                 }
 863         }
 864
 865         _jack_threads.clear();
 866
 867         return ret;
 868 }
 869
 870 bool
 871 JACKAudioBackend::in_process_thread ()
 872 {
 873         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 874              i != _jack_threads.end(); i++) {
 875
 876 #ifdef COMPILER_MINGW
 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         AudioEngine::thread_init_callback (this);
 921
 922         while (1) {
 923                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 924
 925                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 926
 927                 if (engine.process_callback (nframes)) {
 928                         return 0;
 929                 }
 930
 931                 jack_cycle_signal (_priv_jack, 0);
 932         }
 933
 934         return 0;
 935 }
 936
 937 int
 938 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 939 {
 940         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 941 }
 942
 943 int
 944 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 945 {
 946         _current_sample_rate = nframes;
 947         return engine.sample_rate_change (nframes);
 948 }
 949
 950 void
 951 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 952 {
 953         engine.latency_callback (mode == JackPlaybackLatency);
 954 }
 955
 956 int
 957 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 958 {
 959         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 960 }
 961
 962 int
 963 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 964 {
 965         /* if the size has not changed, this should be a no-op */
 966
 967         if (nframes == _current_buffer_size) {
 968                 return 0;
 969         }
 970
 971         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 972
 973         _current_buffer_size = nframes;
 974
 975         if (jack_port_type_get_buffer_size) {
 976                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 977                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 978         } else {
 979
 980                 /* Old version of JACK.
 981
 982                    These crude guesses, see below where we try to get the right answers.
 983
 984                    Note that our guess for MIDI deliberatey tries to overestimate
 985                    by a little. It would be nicer if we could get the actual
 986                    size from a port, but we have to use this estimate in the
 987                    event that there are no MIDI ports currently. If there are
 988                    the value will be adjusted below.
 989                 */
 990
 991                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 992                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 993         }
 994
 995         engine.buffer_size_change (nframes);
 996
 997         return 0;
 998 }
 999
1000 void
1001 JACKAudioBackend::disconnected (const char* why)
1002 {
1003         bool was_running = _running;
1004
1005         _running = false;
1006         _current_buffer_size = 0;
1007         _current_sample_rate = 0;
1008
1009         if (was_running) {
1010                 engine.halted_callback (why); /* EMIT SIGNAL */
1011         }
1012 }
1013
1014 float
1015 JACKAudioBackend::cpu_load() const
1016 {
1017         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
1018         return jack_cpu_load (_priv_jack);
1019 }
1020
1021 void
1022 JACKAudioBackend::update_latencies ()
1023 {
1024         GET_PRIVATE_JACK_POINTER (_priv_jack);
1025         jack_recompute_total_latencies (_priv_jack);
1026 }
1027
1028 ChanCount
1029 JACKAudioBackend::n_physical (unsigned long flags) const
1030 {
1031         ChanCount c;
1032
1033         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
1034
1035         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1036
1037         if (ports) {
1038                 for (uint32_t i = 0; ports[i]; ++i) {
1039                         if (!strstr (ports[i], "Midi-Through")) {
1040                                 DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
1041                                 if (t != DataType::NIL) {
1042                                         c.set (t, c.get (t) + 1);
1043                                 }
1044                         }
1045                 }
1046
1047                 jack_free (ports);
1048         }
1049
1050         return c;
1051 }
1052
1053 bool
1054 JACKAudioBackend::can_change_sample_rate_when_running () const
1055 {
1056         return false;
1057 }
1058
1059 bool
1060 JACKAudioBackend::can_change_buffer_size_when_running () const
1061 {
1062         return true;
1063 }
1064
1065 string
1066 JACKAudioBackend::control_app_name () const
1067 {
1068         /* Since JACK/ALSA really don't provide particularly integrated support
1069            for the idea of a control app to be used to control a device,
1070            allow the user to take some control themselves if necessary.
1071         */
1072
1073         const char* env_value  = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
1074         string appname;
1075
1076         if (!env_value) {
1077                 if (_target_driver.empty() || _target_device.empty()) {
1078                         return appname;
1079                 }
1080
1081                 if (_target_driver == "ALSA") {
1082
1083                         if (_target_device == "Hammerfall DSP") {
1084                                 appname = "hdspconf";
1085                         } else if (_target_device == "M Audio Delta 1010") {
1086                                 appname = "mudita24";
1087                         }
1088                 }
1089         } else {
1090                 appname = env_value;
1091         }
1092
1093         return appname;
1094 }
1095
1096 void
1097 JACKAudioBackend::launch_control_app ()
1098 {
1099         string appname = control_app_name();
1100
1101         if (appname.empty()) {
1102                 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1103                 return;
1104         }
1105
1106         std::list<string> args;
1107         args.push_back (appname);
1108         Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);
1109 }
1110
1111 vector<string>
1112 JACKAudioBackend::enumerate_midi_options () const
1113 {
1114         return ARDOUR::enumerate_midi_options ();
1115 }
1116
1117 int
1118 JACKAudioBackend::set_midi_option (const string& opt)
1119 {
1120         _target_midi_option = opt;
1121         return 0;
1122 }
1123
1124 bool
1125 JACKAudioBackend::speed_and_position (double& speed, framepos_t& position)
1126 {
1127         jack_position_t pos;
1128         jack_transport_state_t state;
1129         bool starting;
1130
1131         /* this won't be called if the port engine in use is not JACK, so we do
1132            not have to worry about the type of PortEngine::private_handle()
1133         */
1134
1135         speed = 0;
1136         position = 0;
1137
1138         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, true);
1139
1140         state = jack_transport_query (_priv_jack, &pos);
1141
1142         switch (state) {
1143         case JackTransportStopped:
1144                 speed = 0;
1145                 starting = false;
1146                 break;
1147         case JackTransportRolling:
1148                 speed = 1.0;
1149                 starting = false;
1150                 break;
1151         case JackTransportLooping:
1152                 speed = 1.0;
1153                 starting = false;
1154                 break;
1155         case JackTransportStarting:
1156                 starting = true;
1157                 // don't adjust speed here, just leave it as it was
1158                 break;
1159         default:
1160                 std::cerr << "WARNING: Unknown JACK transport state: " << state << std::endl;
1161         }
1162
1163         position = pos.frame;
1164         return starting;
1165 }