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 #include "jack_session.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46 using std::string;
  47 using std::vector;
  48
  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_interleaved (false)
  61         , _target_input_channels (0)
  62         , _target_output_channels (0)
  63         , _target_systemic_input_latency (0)
  64         , _target_systemic_output_latency (0)
  65         , _current_sample_rate (0)
  66         , _current_buffer_size (0)
  67         , _session (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 (device == _target_device && 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 (device == _target_device && 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_interleaved (bool yn)
 271 {
 272         /* as far as JACK clients are concerned, the hardware is always
 273          * non-interleaved
 274          */
 275         if (!yn) {
 276                 return 0;
 277         }
 278         return -1;
 279 }
 280
 281 int
 282 JACKAudioBackend::set_input_channels (uint32_t cnt)
 283 {
 284         if (available()) {
 285                 if (cnt != 0) {
 286                         /* can't set a real value for this while JACK runs */
 287                         return -1;
 288                 }
 289         }
 290
 291         _target_input_channels = cnt;
 292
 293         return 0;
 294 }
 295
 296 int
 297 JACKAudioBackend::set_output_channels (uint32_t cnt)
 298 {
 299         if (available()) {
 300                 if (cnt != 0) {
 301                         /* can't set a real value for this while JACK runs */
 302                         return -1;
 303                 }
 304         }
 305
 306         _target_output_channels = cnt;
 307
 308         return 0;
 309 }
 310
 311 int
 312 JACKAudioBackend::set_systemic_input_latency (uint32_t l)
 313 {
 314         if (available()) {
 315                 /* can't do this while JACK runs */
 316                 return -1;
 317         }
 318
 319         _target_systemic_input_latency = l;
 320
 321         return 0;
 322 }
 323
 324 int
 325 JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 326 {
 327         if (available()) {
 328                 /* can't do this while JACK runs */
 329                 return -1;
 330         }
 331
 332         _target_systemic_output_latency = l;
 333
 334         return 0;
 335 }
 336
 337 /* --- Parameter retrieval --- */
 338
 339 std::string
 340 JACKAudioBackend::device_name () const
 341 {
 342         if (!_jack_connection->in_control()) {
 343                 return "???"; // JACK has no way (as of fall 2013) to return
 344                               // the device name
 345         }
 346
 347         return _target_device;
 348 }
 349
 350 std::string
 351 JACKAudioBackend::driver_name() const
 352 {
 353         if (!_jack_connection->in_control()) {
 354                 return "???"; // JACK has no way (as of fall 2013) to return
 355                               // the driver name
 356         }
 357
 358         return _target_driver;
 359 }
 360
 361 float
 362 JACKAudioBackend::sample_rate () const
 363 {
 364         if (!_jack_connection->in_control()) {
 365                 if (available()) {
 366                         return _current_sample_rate;
 367                 } else {
 368                         return 0;
 369                 }
 370         }
 371         return _target_sample_rate;
 372 }
 373
 374 uint32_t
 375 JACKAudioBackend::buffer_size () const
 376 {
 377         if (!_jack_connection->in_control()) {
 378                 if (available()) {
 379                         return _current_buffer_size;
 380                 } else {
 381                         return 0;
 382                 }
 383         }
 384         return _target_buffer_size;
 385 }
 386
 387 bool
 388 JACKAudioBackend::interleaved () const
 389 {
 390         return false;
 391 }
 392
 393 string
 394 JACKAudioBackend::midi_option () const
 395 {
 396         return _target_midi_option;
 397 }
 398
 399 uint32_t
 400 JACKAudioBackend::input_channels () const
 401 {
 402         if (!_jack_connection->in_control()) {
 403                 if (available()) {
 404                         return n_physical (JackPortIsInput).n_audio();
 405                 } else {
 406                         return 0;
 407                 }
 408         } else {
 409                 if (available()) {
 410                         return n_physical (JackPortIsInput).n_audio();
 411                 } else {
 412                         return _target_input_channels;
 413                 }
 414         }
 415 }
 416
 417 uint32_t
 418 JACKAudioBackend::output_channels () const
 419 {
 420         if (!_jack_connection->in_control()) {
 421                 if (available()) {
 422                         return n_physical (JackPortIsOutput).n_audio();
 423                 } else {
 424                         return 0;
 425                 }
 426         } else {
 427                 if (available()) {
 428                         return n_physical (JackPortIsOutput).n_audio();
 429                 } else {
 430                         return _target_output_channels;
 431                 }
 432         }
 433 }
 434
 435 uint32_t
 436 JACKAudioBackend::systemic_input_latency () const
 437 {
 438         return _target_systemic_output_latency;
 439 }
 440
 441 uint32_t
 442 JACKAudioBackend::systemic_output_latency () const
 443 {
 444         return _target_systemic_output_latency;
 445 }
 446
 447 size_t
 448 JACKAudioBackend::raw_buffer_size(DataType t)
 449 {
 450         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 451         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 452 }
 453
 454 void
 455 JACKAudioBackend::setup_jack_startup_command (bool for_latency_measurement)
 456 {
 457         /* first we map the parameters that have been set onto a
 458          * JackCommandLineOptions object.
 459          */
 460
 461         JackCommandLineOptions options;
 462
 463         get_jack_default_server_path (options.server_path);
 464         options.driver = _target_driver;
 465         options.samplerate = _target_sample_rate;
 466         options.period_size = _target_buffer_size;
 467         options.num_periods = 2;
 468         options.input_device = _target_device;
 469         options.output_device = _target_device;
 470         options.input_latency = _target_systemic_input_latency;
 471         options.output_latency = _target_systemic_output_latency;
 472         options.input_channels = _target_input_channels;
 473         options.output_channels = _target_output_channels;
 474         if (_target_sample_format == FormatInt16) {
 475                 options.force16_bit = _target_sample_format;
 476         }
 477         options.realtime = true;
 478         options.ports_max = 2048;
 479
 480         ARDOUR::set_midi_option (options, _target_midi_option);
 481
 482         /* this must always be true for any server instance we start ourselves
 483          */
 484
 485         options.temporary = true;
 486
 487         string cmdline;
 488
 489         if (!get_jack_command_line_string (options, cmdline, for_latency_measurement)) {
 490                 /* error, somehow - we will still try to start JACK
 491                  * automatically but it will be without our preferred options
 492                  */
 493                 std::cerr << "get_jack_command_line_string () failed: using default settings." << std::endl;
 494                 return;
 495         }
 496
 497         std::cerr << "JACK command line will be: " << cmdline << std::endl;
 498
 499         write_jack_config_file (get_jack_server_user_config_file_path(), cmdline);
 500 }
 501
 502 /* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
 503
 504 int
 505 JACKAudioBackend::_start (bool for_latency_measurement)
 506 {
 507         if (!available()) {
 508
 509                 if (_jack_connection->in_control()) {
 510                         /* we will be starting JACK, so set up the
 511                            command that JACK will use when it (auto-)starts
 512                         */
 513                         setup_jack_startup_command (for_latency_measurement);
 514                 }
 515
 516                 if (_jack_connection->open ()) {
 517                         return -1;
 518                 }
 519         }
 520
 521         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 522
 523         /* get the buffer size and sample rates established */
 524
 525         jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
 526         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 527
 528         /* Now that we have buffer size and sample rate established, the engine
 529            can go ahead and do its stuff
 530         */
 531
 532         if (engine.reestablish_ports ()) {
 533                 error << _("Could not re-establish ports after connecting to JACK") << endmsg;
 534                 return -1;
 535         }
 536
 537         if (!jack_port_type_get_buffer_size) {
 538                 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 539         }
 540
 541         set_jack_callbacks ();
 542
 543         if (jack_activate (_priv_jack) == 0) {
 544                 _running = true;
 545         } else {
 546                 // error << _("cannot activate JACK client") << endmsg;
 547         }
 548
 549         engine.reconnect_ports ();
 550
 551         return 0;
 552 }
 553
 554 int
 555 JACKAudioBackend::stop ()
 556 {
 557         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 558
 559         _jack_connection->close ();
 560
 561         _current_buffer_size = 0;
 562         _current_sample_rate = 0;
 563
 564         _raw_buffer_sizes.clear();
 565
 566         return 0;
 567 }
 568
 569 int
 570 JACKAudioBackend::freewheel (bool onoff)
 571 {
 572         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 573
 574         if (onoff == _freewheeling) {
 575                 /* already doing what has been asked for */
 576
 577                 return 0;
 578         }
 579
 580         if (jack_set_freewheel (_priv_jack, onoff) == 0) {
 581                 _freewheeling = onoff;
 582                 return 0;
 583         }
 584
 585         return -1;
 586 }
 587
 588 /* --- TRANSPORT STATE MANAGEMENT --- */
 589
 590 void
 591 JACKAudioBackend::transport_stop ()
 592 {
 593         GET_PRIVATE_JACK_POINTER (_priv_jack);
 594         jack_transport_stop (_priv_jack);
 595 }
 596
 597 void
 598 JACKAudioBackend::transport_start ()
 599 {
 600         GET_PRIVATE_JACK_POINTER (_priv_jack);
 601         jack_transport_start (_priv_jack);
 602 }
 603
 604 void
 605 JACKAudioBackend::transport_locate (framepos_t where)
 606 {
 607         GET_PRIVATE_JACK_POINTER (_priv_jack);
 608         jack_transport_locate (_priv_jack, where);
 609 }
 610
 611 framepos_t
 612 JACKAudioBackend::transport_frame () const
 613 {
 614         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 615         return jack_get_current_transport_frame (_priv_jack);
 616 }
 617
 618 TransportState
 619 JACKAudioBackend::transport_state () const
 620 {
 621         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
 622         jack_position_t pos;
 623         return (TransportState) jack_transport_query (_priv_jack, &pos);
 624 }
 625
 626 int
 627 JACKAudioBackend::set_time_master (bool yn)
 628 {
 629         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 630         if (yn) {
 631                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 632         } else {
 633                 return jack_release_timebase (_priv_jack);
 634         }
 635 }
 636
 637 /* process-time */
 638
 639 bool
 640 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 641 {
 642
 643 #ifdef HAVE_JACK_VIDEO_SUPPORT
 644
 645         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
 646
 647         jack_position_t pos;
 648
 649         if (_priv_jack) {
 650                 (void) jack_transport_query (_priv_jack, &pos);
 651
 652                 if (pos.valid & JackVideoFrameOffset) {
 653                         offset = pos.video_offset;
 654                         return true;
 655                 }
 656         }
 657 #else
 658         /* keep gcc happy */
 659         offset = 0;
 660 #endif
 661
 662         return false;
 663 }
 664
 665 pframes_t
 666 JACKAudioBackend::sample_time ()
 667 {
 668         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 669         return jack_frame_time (_priv_jack);
 670 }
 671
 672 pframes_t
 673 JACKAudioBackend::sample_time_at_cycle_start ()
 674 {
 675         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 676         return jack_last_frame_time (_priv_jack);
 677 }
 678
 679 pframes_t
 680 JACKAudioBackend::samples_since_cycle_start ()
 681 {
 682         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
 683         return jack_frames_since_cycle_start (_priv_jack);
 684 }
 685
 686 /* JACK Callbacks */
 687
 688 static void
 689 ardour_jack_error (const char* msg)
 690 {
 691         error << "JACK: " << msg << endmsg;
 692 }
 693
 694 void
 695 JACKAudioBackend::set_jack_callbacks ()
 696 {
 697         GET_PRIVATE_JACK_POINTER (_priv_jack);
 698
 699         jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
 700
 701         jack_set_process_thread (_priv_jack, _process_thread, this);
 702         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 703         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 704         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 705         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 706         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 707
 708 #ifdef HAVE_JACK_SESSION
 709         if( jack_set_session_callback)
 710                 jack_set_session_callback (_priv_jack, _session_callback, this);
 711 #endif
 712
 713         if (jack_set_latency_callback) {
 714                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 715         }
 716
 717         jack_set_error_function (ardour_jack_error);
 718 }
 719
 720 void
 721 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 722                                       jack_position_t* pos, int new_position, void *arg)
 723 {
 724         static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 725 }
 726
 727 void
 728 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 729                                           jack_position_t* pos, int new_position)
 730 {
 731         ARDOUR::Session* session = engine.session();
 732
 733         if (session) {
 734                 JACKSession jsession (session);
 735                 jsession.timebase_callback (state, nframes, pos, new_position);
 736         }
 737 }
 738
 739 int
 740 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 741 {
 742         return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
 743 }
 744
 745 int
 746 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 747 {
 748         TransportState tstate;
 749         bool tstate_valid = true;
 750
 751         switch (state) {
 752         case JackTransportRolling:
 753                 tstate = TransportRolling;
 754                 break;
 755         case JackTransportLooping:
 756                 tstate = TransportLooping;
 757                 break;
 758         case JackTransportStarting:
 759                 tstate = TransportStarting;
 760                 break;
 761         case JackTransportStopped:
 762                 tstate = TransportStopped;
 763                 break;
 764         default:
 765                 // ignore "unofficial" states like JackTransportNetStarting (jackd2)
 766                 tstate_valid = false;
 767                 break;
 768         }
 769
 770         if (tstate_valid) {
 771                 return engine.sync_callback (tstate, pos->frame);
 772         }
 773
 774         return true;
 775 }
 776
 777 int
 778 JACKAudioBackend::_xrun_callback (void *arg)
 779 {
 780         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 781         if (jab->available()) {
 782                 jab->engine.Xrun (); /* EMIT SIGNAL */
 783         }
 784         return 0;
 785 }
 786
 787 void
 788 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 789 {
 790         JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
 791         ARDOUR::Session* session = jab->engine.session();
 792
 793         if (session) {
 794                 JACKSession jsession (session);
 795                 jsession.session_event (event);
 796         }
 797 }
 798
 799 void
 800 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 801 {
 802         static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
 803 }
 804
 805 void
 806 JACKAudioBackend::freewheel_callback (int onoff)
 807 {
 808         _freewheeling = onoff;
 809         engine.freewheel_callback (onoff);
 810 }
 811
 812 void
 813 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 814 {
 815         return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
 816 }
 817
 818 int
 819 JACKAudioBackend::create_process_thread (boost::function<void()> f)
 820 {
 821         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 822
 823         jack_native_thread_t thread_id;
 824         ThreadData* td = new ThreadData (this, f, thread_stack_size());
 825
 826         if (jack_client_create_thread (_priv_jack, &thread_id, jack_client_real_time_priority (_priv_jack),
 827                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 828                 return -1;
 829         }
 830
 831         _jack_threads.push_back(thread_id);
 832         return 0;
 833 }
 834
 835 int
 836 JACKAudioBackend::join_process_threads ()
 837 {
 838         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
 839
 840         int ret = 0;
 841
 842         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 843              i != _jack_threads.end(); i++) {
 844
 845 #if defined(USING_JACK2_EXPANSION_OF_JACK_API) || defined(PLATFORM_WINDOWS)
 846                 if (jack_client_stop_thread (_priv_jack, *i) != 0) {
 847 #else
 848                 void* status;
 849                 if (pthread_join (*i, &status) != 0) {
 850 #endif
 851                         error << "AudioEngine: cannot stop process thread" << endmsg;
 852                         ret += -1;
 853                 }
 854         }
 855
 856         _jack_threads.clear();
 857
 858         return ret;
 859 }
 860
 861 bool
 862 JACKAudioBackend::in_process_thread ()
 863 {
 864         for (std::vector<jack_native_thread_t>::const_iterator i = _jack_threads.begin ();
 865              i != _jack_threads.end(); i++) {
 866
 867 #ifdef COMPILER_MINGW
 868                 if (*i == GetCurrentThread()) {
 869                         return true;
 870                 }
 871 #else // pthreads
 872                 if (pthread_equal (*i, pthread_self()) != 0) {
 873                         return true;
 874                 }
 875 #endif
 876         }
 877
 878         return false;
 879 }
 880
 881 uint32_t
 882 JACKAudioBackend::process_thread_count ()
 883 {
 884         return _jack_threads.size();
 885 }
 886
 887 void*
 888 JACKAudioBackend::_start_process_thread (void* arg)
 889 {
 890         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 891         boost::function<void()> f = td->f;
 892         delete td;
 893
 894         f ();
 895
 896         return 0;
 897 }
 898
 899 void*
 900 JACKAudioBackend::_process_thread (void *arg)
 901 {
 902         return static_cast<JACKAudioBackend*> (arg)->process_thread ();
 903 }
 904
 905 void*
 906 JACKAudioBackend::process_thread ()
 907 {
 908         /* JACK doesn't do this for us when we use the wait API
 909          */
 910
 911         AudioEngine::thread_init_callback (this);
 912
 913         while (1) {
 914                 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
 915
 916                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 917
 918                 if (engine.process_callback (nframes)) {
 919                         return 0;
 920                 }
 921
 922                 jack_cycle_signal (_priv_jack, 0);
 923         }
 924
 925         return 0;
 926 }
 927
 928 int
 929 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 930 {
 931         return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
 932 }
 933
 934 int
 935 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 936 {
 937         _current_sample_rate = nframes;
 938         return engine.sample_rate_change (nframes);
 939 }
 940
 941 void
 942 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 943 {
 944         engine.latency_callback (mode == JackPlaybackLatency);
 945 }
 946
 947 int
 948 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 949 {
 950         return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
 951 }
 952
 953 int
 954 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 955 {
 956         /* if the size has not changed, this should be a no-op */
 957
 958         if (nframes == _current_buffer_size) {
 959                 return 0;
 960         }
 961
 962         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
 963
 964         _current_buffer_size = nframes;
 965
 966         if (jack_port_type_get_buffer_size) {
 967                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 968                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 969         } else {
 970
 971                 /* Old version of JACK.
 972
 973                    These crude guesses, see below where we try to get the right answers.
 974
 975                    Note that our guess for MIDI deliberatey tries to overestimate
 976                    by a little. It would be nicer if we could get the actual
 977                    size from a port, but we have to use this estimate in the
 978                    event that there are no MIDI ports currently. If there are
 979                    the value will be adjusted below.
 980                 */
 981
 982                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 983                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 984         }
 985
 986         engine.buffer_size_change (nframes);
 987
 988         return 0;
 989 }
 990
 991 void
 992 JACKAudioBackend::disconnected (const char* why)
 993 {
 994         bool was_running = _running;
 995
 996         _running = false;
 997         _current_buffer_size = 0;
 998         _current_sample_rate = 0;
 999
1000         if (was_running) {
1001                 engine.halted_callback (why); /* EMIT SIGNAL */
1002         }
1003 }
1004
1005 float
1006 JACKAudioBackend::dsp_load() const
1007 {
1008         GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
1009         return jack_cpu_load (_priv_jack);
1010 }
1011
1012 void
1013 JACKAudioBackend::update_latencies ()
1014 {
1015         GET_PRIVATE_JACK_POINTER (_priv_jack);
1016         jack_recompute_total_latencies (_priv_jack);
1017 }
1018
1019 ChanCount
1020 JACKAudioBackend::n_physical (unsigned long flags) const
1021 {
1022         ChanCount c;
1023
1024         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
1025
1026         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1027
1028         if (ports) {
1029                 for (uint32_t i = 0; ports[i]; ++i) {
1030                         if (!strstr (ports[i], "Midi-Through")) {
1031                                 DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
1032                                 if (t != DataType::NIL) {
1033                                         c.set (t, c.get (t) + 1);
1034                                 }
1035                         }
1036                 }
1037
1038                 jack_free (ports);
1039         }
1040
1041         return c;
1042 }
1043
1044 bool
1045 JACKAudioBackend::can_change_sample_rate_when_running () const
1046 {
1047         return false;
1048 }
1049
1050 bool
1051 JACKAudioBackend::can_change_buffer_size_when_running () const
1052 {
1053         return true;
1054 }
1055
1056 string
1057 JACKAudioBackend::control_app_name () const
1058 {
1059         /* Since JACK/ALSA really don't provide particularly integrated support
1060            for the idea of a control app to be used to control a device,
1061            allow the user to take some control themselves if necessary.
1062         */
1063
1064         const char* env_value  = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
1065         string appname;
1066
1067         if (!env_value) {
1068                 if (_target_driver.empty() || _target_device.empty()) {
1069                         return appname;
1070                 }
1071
1072                 if (_target_driver == "ALSA") {
1073
1074                         if (_target_device == "Hammerfall DSP") {
1075                                 appname = "hdspconf";
1076                         } else if (_target_device == "M Audio Delta 1010") {
1077                                 appname = "mudita24";
1078                         } else if (_target_device == "M2496") {
1079                                 appname = "mudita24";
1080                         }
1081                 }
1082         } else {
1083                 appname = env_value;
1084         }
1085
1086         return appname;
1087 }
1088
1089 void
1090 JACKAudioBackend::launch_control_app ()
1091 {
1092         string appname = control_app_name();
1093
1094         if (appname.empty()) {
1095                 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1096                 return;
1097         }
1098
1099         std::list<string> args;
1100         args.push_back (appname);
1101         Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);
1102 }
1103
1104 vector<string>
1105 JACKAudioBackend::enumerate_midi_options () const
1106 {
1107         return ARDOUR::enumerate_midi_options ();
1108 }
1109
1110 int
1111 JACKAudioBackend::set_midi_option (const string& opt)
1112 {
1113         _target_midi_option = opt;
1114         return 0;
1115 }
1116
1117 bool
1118 JACKAudioBackend::speed_and_position (double& speed, framepos_t& position)
1119 {
1120         jack_position_t pos;
1121         jack_transport_state_t state;
1122         bool starting;
1123
1124         /* this won't be called if the port engine in use is not JACK, so we do
1125            not have to worry about the type of PortEngine::private_handle()
1126         */
1127
1128         speed = 0;
1129         position = 0;
1130
1131         GET_PRIVATE_JACK_POINTER_RET (_priv_jack, true);
1132
1133         state = jack_transport_query (_priv_jack, &pos);
1134
1135         switch (state) {
1136         case JackTransportStopped:
1137                 speed = 0;
1138                 starting = false;
1139                 break;
1140         case JackTransportRolling:
1141                 speed = 1.0;
1142                 starting = false;
1143                 break;
1144         case JackTransportLooping:
1145                 speed = 1.0;
1146                 starting = false;
1147                 break;
1148         case JackTransportStarting:
1149                 starting = true;
1150                 // don't adjust speed here, just leave it as it was
1151                 break;
1152         default:
1153                 std::cerr << "WARNING: Unknown JACK transport state: " << state << std::endl;
1154         }
1155
1156         position = pos.frame;
1157         return starting;
1158 }