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->in_control()) {
 517                         /* we will be starting JACK, so set up the
 518                            command that JACK will use when it (auto-)starts
 519                         */
 520                         setup_jack_startup_command ();
 521                 }
 522
 523                 if (_jack_connection->open ()) {
 524                         return -1;
 525                 }
 526         }
 527
 528         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 529
 530         /* get the buffer size and sample rates established */
 531
 532         jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
 533         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 534
 535         /* Now that we have buffer size and sample rate established, the engine
 536            can go ahead and do its stuff
 537         */
 538
 539         engine.reestablish_ports ();
 540
 541         if (!jack_port_type_get_buffer_size) {
 542                 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 543         }
 544
 545         set_jack_callbacks ();
 546
 547         if (jack_activate (_priv_jack) == 0) {
 548                 _running = true;
 549         } else {
 550                 // error << _("cannot activate JACK client") << endmsg;
 551         }
 552
 553         engine.reconnect_ports ();
 554
 555         return 0;
 556 }
 557
 558 int
 559 JACKAudioBackend::stop ()
 560 {
 561         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 562
 563         _jack_connection->close ();
 564
 565         _current_buffer_size = 0;
 566         _current_sample_rate = 0;
 567
 568         _raw_buffer_sizes.clear();
 569
 570         return 0;
 571 }
 572
 573 int
 574 JACKAudioBackend::pause ()
 575 {
 576         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 577
 578         if (_priv_jack) {
 579                 jack_deactivate (_priv_jack);
 580         }
 581
 582         return 0;
 583 }
 584
 585 int
 586 JACKAudioBackend::freewheel (bool onoff)
 587 {
 588         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 589
 590         if (onoff == _freewheeling) {
 591                 /* already doing what has been asked for */
 592
 593                 return 0;
 594         }
 595
 596         if (jack_set_freewheel (_priv_jack, onoff) == 0) {
 597                 _freewheeling = true;
 598                 return 0;
 599         }
 600
 601         return -1;
 602 }
 603
 604 /* --- TRANSPORT STATE MANAGEMENT --- */
 605
 606 void
 607 JACKAudioBackend::transport_stop ()
 608 {
 609         GET_PRIVATE_JACK_POINTER (_priv_jack);
 610         jack_transport_stop (_priv_jack);
 611 }
 612
 613 void
 614 JACKAudioBackend::transport_start ()
 615 {
 616         GET_PRIVATE_JACK_POINTER (_priv_jack);
 617         jack_transport_start (_priv_jack);
 618 }
 619
 620 void
 621 JACKAudioBackend::transport_locate (framepos_t where)
 622 {
 623         GET_PRIVATE_JACK_POINTER (_priv_jack);
 624         jack_transport_locate (_priv_jack, where);
 625 }
 626
 627 framepos_t
 628 JACKAudioBackend::transport_frame () const
 629 {
 630         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 631         return jack_get_current_transport_frame (_priv_jack);
 632 }
 633
 634 TransportState
 635 JACKAudioBackend::transport_state () const
 636 {
 637         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
 638         jack_position_t pos;
 639         return (TransportState) jack_transport_query (_priv_jack, &pos);
 640 }
 641
 642 int
 643 JACKAudioBackend::set_time_master (bool yn)
 644 {
 645         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 646         if (yn) {
 647                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 648         } else {
 649                 return jack_release_timebase (_priv_jack);
 650         }
 651 }
 652
 653 /* process-time */
 654
 655 bool
 656 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 657 {
 658
 659 #ifdef HAVE_JACK_VIDEO_SUPPORT
 660
 661         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
 662
 663         jack_position_t pos;
 664
 665         if (_priv_jack) {
 666                 (void) jack_transport_query (_priv_jack, &pos);
 667
 668                 if (pos.valid & JackVideoFrameOffset) {
 669                         offset = pos.video_offset;
 670                         return true;
 671                 }
 672         }
 673 #else
 674         /* keep gcc happy */
 675         offset = 0;
 676 #endif
 677
 678         return false;
 679 }
 680
 681 pframes_t
 682 JACKAudioBackend::sample_time ()
 683 {
 684         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 685         return jack_frame_time (_priv_jack);
 686 }
 687
 688 pframes_t
 689 JACKAudioBackend::sample_time_at_cycle_start ()
 690 {
 691         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 692         return jack_last_frame_time (_priv_jack);
 693 }
 694
 695 pframes_t
 696 JACKAudioBackend::samples_since_cycle_start ()
 697 {
 698         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 699         return jack_frames_since_cycle_start (_priv_jack);
 700 }
 701
 702 /* JACK Callbacks */
 703
 704 static void
 705 ardour_jack_error (const char* msg)
 706 {
 707         error << "JACK: " << msg << endmsg;
 708 }
 709
 710 void
 711 JACKAudioBackend::set_jack_callbacks ()
 712 {
 713         GET_PRIVATE_JACK_POINTER (_priv_jack);
 714
 715         jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
 716
 717         jack_set_process_thread (_priv_jack, _process_thread, this);
 718         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 719         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 720         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 721         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 722         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 723
 724 #ifdef HAVE_JACK_SESSION
 725         if( jack_set_session_callback)
 726                 jack_set_session_callback (_priv_jack, _session_callback, this);
 727 #endif
 728
 729         if (jack_set_latency_callback) {
 730                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 731         }
 732
 733         jack_set_error_function (ardour_jack_error);
 734 }
 735
 736 void
 737 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 738                                       jack_position_t* pos, int new_position, void *arg)
 739 {
 740         static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 741 }
 742
 743 void
 744 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 745                                           jack_position_t* pos, int new_position)
 746 {
 747         ARDOUR::Session* session = engine.session();
 748
 749         if (session) {
 750                 session->jack_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 #ifdef HAVE_JACK_SESSION
 796 void
 797 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 798 {
 799         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 800         ARDOUR::Session* session = jab->engine.session();
 801
 802         if (session) {
 803                 session->jack_session_event (event);
 804         }
 805 }
 806 #endif
 807
 808 void
 809 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 810 {
 811         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 812 }
 813
 814 void
 815 JACKAudioBackend::freewheel_callback (int onoff)
 816 {
 817         _freewheeling = onoff;
 818         engine.freewheel_callback (onoff);
 819 }
 820
 821 void
 822 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 823 {
 824         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 825 }
 826
 827 int
 828 JACKAudioBackend::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
 829 {
 830         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 831         ThreadData* td = new ThreadData (this, f, stacksize);
 832
 833         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
 834                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 835                 return -1;
 836         }
 837
 838         return 0;
 839 }
 840
 841 int
 842 JACKAudioBackend::wait_for_process_thread_exit (AudioBackendNativeThread thr)
 843 {
 844         void* status;
 845         /* this doesn't actively try to stop the thread, it just waits till it exits */
 846         return pthread_join (thr, &status);
 847 }
 848
 849 void*
 850 JACKAudioBackend::_start_process_thread (void* arg)
 851 {
 852         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 853         boost::function<void()> f = td->f;
 854         delete td;
 855
 856         f ();
 857
 858         return 0;
 859 }
 860
 861 void*
 862 JACKAudioBackend::_process_thread (void *arg)
 863 {
 864         return static_cast<JACKAudioBackend*> (arg)->process_thread ();
 865 }
 866
 867 void*
 868 JACKAudioBackend::process_thread ()
 869 {
 870         /* JACK doesn't do this for us when we use the wait API
 871          */
 872
 873         AudioEngine::thread_init_callback (this);
 874
 875         while (1) {
 876                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 877
 878                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 879
 880                 if (engine.process_callback (nframes)) {
 881                         return 0;
 882                 }
 883
 884                 jack_cycle_signal (_priv_jack, 0);
 885         }
 886
 887         return 0;
 888 }
 889
 890 int
 891 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 892 {
 893         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 894 }
 895
 896 int
 897 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 898 {
 899         _current_sample_rate = nframes;
 900         return engine.sample_rate_change (nframes);
 901 }
 902
 903 void
 904 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 905 {
 906         engine.latency_callback (mode == JackPlaybackLatency);
 907 }
 908
 909 int
 910 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 911 {
 912         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 913 }
 914
 915 int
 916 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 917 {
 918         /* if the size has not changed, this should be a no-op */
 919
 920         if (nframes == _current_buffer_size) {
 921                 return 0;
 922         }
 923
 924         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 925
 926         _current_buffer_size = nframes;
 927
 928         if (jack_port_type_get_buffer_size) {
 929                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 930                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 931         } else {
 932
 933                 /* Old version of JACK.
 934
 935                    These crude guesses, see below where we try to get the right answers.
 936
 937                    Note that our guess for MIDI deliberatey tries to overestimate
 938                    by a little. It would be nicer if we could get the actual
 939                    size from a port, but we have to use this estimate in the
 940                    event that there are no MIDI ports currently. If there are
 941                    the value will be adjusted below.
 942                 */
 943
 944                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 945                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 946         }
 947
 948         engine.buffer_size_change (nframes);
 949
 950         return 0;
 951 }
 952
 953 void
 954 JACKAudioBackend::disconnected (const char* why)
 955 {
 956         bool was_running = _running;
 957
 958         _running = false;
 959         _current_buffer_size = 0;
 960         _current_sample_rate = 0;
 961
 962         if (was_running) {
 963                 engine.halted_callback (why); /* EMIT SIGNAL */
 964         }
 965 }
 966
 967 float
 968 JACKAudioBackend::cpu_load() const
 969 {
 970         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 971         return jack_cpu_load (_priv_jack);
 972 }
 973
 974 void
 975 JACKAudioBackend::update_latencies ()
 976 {
 977         GET_PRIVATE_JACK_POINTER (_priv_jack);
 978         jack_recompute_total_latencies (_priv_jack);
 979 }
 980
 981 ChanCount
 982 JACKAudioBackend::n_physical (unsigned long flags) const
 983 {
 984         ChanCount c;
 985
 986         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
 987
 988         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
 989
 990         if (ports) {
 991                 for (uint32_t i = 0; ports[i]; ++i) {
 992                         if (!strstr (ports[i], "Midi-Through")) {
 993                                 DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
 994                                 if (t != DataType::NIL) {
 995                                         c.set (t, c.get (t) + 1);
 996                                 }
 997                         }
 998                 }
 999
1000                 jack_free (ports);
1001         }
1002
1003         return c;
1004 }
1005
1006 bool
1007 JACKAudioBackend::can_change_sample_rate_when_running () const
1008 {
1009         return false;
1010 }
1011
1012 bool
1013 JACKAudioBackend::can_change_buffer_size_when_running () const
1014 {
1015         return true;
1016 }
1017
1018 string
1019 JACKAudioBackend::control_app_name () const
1020 {
1021         /* Since JACK/ALSA really don't provide particularly integrated support
1022            for the idea of a control app to be used to control a device,
1023            allow the user to take some control themselves if necessary.
1024         */
1025
1026         const char* env_value  = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
1027         string appname;
1028
1029         if (!env_value) {
1030                 if (_target_driver.empty() || _target_device.empty()) {
1031                         return appname;
1032                 }
1033
1034                 if (_target_driver == "ALSA") {
1035
1036                         if (_target_device == "Hammerfall DSP") {
1037                                 appname = "hdspconf";
1038                         } else if (_target_device == "M Audio Delta 1010") {
1039                                 appname = "mudita24";
1040                         }
1041                 }
1042         } else {
1043                 appname = env_value;
1044         }
1045
1046         return appname;
1047 }
1048
1049 void
1050 JACKAudioBackend::launch_control_app ()
1051 {
1052         string appname = control_app_name();
1053
1054         if (appname.empty()) {
1055                 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1056                 return;
1057         }
1058
1059         std::list<string> args;
1060         args.push_back (appname);
1061         Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);
1062 }