substantive changes to allow the audio/MIDI setup dialog to change settings as intended
So far only tested with JACK backend, but expected to be more correct for other backends too
This commit is contained in:
parent
7eda429155
commit
f51537b71d
|
|
@ -45,6 +45,7 @@
|
|||
#include "pbd/convert.h"
|
||||
#include "pbd/error.h"
|
||||
|
||||
#include "ardour_ui.h"
|
||||
#include "engine_dialog.h"
|
||||
#include "gui_thread.h"
|
||||
#include "i18n.h"
|
||||
|
|
@ -78,6 +79,12 @@ EngineControl::EngineControl ()
|
|||
, ignore_changes (0)
|
||||
, _desired_sample_rate (0)
|
||||
{
|
||||
if (!ARDOUR::AudioEngine::instance()->setup_required()) {
|
||||
_have_control = false;
|
||||
} else {
|
||||
_have_control = true;
|
||||
}
|
||||
|
||||
set_name (X_("AudioMIDISetup"));
|
||||
|
||||
build_notebook ();
|
||||
|
|
@ -600,15 +607,9 @@ EngineControl::device_changed ()
|
|||
|
||||
vector<float> sr = backend->available_sample_rates (device_name);
|
||||
for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
|
||||
char buf[32];
|
||||
if (fmod (*x, 1000.0f)) {
|
||||
snprintf (buf, sizeof (buf), "%.1f kHz", (*x)/1000.0);
|
||||
} else {
|
||||
snprintf (buf, sizeof (buf), "%.0f kHz", (*x)/1000.0);
|
||||
}
|
||||
s.push_back (buf);
|
||||
s.push_back (rate_as_string (*x));
|
||||
if (*x == _desired_sample_rate) {
|
||||
desired = buf;
|
||||
desired = s.back();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -630,12 +631,7 @@ EngineControl::device_changed ()
|
|||
vector<uint32_t> bs = backend->available_buffer_sizes(device_name);
|
||||
s.clear ();
|
||||
for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
|
||||
char buf[32];
|
||||
/* Translators: "samples" is always plural here, so no
|
||||
need for plural+singular forms.
|
||||
*/
|
||||
snprintf (buf, sizeof (buf), _("%u samples"), *x);
|
||||
s.push_back (buf);
|
||||
s.push_back (bufsize_as_string (*x));
|
||||
}
|
||||
|
||||
if (!s.empty()) {
|
||||
|
|
@ -661,6 +657,29 @@ EngineControl::device_changed ()
|
|||
push_state_to_backend (false);
|
||||
}
|
||||
|
||||
string
|
||||
EngineControl::rate_as_string (float r)
|
||||
{
|
||||
char buf[32];
|
||||
if (fmod (r, 1000.0f)) {
|
||||
snprintf (buf, sizeof (buf), "%.1f kHz", r/1000.0);
|
||||
} else {
|
||||
snprintf (buf, sizeof (buf), "%.0f kHz", r/1000.0);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
string
|
||||
EngineControl::bufsize_as_string (uint32_t sz)
|
||||
{
|
||||
/* Translators: "samples" is always plural here, so no
|
||||
need for plural+singular forms.
|
||||
*/
|
||||
char buf[32];
|
||||
snprintf (buf, sizeof (buf), _("%u samples"), sz);
|
||||
return buf;
|
||||
}
|
||||
|
||||
void
|
||||
EngineControl::sample_rate_changed ()
|
||||
{
|
||||
|
|
@ -673,7 +692,6 @@ EngineControl::sample_rate_changed ()
|
|||
*/
|
||||
|
||||
show_buffer_duration ();
|
||||
push_state_to_backend (false);
|
||||
save_state ();
|
||||
|
||||
}
|
||||
|
|
@ -686,7 +704,6 @@ EngineControl::buffer_size_changed ()
|
|||
}
|
||||
|
||||
show_buffer_duration ();
|
||||
push_state_to_backend (false);
|
||||
save_state ();
|
||||
}
|
||||
|
||||
|
|
@ -765,15 +782,7 @@ EngineControl::save_state ()
|
|||
state = new State;
|
||||
}
|
||||
|
||||
state->backend = backend_combo.get_active_text ();
|
||||
state->driver = driver_combo.get_active_text ();
|
||||
state->device = device_combo.get_active_text ();
|
||||
state->buffer_size = buffer_size_combo.get_active_text ();
|
||||
state->sample_rate = sample_rate_combo.get_active_text ();
|
||||
state->input_latency = (uint32_t) input_latency.get_value();
|
||||
state->output_latency = (uint32_t) output_latency.get_value();
|
||||
state->input_channels = (uint32_t) input_channels.get_value();
|
||||
state->output_channels = (uint32_t) output_channels.get_value();
|
||||
store_state (*state);
|
||||
|
||||
if (!existing) {
|
||||
states.push_back (*state);
|
||||
|
|
@ -782,6 +791,20 @@ EngineControl::save_state ()
|
|||
return state;
|
||||
}
|
||||
|
||||
void
|
||||
EngineControl::store_state (State& state)
|
||||
{
|
||||
state.backend = get_backend ();
|
||||
state.driver = get_driver ();
|
||||
state.device = get_device_name ();
|
||||
state.sample_rate = get_rate ();
|
||||
state.buffer_size = get_buffer_size ();
|
||||
state.input_latency = get_input_latency ();
|
||||
state.output_latency = get_output_latency ();
|
||||
state.input_channels = get_input_channels ();
|
||||
state.output_channels = get_output_channels ();
|
||||
}
|
||||
|
||||
void
|
||||
EngineControl::maybe_display_saved_state ()
|
||||
{
|
||||
|
|
@ -790,9 +813,9 @@ EngineControl::maybe_display_saved_state ()
|
|||
if (state) {
|
||||
ignore_changes++;
|
||||
if (!_desired_sample_rate) {
|
||||
sample_rate_combo.set_active_text (state->sample_rate);
|
||||
sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
|
||||
}
|
||||
buffer_size_combo.set_active_text (state->buffer_size);
|
||||
buffer_size_combo.set_active_text (bufsize_as_string (state->buffer_size));
|
||||
/* call this explicitly because we're ignoring changes to
|
||||
the controls at this point.
|
||||
*/
|
||||
|
|
@ -890,12 +913,12 @@ EngineControl::set_state (const XMLNode& root)
|
|||
if ((prop = grandchild->property ("sample-rate")) == 0) {
|
||||
continue;
|
||||
}
|
||||
state.sample_rate = prop->value ();
|
||||
state.sample_rate = atof (prop->value ());
|
||||
|
||||
if ((prop = grandchild->property ("buffer-size")) == 0) {
|
||||
continue;
|
||||
}
|
||||
state.buffer_size = prop->value ();
|
||||
state.buffer_size = atoi (prop->value ());
|
||||
|
||||
if ((prop = grandchild->property ("input-latency")) == 0) {
|
||||
continue;
|
||||
|
|
@ -934,13 +957,11 @@ EngineControl::set_state (const XMLNode& root)
|
|||
backend_combo.set_active_text ((*i).backend);
|
||||
driver_combo.set_active_text ((*i).driver);
|
||||
device_combo.set_active_text ((*i).device);
|
||||
sample_rate_combo.set_active_text ((*i).sample_rate);
|
||||
buffer_size_combo.set_active_text ((*i).buffer_size);
|
||||
sample_rate_combo.set_active_text (rate_as_string ((*i).sample_rate));
|
||||
buffer_size_combo.set_active_text (bufsize_as_string ((*i).buffer_size));
|
||||
input_latency.set_value ((*i).input_latency);
|
||||
output_latency.set_value ((*i).output_latency);
|
||||
ignore_changes--;
|
||||
|
||||
push_state_to_backend (false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -954,29 +975,171 @@ EngineControl::push_state_to_backend (bool start)
|
|||
|
||||
if (!backend) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* figure out what is going to change */
|
||||
|
||||
/* grab the parameters from the GUI and apply them */
|
||||
bool restart_required = false;
|
||||
bool was_running = ARDOUR::AudioEngine::instance()->running();
|
||||
bool change_driver = false;
|
||||
bool change_device = false;
|
||||
bool change_rate = false;
|
||||
bool change_bufsize = false;
|
||||
bool change_latency = false;
|
||||
bool change_channels = false;
|
||||
|
||||
uint32_t ochan = get_output_channels ();
|
||||
uint32_t ichan = get_input_channels ();
|
||||
|
||||
if (_have_control) {
|
||||
|
||||
/* we can control the backend */
|
||||
|
||||
try {
|
||||
if (backend->requires_driver_selection()) {
|
||||
if (backend->set_driver (get_driver())) {
|
||||
return -1;
|
||||
if (get_driver() != backend->driver_name()) {
|
||||
change_driver = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (backend->set_device_name (get_device_name())) {
|
||||
return -1;
|
||||
if (get_device_name() != backend->device_name()) {
|
||||
change_device = true;
|
||||
}
|
||||
|
||||
if (backend->set_sample_rate (get_rate())) {
|
||||
error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
|
||||
return -1;
|
||||
if (get_rate() != backend->sample_rate()) {
|
||||
change_rate = true;
|
||||
}
|
||||
if (backend->set_buffer_size (get_buffer_size())) {
|
||||
error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
|
||||
return -1;
|
||||
|
||||
if (get_buffer_size() != backend->buffer_size()) {
|
||||
change_bufsize = true;
|
||||
}
|
||||
|
||||
/* zero-requested channels means "all available" */
|
||||
|
||||
if (ichan == 0) {
|
||||
ichan = backend->input_channels();
|
||||
}
|
||||
|
||||
if (ochan == 0) {
|
||||
ochan = backend->output_channels();
|
||||
}
|
||||
|
||||
if (ichan != backend->input_channels()) {
|
||||
change_channels = true;
|
||||
}
|
||||
|
||||
if (ochan != backend->output_channels()) {
|
||||
change_channels = true;
|
||||
}
|
||||
|
||||
if (get_input_latency() != backend->systemic_input_latency() ||
|
||||
get_output_latency() != backend->systemic_output_latency()) {
|
||||
change_latency = true;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
/* we have no control over the backend, meaning that we can
|
||||
* only possibly change sample rate and buffer size.
|
||||
*/
|
||||
|
||||
|
||||
if (get_rate() != backend->sample_rate()) {
|
||||
change_bufsize = true;
|
||||
}
|
||||
|
||||
if (get_buffer_size() != backend->buffer_size()) {
|
||||
change_bufsize = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!_have_control) {
|
||||
|
||||
/* We do not have control over the backend, so the best we can
|
||||
* do is try to change the sample rate and/or bufsize and get
|
||||
* out of here.
|
||||
*/
|
||||
|
||||
if (change_rate) {
|
||||
if (!backend->can_change_sample_rate_when_running()) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if (change_bufsize) {
|
||||
if (!backend->can_change_buffer_size_when_running()) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (change_rate) {
|
||||
backend->set_sample_rate (get_rate());
|
||||
}
|
||||
|
||||
if (change_bufsize) {
|
||||
backend->set_buffer_size (get_buffer_size());
|
||||
}
|
||||
|
||||
post_push ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* determine if we need to stop the backend before changing parameters */
|
||||
|
||||
if (change_driver || change_device || change_channels || change_latency ||
|
||||
(change_rate && !backend->can_change_sample_rate_when_running()) ||
|
||||
(change_bufsize && !backend->can_change_buffer_size_when_running())) {
|
||||
restart_required = true;
|
||||
} else {
|
||||
restart_required = false;
|
||||
}
|
||||
|
||||
if (was_running) {
|
||||
|
||||
if (!change_driver && !change_device && !change_channels && !change_latency) {
|
||||
/* no changes in any parameters that absolutely require a
|
||||
* restart, so check those that might be changeable without a
|
||||
* restart
|
||||
*/
|
||||
|
||||
if (change_rate && !backend->can_change_sample_rate_when_running()) {
|
||||
/* can't do this while running ... */
|
||||
restart_required = true;
|
||||
}
|
||||
|
||||
if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
|
||||
/* can't do this while running ... */
|
||||
restart_required = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (was_running) {
|
||||
if (restart_required) {
|
||||
if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (change_driver && backend->set_driver (get_driver())) {
|
||||
error << string_compose (_("Cannot set driver to %1"), get_driver()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
if (change_device && backend->set_device_name (get_device_name())) {
|
||||
error << string_compose (_("Cannot set device name to %1"), get_device_name()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
if (change_rate && backend->set_sample_rate (get_rate())) {
|
||||
error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
if (change_bufsize && backend->set_buffer_size (get_buffer_size())) {
|
||||
error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (change_channels || get_input_channels() == 0 || get_output_channels() == 0) {
|
||||
if (backend->set_input_channels (get_input_channels())) {
|
||||
error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
|
||||
return -1;
|
||||
|
|
@ -985,6 +1148,8 @@ EngineControl::push_state_to_backend (bool start)
|
|||
error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if (change_latency) {
|
||||
if (backend->set_systemic_input_latency (get_input_latency())) {
|
||||
error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
|
||||
return -1;
|
||||
|
|
@ -993,61 +1158,66 @@ EngineControl::push_state_to_backend (bool start)
|
|||
error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* get a pointer to the current state object, creating one if
|
||||
* necessary
|
||||
*/
|
||||
|
||||
State* state = get_saved_state_for_currently_displayed_backend_and_device ();
|
||||
|
||||
if (!state) {
|
||||
state = save_state ();
|
||||
assert (state);
|
||||
}
|
||||
|
||||
/* all off */
|
||||
|
||||
for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
|
||||
(*i).active = false;
|
||||
}
|
||||
|
||||
/* mark this one active (to be used next time the dialog is
|
||||
* shown)
|
||||
*/
|
||||
|
||||
state->active = true;
|
||||
|
||||
if (start) {
|
||||
if (ARDOUR::AudioEngine::instance()->start()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* schedule a redisplay of MIDI ports */
|
||||
|
||||
Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
|
||||
}
|
||||
|
||||
manage_control_app_sensitivity ();
|
||||
return 0;
|
||||
|
||||
} catch (...) {
|
||||
cerr << "exception thrown...\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (start || (was_running && restart_required)) {
|
||||
if (ARDOUR_UI::instance()->reconnect_to_engine()) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
post_push ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
void
|
||||
EngineControl::post_push ()
|
||||
{
|
||||
/* get a pointer to the current state object, creating one if
|
||||
* necessary
|
||||
*/
|
||||
|
||||
State* state = get_saved_state_for_currently_displayed_backend_and_device ();
|
||||
|
||||
if (!state) {
|
||||
state = save_state ();
|
||||
assert (state);
|
||||
}
|
||||
|
||||
/* all off */
|
||||
|
||||
for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
|
||||
(*i).active = false;
|
||||
}
|
||||
|
||||
/* mark this one active (to be used next time the dialog is
|
||||
* shown)
|
||||
*/
|
||||
|
||||
state->active = true;
|
||||
|
||||
manage_control_app_sensitivity ();
|
||||
|
||||
/* schedule a redisplay of MIDI ports */
|
||||
|
||||
Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
|
||||
}
|
||||
|
||||
|
||||
float
|
||||
EngineControl::get_rate () const
|
||||
{
|
||||
double r = atof (sample_rate_combo.get_active_text ());
|
||||
float r = atof (sample_rate_combo.get_active_text ());
|
||||
/* the string may have been translated with an abbreviation for
|
||||
* thousands, so use a crude heuristic to fix this.
|
||||
*/
|
||||
if (r < 1000.0) {
|
||||
r *= 1000.0;
|
||||
}
|
||||
return lrint (r);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
uint32_t
|
||||
EngineControl::get_buffer_size () const
|
||||
|
|
@ -1086,6 +1256,12 @@ EngineControl::get_output_latency() const
|
|||
return (uint32_t) output_latency_adjustment.get_value();
|
||||
}
|
||||
|
||||
string
|
||||
EngineControl::get_backend () const
|
||||
{
|
||||
return backend_combo.get_active_text ();
|
||||
}
|
||||
|
||||
string
|
||||
EngineControl::get_driver () const
|
||||
{
|
||||
|
|
@ -1172,8 +1348,6 @@ EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
|
|||
input_latency.set_value (0);
|
||||
output_latency.set_value (0);
|
||||
|
||||
push_state_to_backend (false);
|
||||
|
||||
/* reset control */
|
||||
|
||||
input_latency.set_value (il);
|
||||
|
|
@ -1219,7 +1393,6 @@ EngineControl::check_latency_measurement ()
|
|||
}
|
||||
|
||||
uint32_t frames_total = mtdm->del();
|
||||
cerr << "total = " << frames_total << " delay = " << ARDOUR::AudioEngine::instance()->latency_signal_delay() << endl;
|
||||
uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
|
||||
|
||||
snprintf (buf, sizeof (buf), "%u samples %10.3lf ms", extra, extra * 1000.0f/sample_rate);
|
||||
|
|
|
|||
|
|
@ -118,8 +118,11 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
|
|||
void setup_midi_tab_for_backend ();
|
||||
void setup_midi_tab_for_jack ();
|
||||
void refresh_midi_display ();
|
||||
|
||||
std::string rate_as_string (float);
|
||||
std::string bufsize_as_string (uint32_t);
|
||||
|
||||
uint32_t get_rate() const;
|
||||
float get_rate() const;
|
||||
uint32_t get_buffer_size() const;
|
||||
uint32_t get_input_channels() const;
|
||||
uint32_t get_output_channels() const;
|
||||
|
|
@ -127,6 +130,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
|
|||
uint32_t get_output_latency() const;
|
||||
std::string get_device_name() const;
|
||||
std::string get_driver() const;
|
||||
std::string get_backend() const;
|
||||
|
||||
void device_changed ();
|
||||
void list_devices ();
|
||||
|
|
@ -136,15 +140,21 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
|
|||
std::string backend;
|
||||
std::string driver;
|
||||
std::string device;
|
||||
std::string sample_rate;
|
||||
std::string buffer_size;
|
||||
float sample_rate;
|
||||
uint32_t buffer_size;
|
||||
uint32_t input_latency;
|
||||
uint32_t output_latency;
|
||||
uint32_t input_channels;
|
||||
uint32_t output_channels;
|
||||
bool active;
|
||||
|
||||
State() : active (false) {};
|
||||
State()
|
||||
: input_latency (0)
|
||||
, output_latency (0)
|
||||
, input_channels (0)
|
||||
, output_channels (0)
|
||||
, active (false) {}
|
||||
|
||||
};
|
||||
|
||||
typedef std::list<State> StateList;
|
||||
|
|
@ -157,6 +167,9 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
|
|||
State* get_saved_state_for_currently_displayed_backend_and_device ();
|
||||
void maybe_display_saved_state ();
|
||||
State* save_state ();
|
||||
void store_state (State&);
|
||||
|
||||
bool _have_control;
|
||||
|
||||
static bool print_channel_count (Gtk::SpinButton*);
|
||||
|
||||
|
|
@ -167,6 +180,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
|
|||
void use_latency_button_clicked ();
|
||||
void manage_control_app_sensitivity ();
|
||||
int push_state_to_backend (bool start);
|
||||
void post_push ();
|
||||
|
||||
/* latency measurement */
|
||||
void latency_button_toggled ();
|
||||
|
|
|
|||
|
|
@ -223,6 +223,11 @@ class AudioBackend : public PortEngine {
|
|||
virtual uint32_t systemic_input_latency () const = 0;
|
||||
virtual uint32_t systemic_output_latency () const = 0;
|
||||
|
||||
/** override this if this implementation returns true from
|
||||
* requires_driver_selection()
|
||||
*/
|
||||
virtual std::string driver_name() const { return std::string(); }
|
||||
|
||||
/** Return the name of a control application for the
|
||||
* selected/in-use device. If no such application exists,
|
||||
* or if no device has been selected or is in-use,
|
||||
|
|
|
|||
|
|
@ -1039,12 +1039,22 @@ AudioEngine::start_latency_detection ()
|
|||
delete _mtdm;
|
||||
_mtdm = 0;
|
||||
|
||||
/* find the ports we will connect to */
|
||||
|
||||
PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
|
||||
PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
|
||||
|
||||
if (!out || !in) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* create the ports we will use to read/write data */
|
||||
|
||||
if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
|
||||
return;
|
||||
}
|
||||
if (pe.connect (_latency_output_port, _latency_output_name)) {
|
||||
pe.unregister_port (_latency_output_port);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1060,9 +1070,9 @@ AudioEngine::start_latency_detection ()
|
|||
|
||||
LatencyRange lr;
|
||||
_latency_signal_latency = 0;
|
||||
lr = pe.get_latency_range (_latency_input_port, false);
|
||||
lr = pe.get_latency_range (in, false);
|
||||
_latency_signal_latency = lr.max;
|
||||
lr = pe.get_latency_range (_latency_output_port, true);
|
||||
lr = pe.get_latency_range (out, true);
|
||||
_latency_signal_latency += lr.max;
|
||||
|
||||
/* all created and connected, lets go */
|
||||
|
|
|
|||
|
|
@ -57,8 +57,8 @@ JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnec
|
|||
, _target_buffer_size (1024)
|
||||
, _target_sample_format (FormatFloat)
|
||||
, _target_interleaved (false)
|
||||
, _target_input_channels (-1)
|
||||
, _target_output_channels (-1)
|
||||
, _target_input_channels (0)
|
||||
, _target_output_channels (0)
|
||||
, _target_systemic_input_latency (0)
|
||||
, _target_systemic_output_latency (0)
|
||||
, _current_sample_rate (0)
|
||||
|
|
@ -292,7 +292,10 @@ int
|
|||
JACKAudioBackend::set_input_channels (uint32_t cnt)
|
||||
{
|
||||
if (available()) {
|
||||
return -1;
|
||||
if (cnt != 0) {
|
||||
/* can't set a real value for this while JACK runs */
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
_target_input_channels = cnt;
|
||||
|
|
@ -304,7 +307,10 @@ int
|
|||
JACKAudioBackend::set_output_channels (uint32_t cnt)
|
||||
{
|
||||
if (available()) {
|
||||
return -1;
|
||||
if (cnt != 0) {
|
||||
/* can't set a real value for this while JACK runs */
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
_target_output_channels = cnt;
|
||||
|
|
@ -316,6 +322,7 @@ int
|
|||
JACKAudioBackend::set_systemic_input_latency (uint32_t l)
|
||||
{
|
||||
if (available()) {
|
||||
/* can't do this while JACK runs */
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -328,6 +335,7 @@ int
|
|||
JACKAudioBackend::set_systemic_output_latency (uint32_t l)
|
||||
{
|
||||
if (available()) {
|
||||
/* can't do this while JACK runs */
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -341,18 +349,34 @@ JACKAudioBackend::set_systemic_output_latency (uint32_t l)
|
|||
std::string
|
||||
JACKAudioBackend::device_name () const
|
||||
{
|
||||
if (available()) {
|
||||
return "???";
|
||||
if (!_jack_connection->in_control()) {
|
||||
return "???"; // JACK has no way (as of fall 2013) to return
|
||||
// the device name
|
||||
}
|
||||
|
||||
return _target_device;
|
||||
}
|
||||
|
||||
std::string
|
||||
JACKAudioBackend::driver_name() const
|
||||
{
|
||||
if (!_jack_connection->in_control()) {
|
||||
return "???"; // JACK has no way (as of fall 2013) to return
|
||||
// the driver name
|
||||
}
|
||||
|
||||
return _target_driver;
|
||||
}
|
||||
|
||||
float
|
||||
JACKAudioBackend::sample_rate () const
|
||||
{
|
||||
if (available()) {
|
||||
return _current_sample_rate;
|
||||
if (!_jack_connection->in_control()) {
|
||||
if (available()) {
|
||||
return _current_sample_rate;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return _target_sample_rate;
|
||||
}
|
||||
|
|
@ -360,8 +384,12 @@ JACKAudioBackend::sample_rate () const
|
|||
uint32_t
|
||||
JACKAudioBackend::buffer_size () const
|
||||
{
|
||||
if (available()) {
|
||||
return _current_buffer_size;
|
||||
if (!_jack_connection->in_control()) {
|
||||
if (available()) {
|
||||
return _current_buffer_size;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return _target_buffer_size;
|
||||
}
|
||||
|
|
@ -381,19 +409,37 @@ JACKAudioBackend::interleaved () const
|
|||
uint32_t
|
||||
JACKAudioBackend::input_channels () const
|
||||
{
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsInput).n_audio();
|
||||
}
|
||||
return _target_input_channels;
|
||||
if (!_jack_connection->in_control()) {
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsInput).n_audio();
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsInput).n_audio();
|
||||
} else {
|
||||
return _target_input_channels;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::output_channels () const
|
||||
{
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsOutput).n_audio();
|
||||
}
|
||||
return _target_output_channels;
|
||||
if (!_jack_connection->in_control()) {
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsOutput).n_audio();
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (available()) {
|
||||
return n_physical (JackPortIsOutput).n_audio();
|
||||
} else {
|
||||
return _target_output_channels;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t
|
||||
|
|
|
|||
|
|
@ -85,6 +85,7 @@ class JACKAudioBackend : public AudioBackend {
|
|||
uint32_t output_channels () const;
|
||||
uint32_t systemic_input_latency () const;
|
||||
uint32_t systemic_output_latency () const;
|
||||
std::string driver_name() const;
|
||||
|
||||
std::string control_app_name () const;
|
||||
void launch_control_app ();
|
||||
|
|
|
|||
|
|
@ -54,6 +54,7 @@ JackConnection::JackConnection (const std::string& arg1, const std::string& arg2
|
|||
, _client_name (arg1)
|
||||
, session_uuid (arg2)
|
||||
{
|
||||
_in_control = !server_running();
|
||||
}
|
||||
|
||||
JackConnection::~JackConnection ()
|
||||
|
|
@ -105,6 +106,19 @@ JackConnection::open ()
|
|||
global_epa->restore ();
|
||||
}
|
||||
|
||||
/* check to see if the server is already running so that we know if we
|
||||
* are starting it.
|
||||
*/
|
||||
|
||||
jack_client_t* c = jack_client_open ("ardourprobe", JackNoStartServer, &status);
|
||||
|
||||
if (status == 0) {
|
||||
_in_control = false;
|
||||
jack_client_close (c);
|
||||
} else {
|
||||
_in_control = true;
|
||||
}
|
||||
|
||||
/* ensure that PATH or equivalent includes likely locations of the JACK
|
||||
* server, in case the user's default does not.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -27,12 +27,15 @@ class JackConnection {
|
|||
void halted_callback ();
|
||||
void halted_info_callback (jack_status_t, const char*);
|
||||
|
||||
static bool server_running();
|
||||
bool in_control() const { return _in_control; }
|
||||
|
||||
static bool server_running();
|
||||
|
||||
private:
|
||||
jack_client_t* volatile _jack;
|
||||
std::string _client_name;
|
||||
std::string session_uuid;
|
||||
bool _in_control;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
Loading…
Reference in New Issue