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