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 JackTransportRolling:
 768                 tstate = TransportRolling;
 769                 break;
 770         case JackTransportLooping:
 771                 tstate = TransportLooping;
 772                 break;
 773         case JackTransportStarting:
 774                 tstate = TransportStarting;
 775                 break;
 776         case JackTransportStopped:
 777         default:
 778                 tstate = TransportStopped;
 779                 break;
 780         }
 781
 782         return engine.sync_callback (tstate, pos->frame);
 783
 784         return true;
 785 }
 786
 787 int
 788 JACKAudioBackend::_xrun_callback (void *arg)
 789 {
 790         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 791         if (jab->available()) {
 792                 jab->engine.Xrun (); /* EMIT SIGNAL */
 793         }
 794         return 0;
 795 }
 796
 797 void
 798 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 799 {
 800         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 801         ARDOUR::Session* session = jab->engine.session();
 802
 803         if (session) {
 804                 JACKSession jsession (session);
 805                 jsession.session_event (event);
 806         }
 807 }
 808
 809 void
 810 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 811 {
 812         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 813 }
 814
 815 void
 816 JACKAudioBackend::freewheel_callback (int onoff)
 817 {
 818         _freewheeling = onoff;
 819         engine.freewheel_callback (onoff);
 820 }
 821
 822 void
 823 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 824 {
 825         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 826 }
 827
 828 int
 829 JACKAudioBackend::create_process_thread (boost::function<void()> f)
 830 {
 831         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 832
 833         jack_native_thread_t thread_id;
 834         ThreadData* td = new ThreadData (this, f, thread_stack_size());
 835
 836         if (jack_client_create_thread (_priv_jack, &thread_id, jack_client_real_time_priority (_priv_jack),
 837                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 838                 return -1;
 839         }
 840
 841         _jack_threads.push_back(thread_id);
 842         return 0;
 843 }
 844
 845 int
 846 JACKAudioBackend::join_process_threads ()
 847 {
 848         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 849
 850         int ret = 0;
 851
 852         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 853              i != _jack_threads.end(); i++) {
 854
 855 #if defined(USING_JACK2_EXPANSION_OF_JACK_API) || defined(PLATFORM_WINDOWS)
 856                 if (jack_client_stop_thread (_priv_jack, *i) != 0) {
 857 #else
 858                 void* status;
 859                 if (pthread_join (*i, &status) != 0) {
 860 #endif
 861                         error << "AudioEngine: cannot stop process thread" << endmsg;
 862                         ret += -1;
 863                 }
 864         }
 865
 866         _jack_threads.clear();
 867
 868         return ret;
 869 }
 870
 871 bool
 872 JACKAudioBackend::in_process_thread ()
 873 {
 874         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 875              i != _jack_threads.end(); i++) {
 876
 877 #ifdef COMPILER_MINGW
 878                 if (*i == GetCurrentThread()) {
 879                         return true;
 880                 }
 881 #else // pthreads
 882                 if (pthread_equal (*i, pthread_self()) != 0) {
 883                         return true;
 884                 }
 885 #endif
 886         }
 887
 888         return false;
 889 }
 890
 891 uint32_t
 892 JACKAudioBackend::process_thread_count ()
 893 {
 894         return _jack_threads.size();
 895 }
 896
 897 void*
 898 JACKAudioBackend::_start_process_thread (void* arg)
 899 {
 900         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 901         boost::function<void()> f = td->f;
 902         delete td;
 903
 904         f ();
 905
 906         return 0;
 907 }
 908
 909 void*
 910 JACKAudioBackend::_process_thread (void *arg)
 911 {
 912         return static_cast<JACKAudioBackend*> (arg)->process_thread ();
 913 }
 914
 915 void*
 916 JACKAudioBackend::process_thread ()
 917 {
 918         /* JACK doesn't do this for us when we use the wait API
 919          */
 920
 921         AudioEngine::thread_init_callback (this);
 922
 923         while (1) {
 924                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 925
 926                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 927
 928                 if (engine.process_callback (nframes)) {
 929                         return 0;
 930                 }
 931
 932                 jack_cycle_signal (_priv_jack, 0);
 933         }
 934
 935         return 0;
 936 }
 937
 938 int
 939 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 940 {
 941         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 942 }
 943
 944 int
 945 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 946 {
 947         _current_sample_rate = nframes;
 948         return engine.sample_rate_change (nframes);
 949 }
 950
 951 void
 952 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 953 {
 954         engine.latency_callback (mode == JackPlaybackLatency);
 955 }
 956
 957 int
 958 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 959 {
 960         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 961 }
 962
 963 int
 964 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 965 {
 966         /* if the size has not changed, this should be a no-op */
 967
 968         if (nframes == _current_buffer_size) {
 969                 return 0;
 970         }
 971
 972         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 973
 974         _current_buffer_size = nframes;
 975
 976         if (jack_port_type_get_buffer_size) {
 977                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 978                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 979         } else {
 980
 981                 /* Old version of JACK.
 982
 983                    These crude guesses, see below where we try to get the right answers.
 984
 985                    Note that our guess for MIDI deliberatey tries to overestimate
 986                    by a little. It would be nicer if we could get the actual
 987                    size from a port, but we have to use this estimate in the
 988                    event that there are no MIDI ports currently. If there are
 989                    the value will be adjusted below.
 990                 */
 991
 992                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 993                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 994         }
 995
 996         engine.buffer_size_change (nframes);
 997
 998         return 0;
 999 }
1000
1001 void
1002 JACKAudioBackend::disconnected (const char* why)
1003 {
1004         bool was_running = _running;
1005
1006         _running = false;
1007         _current_buffer_size = 0;
1008         _current_sample_rate = 0;
1009
1010         if (was_running) {
1011                 engine.halted_callback (why); /* EMIT SIGNAL */
1012         }
1013 }
1014
1015 float
1016 JACKAudioBackend::cpu_load() const
1017 {
1018         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
1019         return jack_cpu_load (_priv_jack);
1020 }
1021
1022 void
1023 JACKAudioBackend::update_latencies ()
1024 {
1025         GET_PRIVATE_JACK_POINTER (_priv_jack);
1026         jack_recompute_total_latencies (_priv_jack);
1027 }
1028
1029 ChanCount
1030 JACKAudioBackend::n_physical (unsigned long flags) const
1031 {
1032         ChanCount c;
1033
1034         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
1035
1036         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1037
1038         if (ports) {
1039                 for (uint32_t i = 0; ports[i]; ++i) {
1040                         if (!strstr (ports[i], "Midi-Through")) {
1041                                 DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
1042                                 if (t != DataType::NIL) {
1043                                         c.set (t, c.get (t) + 1);
1044                                 }
1045                         }
1046                 }
1047
1048                 jack_free (ports);
1049         }
1050
1051         return c;
1052 }
1053
1054 bool
1055 JACKAudioBackend::can_change_sample_rate_when_running () const
1056 {
1057         return false;
1058 }
1059
1060 bool
1061 JACKAudioBackend::can_change_buffer_size_when_running () const
1062 {
1063         return true;
1064 }
1065
1066 string
1067 JACKAudioBackend::control_app_name () const
1068 {
1069         /* Since JACK/ALSA really don't provide particularly integrated support
1070            for the idea of a control app to be used to control a device,
1071            allow the user to take some control themselves if necessary.
1072         */
1073
1074         const char* env_value  = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
1075         string appname;
1076
1077         if (!env_value) {
1078                 if (_target_driver.empty() || _target_device.empty()) {
1079                         return appname;
1080                 }
1081
1082                 if (_target_driver == "ALSA") {
1083
1084                         if (_target_device == "Hammerfall DSP") {
1085                                 appname = "hdspconf";
1086                         } else if (_target_device == "M Audio Delta 1010") {
1087                                 appname = "mudita24";
1088                         }
1089                 }
1090         } else {
1091                 appname = env_value;
1092         }
1093
1094         return appname;
1095 }
1096
1097 void
1098 JACKAudioBackend::launch_control_app ()
1099 {
1100         string appname = control_app_name();
1101
1102         if (appname.empty()) {
1103                 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1104                 return;
1105         }
1106
1107         std::list<string> args;
1108         args.push_back (appname);
1109         Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);
1110 }
1111
1112 vector<string>
1113 JACKAudioBackend::enumerate_midi_options () const
1114 {
1115         return ARDOUR::enumerate_midi_options ();
1116 }
1117
1118 int
1119 JACKAudioBackend::set_midi_option (const string& opt)
1120 {
1121         _target_midi_option = opt;
1122         return 0;
1123 }
1124
1125 bool
1126 JACKAudioBackend::speed_and_position (double& speed, framepos_t& position)
1127 {
1128         jack_position_t pos;
1129         jack_transport_state_t state;
1130         bool starting;
1131
1132         /* this won't be called if the port engine in use is not JACK, so we do
1133            not have to worry about the type of PortEngine::private_handle()
1134         */
1135
1136         speed = 0;
1137         position = 0;
1138
1139         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, true);
1140
1141         state = jack_transport_query (_priv_jack, &pos);
1142
1143         switch (state) {
1144         case JackTransportStopped:
1145                 speed = 0;
1146                 starting = false;
1147                 break;
1148         case JackTransportRolling:
1149                 speed = 1.0;
1150                 starting = false;
1151                 break;
1152         case JackTransportLooping:
1153                 speed = 1.0;
1154                 starting = false;
1155                 break;
1156         case JackTransportStarting:
1157                 starting = true;
1158                 // don't adjust speed here, just leave it as it was
1159                 break;
1160         default:
1161                 std::cerr << "WARNING: Unknown JACK transport state: " << state << std::endl;
1162         }
1163
1164         position = pos.frame;
1165         return starting;
1166 }