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