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