2 Copyright (C) 2013 Paul Davis
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.
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.
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.
24 #include <boost/scoped_ptr.hpp>
25 #include <glibmm/timer.h>
26 #include <glibmm/spawn.h>
28 #include "pbd/error.h"
30 #include "jack/jack.h"
31 #include "jack/thread.h"
33 #include "ardour/audioengine.h"
34 #include "ardour/session.h"
35 #include "ardour/types.h"
37 #include "jack_audiobackend.h"
38 #include "jack_connection.h"
39 #include "jack_utils.h"
43 using namespace ARDOUR;
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; }
53 JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnection> jc)
55 , _jack_connection (jc)
57 , _freewheeling (false)
58 , _target_sample_rate (48000)
59 , _target_buffer_size (1024)
60 , _target_sample_format (FormatFloat)
61 , _target_interleaved (false)
62 , _target_input_channels (-1)
63 , _target_output_channels (-1)
64 , _target_systemic_input_latency (0)
65 , _target_systemic_output_latency (0)
66 , _current_sample_rate (0)
67 , _current_buffer_size (0)
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));
73 JACKAudioBackend::~JACKAudioBackend()
78 JACKAudioBackend::name() const
84 JACKAudioBackend::private_handle() const
86 return _jack_connection->jack();
90 JACKAudioBackend::available() const
92 return (private_handle() != 0);
96 JACKAudioBackend::is_realtime () const
98 GET_PRIVATE_JACK_POINTER_RET (_priv_jack,false);
99 return jack_is_realtime (_priv_jack);
103 JACKAudioBackend::requires_driver_selection() const
109 JACKAudioBackend::enumerate_drivers () const
111 vector<string> currently_available;
112 get_jack_audio_driver_names (currently_available);
113 return currently_available;
117 JACKAudioBackend::set_driver (const std::string& name)
119 _target_driver = name;
123 vector<AudioBackend::DeviceStatus>
124 JACKAudioBackend::enumerate_devices () const
126 vector<string> currently_available = get_jack_device_names_for_audio_driver (_target_driver);
127 vector<DeviceStatus> statuses;
129 if (all_devices.find (_target_driver) == all_devices.end()) {
130 all_devices.insert (make_pair (_target_driver, std::set<string>()));
133 /* store every device we've found, by driver name.
135 * This is so we do not confuse ALSA, FFADO, netjack etc. devices
139 DeviceList& all (all_devices[_target_driver]);
141 for (vector<string>::const_iterator d = currently_available.begin(); d != currently_available.end(); ++d) {
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));
149 statuses.push_back (DeviceStatus (*d, false));
157 JACKAudioBackend::available_sample_rates (const string& /*device*/) const
162 f.push_back (sample_rate());
166 /* if JACK is not already running, just list a bunch of reasonable
167 values and let the future sort it all out.
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);
185 JACKAudioBackend::available_buffer_sizes (const string& /*device*/) const
190 s.push_back (buffer_size());
210 JACKAudioBackend::available_input_channel_count (const string& /*device*/) const
216 JACKAudioBackend::available_output_channel_count (const string& /*device*/) const
221 /* -- parameter setting -- */
224 JACKAudioBackend::set_device_name (const string& dev)
227 /* need to stop and restart JACK for this to work, at present */
231 _target_device = dev;
236 JACKAudioBackend::set_sample_rate (float sr)
239 _target_sample_rate = sr;
243 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
245 if (sr == jack_get_sample_rate (_priv_jack)) {
253 JACKAudioBackend::set_buffer_size (uint32_t nframes)
256 _target_buffer_size = nframes;
260 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
262 if (nframes == jack_get_buffer_size (_priv_jack)) {
266 return jack_set_buffer_size (_priv_jack, nframes);
270 JACKAudioBackend::set_sample_format (SampleFormat sf)
272 /* as far as JACK clients are concerned, the hardware is always
273 * floating point format.
275 if (sf == FormatFloat) {
282 JACKAudioBackend::set_interleaved (bool yn)
284 /* as far as JACK clients are concerned, the hardware is always
294 JACKAudioBackend::set_input_channels (uint32_t cnt)
300 _target_input_channels = cnt;
306 JACKAudioBackend::set_output_channels (uint32_t cnt)
312 _target_output_channels = cnt;
318 JACKAudioBackend::set_systemic_input_latency (uint32_t l)
324 _target_systemic_input_latency = l;
330 JACKAudioBackend::set_systemic_output_latency (uint32_t l)
336 _target_systemic_output_latency = l;
341 /* --- Parameter retrieval --- */
344 JACKAudioBackend::device_name () const
350 return _target_device;
354 JACKAudioBackend::sample_rate () const
357 return _current_sample_rate;
359 return _target_sample_rate;
363 JACKAudioBackend::buffer_size () const
366 return _current_buffer_size;
368 return _target_buffer_size;
372 JACKAudioBackend::sample_format () const
378 JACKAudioBackend::interleaved () const
384 JACKAudioBackend::input_channels () const
387 return n_physical (JackPortIsInput).n_audio();
389 return _target_input_channels;
393 JACKAudioBackend::output_channels () const
396 return n_physical (JackPortIsOutput).n_audio();
398 return _target_output_channels;
402 JACKAudioBackend::systemic_input_latency () const
404 return _target_systemic_output_latency;
408 JACKAudioBackend::systemic_output_latency () const
410 return _target_systemic_output_latency;
414 JACKAudioBackend::raw_buffer_size(DataType t)
416 std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
417 return (s != _raw_buffer_sizes.end()) ? s->second : 0;
421 JACKAudioBackend::setup_jack_startup_command ()
423 /* first we map the parameters that have been set onto a
424 * JackCommandLineOptions object.
427 JackCommandLineOptions options;
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;
443 options.realtime = true;
444 options.ports_max = 2048;
446 /* this must always be true for any server instance we start ourselves
449 options.temporary = true;
453 if (!get_jack_command_line_string (options, cmdline)) {
454 /* error, somehow - we will still try to start JACK
455 * automatically but it will be without our preferred options
460 std::cerr << "JACK command line will be: " << cmdline << std::endl;
462 write_jack_config_file (get_jack_server_user_config_file_path(), cmdline);
465 /* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
468 JACKAudioBackend::start ()
472 if (!_jack_connection->server_running()) {
473 setup_jack_startup_command ();
476 if (_jack_connection->open ()) {
481 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
483 /* get the buffer size and sample rates established */
485 jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
486 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
488 /* Now that we have buffer size and sample rate established, the engine
489 can go ahead and do its stuff
492 engine.reestablish_ports ();
494 if (!jack_port_type_get_buffer_size) {
495 warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
498 set_jack_callbacks ();
500 if (jack_activate (_priv_jack) == 0) {
503 // error << _("cannot activate JACK client") << endmsg;
506 engine.reconnect_ports ();
512 JACKAudioBackend::stop ()
514 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
516 _jack_connection->close ();
518 _current_buffer_size = 0;
519 _current_sample_rate = 0;
521 _raw_buffer_sizes.clear();
527 JACKAudioBackend::pause ()
529 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
532 jack_deactivate (_priv_jack);
539 JACKAudioBackend::freewheel (bool onoff)
541 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
543 if (onoff == _freewheeling) {
544 /* already doing what has been asked for */
549 if (jack_set_freewheel (_priv_jack, onoff) == 0) {
550 _freewheeling = true;
557 /* --- TRANSPORT STATE MANAGEMENT --- */
560 JACKAudioBackend::transport_stop ()
562 GET_PRIVATE_JACK_POINTER (_priv_jack);
563 jack_transport_stop (_priv_jack);
567 JACKAudioBackend::transport_start ()
569 GET_PRIVATE_JACK_POINTER (_priv_jack);
570 jack_transport_start (_priv_jack);
574 JACKAudioBackend::transport_locate (framepos_t where)
576 GET_PRIVATE_JACK_POINTER (_priv_jack);
577 jack_transport_locate (_priv_jack, where);
581 JACKAudioBackend::transport_frame () const
583 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
584 return jack_get_current_transport_frame (_priv_jack);
588 JACKAudioBackend::transport_state () const
590 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
592 return (TransportState) jack_transport_query (_priv_jack, &pos);
596 JACKAudioBackend::set_time_master (bool yn)
598 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
600 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
602 return jack_release_timebase (_priv_jack);
609 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
612 #ifdef HAVE_JACK_VIDEO_SUPPORT
614 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
619 (void) jack_transport_query (_priv_jack, &pos);
621 if (pos.valid & JackVideoFrameOffset) {
622 offset = pos.video_offset;
635 JACKAudioBackend::sample_time ()
637 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
638 return jack_frame_time (_priv_jack);
642 JACKAudioBackend::sample_time_at_cycle_start ()
644 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
645 return jack_last_frame_time (_priv_jack);
649 JACKAudioBackend::samples_since_cycle_start ()
651 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
652 return jack_frames_since_cycle_start (_priv_jack);
658 ardour_jack_error (const char* msg)
660 error << "JACK: " << msg << endmsg;
664 JACKAudioBackend::set_jack_callbacks ()
666 GET_PRIVATE_JACK_POINTER (_priv_jack);
668 jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
670 jack_set_process_thread (_priv_jack, _process_thread, this);
671 jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
672 jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
673 jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
674 jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
675 jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
677 #ifdef HAVE_JACK_SESSION
678 if( jack_set_session_callback)
679 jack_set_session_callback (_priv_jack, _session_callback, this);
682 if (jack_set_latency_callback) {
683 jack_set_latency_callback (_priv_jack, _latency_callback, this);
686 jack_set_error_function (ardour_jack_error);
690 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
691 jack_position_t* pos, int new_position, void *arg)
693 static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
697 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
698 jack_position_t* pos, int new_position)
700 ARDOUR::Session* session = engine.session();
703 session->jack_timebase_callback (state, nframes, pos, new_position);
708 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
710 return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
714 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
716 TransportState tstate;
719 case JackTransportStopped:
720 tstate = TransportStopped;
722 case JackTransportRolling:
723 tstate = TransportRolling;
725 case JackTransportLooping:
726 tstate = TransportLooping;
728 case JackTransportStarting:
729 tstate = TransportStarting;
733 return engine.sync_callback (tstate, pos->frame);
739 JACKAudioBackend::_xrun_callback (void *arg)
741 JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
742 if (jab->available()) {
743 jab->engine.Xrun (); /* EMIT SIGNAL */
748 #ifdef HAVE_JACK_SESSION
750 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
752 JACKAudioBackend* jab = static_cast<JACKAudioBackend*> (arg);
753 ARDOUR::Session* session = jab->engine.session();
756 session->jack_session_event (event);
762 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
764 static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
768 JACKAudioBackend::freewheel_callback (int onoff)
770 _freewheeling = onoff;
771 engine.freewheel_callback (onoff);
775 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
777 return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
781 JACKAudioBackend::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
783 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
784 ThreadData* td = new ThreadData (this, f, stacksize);
786 if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
787 jack_is_realtime (_priv_jack), _start_process_thread, td)) {
795 JACKAudioBackend::wait_for_process_thread_exit (AudioBackendNativeThread thr)
798 /* this doesn't actively try to stop the thread, it just waits till it exits */
799 return pthread_join (thr, &status);
803 JACKAudioBackend::_start_process_thread (void* arg)
805 ThreadData* td = reinterpret_cast<ThreadData*> (arg);
806 boost::function<void()> f = td->f;
815 JACKAudioBackend::_process_thread (void *arg)
817 return static_cast<JACKAudioBackend*> (arg)->process_thread ();
821 JACKAudioBackend::process_thread ()
823 /* JACK doesn't do this for us when we use the wait API
826 AudioEngine::thread_init_callback (this);
829 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
831 pframes_t nframes = jack_cycle_wait (_priv_jack);
833 if (engine.process_callback (nframes)) {
837 jack_cycle_signal (_priv_jack, 0);
844 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
846 return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
850 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
852 _current_sample_rate = nframes;
853 return engine.sample_rate_change (nframes);
857 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
859 engine.latency_callback (mode == JackPlaybackLatency);
863 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
865 return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
869 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
871 /* if the size has not changed, this should be a no-op */
873 if (nframes == _current_buffer_size) {
877 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
879 _current_buffer_size = nframes;
881 if (jack_port_type_get_buffer_size) {
882 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
883 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
886 /* Old version of JACK.
888 These crude guesses, see below where we try to get the right answers.
890 Note that our guess for MIDI deliberatey tries to overestimate
891 by a little. It would be nicer if we could get the actual
892 size from a port, but we have to use this estimate in the
893 event that there are no MIDI ports currently. If there are
894 the value will be adjusted below.
897 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
898 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
901 engine.buffer_size_change (nframes);
907 JACKAudioBackend::disconnected (const char* why)
909 bool was_running = _running;
912 _current_buffer_size = 0;
913 _current_sample_rate = 0;
916 engine.halted_callback (why); /* EMIT SIGNAL */
920 JACKAudioBackend::cpu_load() const
922 GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
923 return jack_cpu_load (_priv_jack);
927 JACKAudioBackend::update_latencies ()
929 GET_PRIVATE_JACK_POINTER (_priv_jack);
930 jack_recompute_total_latencies (_priv_jack);
934 JACKAudioBackend::n_physical (unsigned long flags) const
938 GET_PRIVATE_JACK_POINTER_RET (_priv_jack, c);
940 const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
943 for (uint32_t i = 0; ports[i]; ++i) {
944 if (!strstr (ports[i], "Midi-Through")) {
945 DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
946 if (t != DataType::NIL) {
947 c.set (t, c.get (t) + 1);
959 JACKAudioBackend::can_change_sample_rate_when_running () const
965 JACKAudioBackend::can_change_buffer_size_when_running () const
971 JACKAudioBackend::control_app_name () const
973 /* Since JACK/ALSA really don't provide particularly integrated support
974 for the idea of a control app to be used to control a device,
975 allow the user to take some control themselves if necessary.
978 const char* env_value = g_getenv ("ARDOUR_DEVICE_CONTROL_APP");
982 if (_target_driver.empty() || _target_device.empty()) {
986 if (_target_driver == "ALSA") {
988 if (_target_device == "Hammerfall DSP") {
989 appname = "hdspconf";
990 } else if (_target_device == "M Audio Delta 1010") {
991 appname = "mudita24";
1002 JACKAudioBackend::launch_control_app ()
1004 string appname = control_app_name();
1006 if (appname.empty()) {
1007 error << string_compose (_("There is no control application for the device \"%1\""), _target_device) << endmsg;
1011 std::list<string> args;
1012 args.push_back (appname);
1013 Glib::spawn_async ("", args, Glib::SPAWN_SEARCH_PATH);