libs/backends/jack/jack_audiobackend.cc

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