libs/backends/jack/jack_audiobackend.cc

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