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