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