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