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_portengine.h"
  40 #include "jack_utils.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46 using std::string;
  47 using std::vector;
  48 using std::cerr;
  49 using std::endl;
  50
  51 #define GET_PRIVATE_JACK_POINTER(localvar)  jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return; }
  52 #define GET_PRIVATE_JACK_POINTER_RET(localvar,r) jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return r; }
  53
  54 JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnection> jc)
  55         : AudioBackend (e)
  56         , _jack_connection (jc)
  57         , _running (false)
  58         , _freewheeling (false)
  59         , _target_sample_rate (48000)
  60         , _target_buffer_size (1024)
  61         , _target_sample_format (FormatFloat)
  62         , _target_interleaved (false)
  63         , _target_input_channels (-1)
  64         , _target_output_channels (-1)
  65         , _target_systemic_input_latency (0)
  66         , _target_systemic_output_latency (0)
  67         , _current_sample_rate (0)
  68         , _current_buffer_size (0)
  69 {
  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::connected() 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 (connected()) {
 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 (connected()) {
 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 (connected()) {
 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 (!connected()) {
 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 (!connected()) {
 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 (connected()) {
 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 (connected()) {
 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 (connected()) {
 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 (connected()) {
 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 (connected()) {
 347                 return "???";
 348         }
 349
 350         return _target_device;
 351 }
 352
 353 float
 354 JACKAudioBackend::sample_rate () const
 355 {
 356         if (connected()) {
 357                 return _current_sample_rate;
 358         }
 359         return _target_sample_rate;
 360 }
 361
 362 uint32_t
 363 JACKAudioBackend::buffer_size () const
 364 {
 365         if (connected()) {
 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 (connected()) {
 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 (connected()) {
 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 */
 455                 return;
 456         }
 457
 458         std::cerr << "JACK command line will be: " << cmdline << std::endl;
 459
 460         write_jack_config_file (get_jack_server_user_config_file_path(), cmdline);
 461 }
 462
 463 /* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
 464
 465 int
 466 JACKAudioBackend::start ()
 467 {
 468         if (!connected()) {
 469
 470                 if (!_jack_connection->server_running()) {
 471                         setup_jack_startup_command ();
 472                 }
 473
 474                 if (_jack_connection->open ()) {
 475                         return -1;
 476                 }
 477         }
 478
 479         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 480
 481         /* get the buffer size and sample rates established */
 482
 483         jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
 484         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 485
 486         /* Now that we have buffer size and sample rate established, the engine
 487            can go ahead and do its stuff
 488         */
 489
 490         engine.reestablish_ports ();
 491
 492         if (!jack_port_type_get_buffer_size) {
 493                 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 494         }
 495
 496         set_jack_callbacks ();
 497
 498         if (jack_activate (_priv_jack) == 0) {
 499                 _running = true;
 500         } else {
 501                 // error << _("cannot activate JACK client") << endmsg;
 502         }
 503
 504         engine.reconnect_ports ();
 505
 506         return 0;
 507 }
 508
 509 int
 510 JACKAudioBackend::stop ()
 511 {
 512         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 513
 514         _jack_connection->close ();
 515
 516         _current_buffer_size = 0;
 517         _current_sample_rate = 0;
 518
 519         _raw_buffer_sizes.clear();
 520
 521         return 0;
 522 }
 523
 524 int
 525 JACKAudioBackend::pause ()
 526 {
 527         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 528
 529         if (_priv_jack) {
 530                 jack_deactivate (_priv_jack);
 531         }
 532
 533         return 0;
 534 }
 535
 536 int
 537 JACKAudioBackend::freewheel (bool onoff)
 538 {
 539         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 540
 541         if (onoff == _freewheeling) {
 542                 /* already doing what has been asked for */
 543
 544                 return 0;
 545         }
 546
 547         if (jack_set_freewheel (_priv_jack, onoff) == 0) {
 548                 _freewheeling = true;
 549                 return 0;
 550         }
 551
 552         return -1;
 553 }
 554
 555 /* --- TRANSPORT STATE MANAGEMENT --- */
 556
 557 void
 558 JACKAudioBackend::transport_stop ()
 559 {
 560         GET_PRIVATE_JACK_POINTER (_priv_jack);
 561         jack_transport_stop (_priv_jack);
 562 }
 563
 564 void
 565 JACKAudioBackend::transport_start ()
 566 {
 567         GET_PRIVATE_JACK_POINTER (_priv_jack);
 568         jack_transport_start (_priv_jack);
 569 }
 570
 571 void
 572 JACKAudioBackend::transport_locate (framepos_t where)
 573 {
 574         GET_PRIVATE_JACK_POINTER (_priv_jack);
 575         jack_transport_locate (_priv_jack, where);
 576 }
 577
 578 framepos_t
 579 JACKAudioBackend::transport_frame () const
 580 {
 581         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 582         return jack_get_current_transport_frame (_priv_jack);
 583 }
 584
 585 TransportState
 586 JACKAudioBackend::transport_state () const
 587 {
 588         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
 589         jack_position_t pos;
 590         return (TransportState) jack_transport_query (_priv_jack, &pos);
 591 }
 592
 593 int
 594 JACKAudioBackend::set_time_master (bool yn)
 595 {
 596         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 597         if (yn) {
 598                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 599         } else {
 600                 return jack_release_timebase (_priv_jack);
 601         }
 602 }
 603
 604 /* process-time */
 605
 606 bool
 607 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 608 {
 609
 610 #ifdef HAVE_JACK_VIDEO_SUPPORT
 611
 612         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
 613
 614         jack_position_t pos;
 615
 616         if (_priv_jack) {
 617                 (void) jack_transport_query (_priv_jack, &pos);
 618
 619                 if (pos.valid & JackVideoFrameOffset) {
 620                         offset = pos.video_offset;
 621                         return true;
 622                 }
 623         }
 624 #else
 625         /* keep gcc happy */
 626         offset = 0;
 627 #endif
 628
 629         return false;
 630 }
 631
 632 pframes_t
 633 JACKAudioBackend::sample_time ()
 634 {
 635         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 636         return jack_frame_time (_priv_jack);
 637 }
 638
 639 pframes_t
 640 JACKAudioBackend::sample_time_at_cycle_start ()
 641 {
 642         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 643         return jack_last_frame_time (_priv_jack);
 644 }
 645
 646 pframes_t
 647 JACKAudioBackend::samples_since_cycle_start ()
 648 {
 649         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 650         return jack_frames_since_cycle_start (_priv_jack);
 651 }
 652
 653 /* JACK Callbacks */
 654
 655 static void
 656 ardour_jack_error (const char* msg)
 657 {
 658         error << "JACK: " << msg << endmsg;
 659 }
 660
 661 void
 662 JACKAudioBackend::set_jack_callbacks ()
 663 {
 664         GET_PRIVATE_JACK_POINTER (_priv_jack);
 665
 666         jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
 667
 668         jack_set_process_thread (_priv_jack, _process_thread, this);
 669         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 670         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 671         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 672         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 673         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 674
 675 #ifdef HAVE_JACK_SESSION
 676         if( jack_set_session_callback)
 677                 jack_set_session_callback (_priv_jack, _session_callback, this);
 678 #endif
 679
 680         if (jack_set_latency_callback) {
 681                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 682         }
 683
 684         jack_set_error_function (ardour_jack_error);
 685 }
 686
 687 void
 688 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 689                                       jack_position_t* pos, int new_position, void *arg)
 690 {
 691         static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 692 }
 693
 694 void
 695 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 696                                           jack_position_t* pos, int new_position)
 697 {
 698         ARDOUR::Session* session = engine.session();
 699
 700         if (session) {
 701                 session->jack_timebase_callback (state, nframes, pos, new_position);
 702         }
 703 }
 704
 705 int
 706 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 707 {
 708         return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
 709 }
 710
 711 int
 712 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 713 {
 714         TransportState tstate;
 715
 716         switch (state) {
 717         case JackTransportStopped:
 718                 tstate = TransportStopped;
 719                 break;
 720         case JackTransportRolling:
 721                 tstate = TransportRolling;
 722                 break;
 723         case JackTransportLooping:
 724                 tstate = TransportLooping;
 725                 break;
 726         case JackTransportStarting:
 727                 tstate = TransportStarting;
 728                 break;
 729         }
 730
 731         return engine.sync_callback (tstate, pos->frame);
 732
 733         return true;
 734 }
 735
 736 int
 737 JACKAudioBackend::_xrun_callback (void *arg)
 738 {
 739         JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
 740         if (ae->connected()) {
 741                 ae->engine.Xrun (); /* EMIT SIGNAL */
 742         }
 743         return 0;
 744 }
 745
 746 #ifdef HAVE_JACK_SESSION
 747 void
 748 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 749 {
 750         JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
 751         ARDOUR::Session* session = ae->engine.session();
 752
 753         if (session) {
 754                 session->jack_session_event (event);
 755         }
 756 }
 757 #endif
 758
 759 void
 760 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 761 {
 762         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 763 }
 764
 765 void
 766 JACKAudioBackend::freewheel_callback (int onoff)
 767 {
 768         _freewheeling = onoff;
 769         engine.freewheel_callback (onoff);
 770 }
 771
 772 void
 773 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 774 {
 775         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 776 }
 777
 778 int
 779 JACKAudioBackend::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
 780 {
 781         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 782         ThreadData* td = new ThreadData (this, f, stacksize);
 783
 784         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
 785                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 786                 return -1;
 787         }
 788
 789         return 0;
 790 }
 791
 792 int
 793 JACKAudioBackend::wait_for_process_thread_exit (AudioBackendNativeThread thr)
 794 {
 795         void* status;
 796         /* this doesn't actively try to stop the thread, it just waits till it exits */
 797         return pthread_join (thr, &status);
 798 }
 799
 800 void*
 801 JACKAudioBackend::_start_process_thread (void* arg)
 802 {
 803         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 804         boost::function<void()> f = td->f;
 805         delete td;
 806
 807         f ();
 808
 809         return 0;
 810 }
 811
 812 void*
 813 JACKAudioBackend::_process_thread (void *arg)
 814 {
 815         return static_cast<JACKAudioBackend*> (arg)->process_thread ();
 816 }
 817
 818 void*
 819 JACKAudioBackend::process_thread ()
 820 {
 821         /* JACK doesn't do this for us when we use the wait API
 822          */
 823
 824         AudioEngine::thread_init_callback (this);
 825
 826         while (1) {
 827                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 828
 829                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 830
 831                 if (engine.process_callback (nframes)) {
 832                         return 0;
 833                 }
 834
 835                 jack_cycle_signal (_priv_jack, 0);
 836         }
 837
 838         return 0;
 839 }
 840
 841 int
 842 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 843 {
 844         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 845 }
 846
 847 int
 848 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 849 {
 850         _current_sample_rate = nframes;
 851         return engine.sample_rate_change (nframes);
 852 }
 853
 854 void
 855 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 856 {
 857         engine.latency_callback (mode == JackPlaybackLatency);
 858 }
 859
 860 int
 861 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 862 {
 863         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 864 }
 865
 866 int
 867 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 868 {
 869         /* if the size has not changed, this should be a no-op */
 870
 871         if (nframes == _current_buffer_size) {
 872                 return 0;
 873         }
 874
 875         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 876
 877         _current_buffer_size = nframes;
 878
 879         if (jack_port_type_get_buffer_size) {
 880                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 881                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 882         } else {
 883
 884                 /* Old version of JACK.
 885
 886                    These crude guesses, see below where we try to get the right answers.
 887
 888                    Note that our guess for MIDI deliberatey tries to overestimate
 889                    by a little. It would be nicer if we could get the actual
 890                    size from a port, but we have to use this estimate in the
 891                    event that there are no MIDI ports currently. If there are
 892                    the value will be adjusted below.
 893                 */
 894
 895                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 896                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 897         }
 898
 899         engine.buffer_size_change (nframes);
 900
 901         return 0;
 902 }
 903
 904 void
 905 JACKAudioBackend::disconnected (const char* why)
 906 {
 907         bool was_running = _running;
 908
 909         _running = false;
 910         _current_buffer_size = 0;
 911         _current_sample_rate = 0;
 912
 913         if (was_running) {
 914                 engine.halted_callback (why); /* EMIT SIGNAL */
 915         }
 916 }
 917 float
 918 JACKAudioBackend::cpu_load() const
 919 {
 920         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 921         return jack_cpu_load (_priv_jack);
 922 }
 923
 924 void
 925 JACKAudioBackend::update_latencies ()
 926 {
 927         GET_PRIVATE_JACK_POINTER (_priv_jack);
 928         jack_recompute_total_latencies (_priv_jack);
 929 }
 930
 931 ChanCount
 932 JACKAudioBackend::n_physical (unsigned long flags) const
 933 {
 934         ChanCount c;
 935
 936         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
 937
 938         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
 939
 940         if (ports) {
 941                 for (uint32_t i = 0; ports[i]; ++i) {
 942                         if (!strstr (ports[i], "Midi-Through")) {
 943                                 DataType t (jack_port_type (jack_port_by_name (_priv_jack, ports[i])));
 944                                 c.set (t, c.get (t) + 1);
 945                         }
 946                 }
 947
 948                 jack_free (ports);
 949         }
 950
 951         return c;
 952 }
 953
 954 bool
 955 JACKAudioBackend::can_change_sample_rate_when_running () const
 956 {
 957         return false;
 958 }
 959
 960 bool
 961 JACKAudioBackend::can_change_buffer_size_when_running () const
 962 {
 963         return true;
 964 }
 965
 966 string
 967 JACKAudioBackend::control_app_name () const
 968 {
 969         /* Since JACK/ALSA really don't provide particularly integrated support
 970            for the idea of a control app to be used to control a device,
 971            allow the user to take some control themselves if necessary.
 972         */
 973
 974         const char* env_value  = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
 975         string appname;
 976
 977         if (!env_value) {
 978                 if (_target_driver.empty() || _target_device.empty()) {
 979                         return appname;
 980                 }
 981
 982                 if (_target_driver == "ALSA") {
 983
 984                         if (_target_device == "Hammerfall DSP") {
 985                                 appname = "hdspconf";
 986                         } else if (_target_device == "M Audio Delta 1010") {
 987                                 appname = "mudita24";
 988                         }
 989                 }
 990         } else {
 991                 appname = env_value;
 992         }
 993
 994         return appname;
 995 }
 996
 997 void
 998 JACKAudioBackend::launch_control_app ()
 999 {
1000         string appname = control_app_name();
1001
1002         if (appname.empty()) {
1003                 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1004                 return;
1005         }
1006
1007         std::list<string> args;
1008         args.push_back (appname);
1009         Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);
1010 }