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