/*
Copyright (C) 2014 Waves Audio Ltd.
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+
*/
#include "ardour/engine_state_controller.h"
using namespace PBD;
namespace {
-
+
struct DevicePredicate
{
DevicePredicate (const std::string& device_name)
: _device_name (device_name)
{}
-
+
bool operator ()(const AudioBackend::DeviceStatus& rhs)
{
return _device_name == rhs.name;
}
-
+
private:
std::string _device_name;
};
AudioEngine::instance ()->Running.connect_same_thread (running_connection, boost::bind (&EngineStateController::_on_engine_running, this));
AudioEngine::instance ()->Stopped.connect_same_thread (stopped_connection, boost::bind (&EngineStateController::_on_engine_stopped, this));
AudioEngine::instance ()->Halted.connect_same_thread (stopped_connection, boost::bind (&EngineStateController::_on_engine_stopped, this));
-
+
/* Subscribe for udpates from AudioEngine */
AudioEngine::instance ()->PortRegisteredOrUnregistered.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_ports_registration_update, this));
AudioEngine::instance ()->SampleRateChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_sample_rate_change, this, _1));
AudioEngine::instance ()->BufferSizeChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_buffer_size_change, this, _1));
AudioEngine::instance ()->DeviceListChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_device_list_change, this));
AudioEngine::instance ()->DeviceError.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_device_error, this));
-
+
/* Global configuration parameters update */
Config->ParameterChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_parameter_changed, this, _1));
-
+
_deserialize_and_load_engine_states ();
_deserialize_and_load_midi_port_states ();
_do_initial_engine_setup ();
-
+
// now push the sate to the backend
push_current_state_to_backend (false);
}
XMLNode&
EngineStateController::serialize_audio_midi_settings ()
{
-
+
XMLNode* root = new XMLNode ("AudioMidiSettings");
-
+
_serialize_engine_states (root);
_serialize_midi_port_states (root);
-
+
return *root;
}
EngineStateController::_deserialize_and_load_engine_states ()
{
XMLNode* audio_midi_settings_root = ARDOUR::Config->extra_xml ("AudioMidiSettings");
-
+
if (!audio_midi_settings_root) {
return;
}
-
+
XMLNode* engine_states = audio_midi_settings_root->child ("EngineStates");
-
+
if (!engine_states) {
return;
}
-
+
XMLNodeList state_nodes_list = engine_states->children ();
XMLNodeConstIterator state_node_iter = state_nodes_list.begin ();
-
+
for (; state_node_iter != state_nodes_list.end (); ++state_node_iter) {
-
+
XMLNode* state_node = *state_node_iter;
StatePtr engine_state (new State);
XMLProperty* prop = NULL;
-
+
if ((prop = state_node->property ("backend-name")) == 0) {
continue;
}
engine_state->backend_name = prop->value ();
-
+
if ((prop = state_node->property ("device-name")) == 0) {
continue;
}
engine_state->device_name = prop->value ();
-
+
if ((prop = state_node->property ("sample-rate")) == 0) {
continue;
}
engine_state->sample_rate = atoi (prop->value ());
-
+
if ((prop = state_node->property ("buffer-size")) == 0) {
continue;
}
engine_state->buffer_size = atoi (prop->value ());
-
+
if ((prop = state_node->property ("active")) == 0) {
continue;
}
engine_state->active = string_is_affirmative (prop->value ());
-
+
XMLNodeList state_children_list = state_node->children ();
XMLNodeConstIterator state_child_iter = state_children_list.begin ();
-
+
for (; state_child_iter != state_children_list.end (); ++state_child_iter) {
XMLNode* state_child = *state_child_iter;
-
+
if (state_child->name () == "InputConfiguration") {
-
+
XMLNodeList input_states_nodes = state_child->children ();
XMLNodeConstIterator input_state_node_iter = input_states_nodes.begin ();
PortStateList& input_states = engine_state->input_channel_states;
-
+
for (; input_state_node_iter != input_states_nodes.end (); ++input_state_node_iter) {
-
+
XMLNode* input_state_node = *input_state_node_iter;
-
+
if (input_state_node->name () != "input") {
continue;
}
PortState input_state (input_state_node->name ());
-
+
if ((prop = input_state_node->property ("name")) == 0) {
continue;
}
input_state.name = prop->value ();
-
+
if ((prop = input_state_node->property ("active")) == 0) {
continue;
}
input_state.active = string_is_affirmative (prop->value ());
-
+
input_states.push_back (input_state);
}
-
+
} else if (state_child->name () == "MultiOutConfiguration") {
-
+
XMLNodeList multi_out_state_nodes = state_child->children ();
XMLNodeConstIterator multi_out_state_node_iter = multi_out_state_nodes.begin ();
PortStateList& multi_out_states = engine_state->multi_out_channel_states;
-
+
for (; multi_out_state_node_iter != multi_out_state_nodes.end (); ++multi_out_state_node_iter) {
-
+
XMLNode* multi_out_state_node = *multi_out_state_node_iter;
-
+
if (multi_out_state_node->name () != "output") {
continue;
}
PortState multi_out_state (multi_out_state_node->name ());
-
+
if ((prop = multi_out_state_node->property ("name")) == 0) {
continue;
}
multi_out_state.name = prop->value ();
-
+
if ((prop = multi_out_state_node->property ("active")) == 0) {
continue;
}
multi_out_state.active = string_is_affirmative (prop->value ());
-
+
multi_out_states.push_back (multi_out_state);
}
} else if (state_child->name () == "StereoOutConfiguration") {
-
+
XMLNodeList stereo_out_state_nodes = state_child->children ();
XMLNodeConstIterator stereo_out_state_node_iter = stereo_out_state_nodes.begin ();
PortStateList& stereo_out_states = engine_state->stereo_out_channel_states;
-
+
for (; stereo_out_state_node_iter != stereo_out_state_nodes.end (); ++stereo_out_state_node_iter) {
-
+
XMLNode* stereo_out_state_node = *stereo_out_state_node_iter;
-
+
if (stereo_out_state_node->name () != "output") {
continue;
}
PortState stereo_out_state (stereo_out_state_node->name ());
-
+
if ((prop = stereo_out_state_node->property ("name")) == 0) {
continue;
}
stereo_out_state.name = prop->value ();
-
+
if ((prop = stereo_out_state_node->property ("active")) == 0) {
continue;
- }
+ }
stereo_out_state.active = string_is_affirmative (prop->value ());
-
+
stereo_out_states.push_back (stereo_out_state);
}
}
}
-
+
_states.push_back (engine_state);
}
}
void
EngineStateController::_deserialize_and_load_midi_port_states ()
-{
+{
XMLNode* audio_midi_settings_root = ARDOUR::Config->extra_xml ("AudioMidiSettings");
-
+
if (!audio_midi_settings_root) {
return;
}
-
+
XMLNode* midi_states = audio_midi_settings_root->child ("MidiStates");
-
+
if (!midi_states) {
return;
}
-
+
XMLNodeList state_nodes_list = midi_states->children ();
XMLNodeConstIterator state_node_iter = state_nodes_list.begin ();
for (; state_node_iter != state_nodes_list.end (); ++state_node_iter) {
-
+
XMLNode* state_node = *state_node_iter;
if (state_node->name () == "MidiInputs") {
-
+
XMLNodeList input_state_nodes = state_node->children ();
XMLNodeConstIterator input_state_node_iter = input_state_nodes.begin ();
_midi_inputs.clear ();
-
+
for (; input_state_node_iter != input_state_nodes.end (); ++input_state_node_iter) {
-
+
XMLNode* input_state_node = *input_state_node_iter;
XMLProperty* prop = NULL;
-
+
if (input_state_node->name () != "input") {
continue;
}
MidiPortState input_state (input_state_node->name ());
-
+
if ((prop = input_state_node->property ("name")) == 0) {
continue;
}
input_state.name = prop->value ();
-
+
if ((prop = input_state_node->property ("active")) == 0) {
continue;
}
input_state.active = string_is_affirmative (prop->value ());
-
+
if ((prop = input_state_node->property ("scene-connected")) == 0) {
continue;
}
input_state.scene_connected = string_is_affirmative (prop->value ());
-
+
if ((prop = input_state_node->property ("mtc-in")) == 0) {
continue;
}
input_state.mtc_in = string_is_affirmative (prop->value ());
-
+
_midi_inputs.push_back (input_state);
}
-
+
} else if (state_node->name () == "MidiOutputs") {
-
+
XMLNodeList output_state_nodes = state_node->children ();
XMLNodeConstIterator output_state_node_iter = output_state_nodes.begin ();
_midi_outputs.clear ();
-
+
for (; output_state_node_iter != output_state_nodes.end (); ++output_state_node_iter) {
-
+
XMLNode* output_state_node = *output_state_node_iter;
XMLProperty* prop = NULL;
-
+
if (output_state_node->name () != "output") {
continue;
}
MidiPortState output_state (output_state_node->name ());
-
+
if ((prop = output_state_node->property ("name")) == 0) {
continue;
}
output_state.name = prop->value ();
-
+
if ((prop = output_state_node->property ("active")) == 0) {
continue;
}
output_state.active = string_is_affirmative (prop->value ());
-
+
if ((prop = output_state_node->property ("scene-connected")) == 0) {
continue;
}
output_state.scene_connected = string_is_affirmative (prop->value ());
-
+
if ((prop = output_state_node->property ("mtc-in")) == 0) {
continue;
}
output_state.mtc_in = string_is_affirmative (prop->value ());
-
+
_midi_outputs.push_back (output_state);
}
}
if (!audio_midi_settings_node) {
return;
}
-
+
// clean up state data first
audio_midi_settings_node->remove_nodes_and_delete ("EngineStates" );
-
+
XMLNode* engine_states = new XMLNode ("EngineStates" );
-
+
StateList::const_iterator state_iter = _states.begin ();
for (; state_iter != _states.end (); ++state_iter) {
-
+
StatePtr state_ptr = *state_iter;
-
+
// create new node for the state
XMLNode* state_node = new XMLNode ("State");
-
+
state_node->add_property ("backend-name", state_ptr->backend_name);
state_node->add_property ("device-name", state_ptr->device_name);
state_node->add_property ("sample-rate", state_ptr->sample_rate);
state_node->add_property ("buffer-size", state_ptr->buffer_size);
state_node->add_property ("active", state_ptr->active ? "yes" : "no");
-
+
// store channel states:
// inputs
XMLNode* input_config_node = new XMLNode ("InputConfiguration");
input_config_node->add_child_nocopy (*input_state_node);
}
state_node->add_child_nocopy (*input_config_node);
-
+
// multi out outputs
XMLNode* multi_out_config_node = new XMLNode ("MultiOutConfiguration");
PortStateList& multi_out_channels = state_ptr->multi_out_channel_states;
multi_out_config_node->add_child_nocopy (*multi_out_state_node);
}
state_node->add_child_nocopy (*multi_out_config_node);
-
+
// stereo out outputs
XMLNode* stereo_out_config_node = new XMLNode ("StereoOutConfiguration");
PortStateList& stereo_out_channels = state_ptr->stereo_out_channel_states;
stereo_out_config_node->add_child_nocopy (*stereo_out_state_node);
}
state_node->add_child_nocopy (*stereo_out_config_node);
-
+
engine_states->add_child_nocopy (*state_node);
}
if (!audio_midi_settings_node) {
return;
}
-
+
// clean up state data first
audio_midi_settings_node->remove_nodes_and_delete ("MidiStates" );
-
+
XMLNode* midi_states_node = new XMLNode ("MidiStates" );
-
+
XMLNode* midi_input_states_node = new XMLNode ("MidiInputs" );
MidiPortStateList::const_iterator midi_input_state_iter = _midi_inputs.begin ();
for (; midi_input_state_iter != _midi_inputs.end (); ++midi_input_state_iter) {
midi_input_states_node->add_child_nocopy (*midi_input_node);
}
midi_states_node->add_child_nocopy (*midi_input_states_node);
-
+
XMLNode* midi_output_states_node = new XMLNode ("MidiOutputs" );
MidiPortStateList::const_iterator midi_output_state_iter = _midi_outputs.begin ();
for (; midi_output_state_iter != _midi_outputs.end (); ++midi_output_state_iter) {
EngineStateController::_apply_state (const StatePtr& state)
{
bool applied = false;
-
+
if (set_new_backend_as_current (state->backend_name)) {
applied = set_new_device_as_current (state->device_name);
}
-
+
return applied;
}
EngineStateController::_do_initial_engine_setup ()
{
bool state_applied = false;
-
+
// if we have no saved state load default values
if (!_states.empty ()) {
-
+
// look for last active state first
StateList::const_iterator state_iter = _states.begin ();
for (; state_iter != _states.end (); ++state_iter) {
break;
}
}
-
+
// last active state was not applied
// try others
if (!state_applied) {
if (!state_applied ){
std::vector<const AudioBackendInfo*> backends = AudioEngine::instance ()->available_backends ();
-
+
if (!backends.empty ()) {
-
+
if (!set_new_backend_as_current (backends.front ()->name )) {
std::cerr << "\tfailed to set backend [" << backends.front ()->name << "]\n";
}
}
-
+
}
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
// check if device parameters from the state record are still valid
// validate sample rate
std::vector<float> sample_rates = backend->available_sample_rates (_current_state->device_name);
-
+
if (sample_rates.empty ()) {
return false;
}
// check if session desired sample rate (if it's set) could be used with this device
if (_session != 0) {
-
+
if ( !set_new_sample_rate_in_controller (_session->nominal_frame_rate ())) {
if ( !set_new_sample_rate_in_controller (backend->default_sample_rate ()) ) {
if (!set_new_sample_rate_in_controller (sample_rates.front ()) ) {
}
}
}
-
+
} else {
// check if current sample rate is supported because we have no session desired sample rate value
if ( !set_new_sample_rate_in_controller (_current_state->sample_rate)) {
}
}
}
-
+
// validate buffer size
std::vector<pframes_t> buffer_sizes = backend->available_buffer_sizes (_current_state->device_name);
// check if buffer size is supported
EngineStateController::_update_ltc_source_port ()
{
// this method is called if the list of ports is changed
-
+
// check that ltc-in port from Config still exists
if (_audio_input_port_exists (get_ltc_source_port ())) {
// audio port, that was saved in Config, exists
set_ltc_source_port (_current_state->input_channel_states.front ().name);
return ;
}
-
+
// no available audio-in ports
set_ltc_source_port ("");
}
EngineStateController::_update_ltc_output_port ()
{
// this method is called if the list of ports is changed
-
+
// check that ltc-out port from Config still exists
if (_audio_output_port_exists (get_ltc_output_port ())) {
// audio port, that was saved in Config, exists
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
//otherwise set first available audio port
if (!output_states->empty ()) {
set_ltc_output_port (output_states->front ().name);
return ;
}
-
+
// no available audio-out ports
set_ltc_output_port ("");
}
-
+
bool
EngineStateController::_audio_input_port_exists (const std::string& port_name)
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::const_iterator iter = output_states->begin ();
for (; iter != output_states->end (); ++iter ) {
if (iter->name == port_name)
if (backend_name == AudioEngine::instance ()->current_backend_name ()) {
return true;
}
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->set_backend (backend_name, PROGRAM_NAME, "");
if (backend)
{
if (_current_state != NULL) {
_current_state->active = false;
}
-
+
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (backend_name, "None"));
-
+
if (found_state_iter != _states.end ()) {
// we found a record for new engine with None device - switch to it
_current_state = *found_state_iter;
_validate_current_device_state ();
_states.push_front (_current_state);
}
-
+
push_current_state_to_backend (false);
-
+
return true;
}
-
+
return false;
}
if (_current_state->device_name == device_name) {
return true;
}
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<AudioBackend::DeviceStatus> device_vector = backend->enumerate_devices ();
-
+
// validate the device
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (device_name));
-
+
// device is available
if (device_iter != device_vector.end ()) {
-
+
boost::shared_ptr<State> previous_state (_current_state);
-
+
// look through state list and find the record for this device and current engine
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (backend->name (), device_name));
-
+
if (found_state_iter != _states.end ())
{
// we found a record for current engine and provided device name - switch to it
-
+
_current_state = *found_state_iter;
-
+
if (!_validate_current_device_state ()) {
_current_state = previous_state;
return false;
}
-
+
} else {
-
+
// the record is not found, create new one
_current_state = boost::shared_ptr<State>(new State ());
-
+
_current_state->backend_name = backend->name ();
_current_state->device_name = device_name;
-
+
if (!_validate_current_device_state ()) {
_current_state = previous_state;
return false;
}
-
+
_states.push_front (_current_state);
}
-
+
if (previous_state != NULL) {
previous_state->active = false;
}
-
+
push_current_state_to_backend (false);
_last_used_real_device.clear ();
-
+
if (device_name != "None") {
_last_used_real_device = device_name;
}
-
+
return true;
}
-
+
// device is not supported by current backend
return false;
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<float> sample_rates = backend->available_sample_rates (_current_state->device_name);
std::vector<float>::iterator iter = std::find (sample_rates.begin (), sample_rates.end (), (float)sample_rate);
-
+
if (iter != sample_rates.end ()) {
_current_state->sample_rate = sample_rate;
return true;
}
-
+
return false;
}
bool
EngineStateController::set_new_buffer_size_in_controller (pframes_t buffer_size)
-{
+{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<uint32_t> buffer_sizes = backend->available_buffer_sizes (_current_state->device_name);
std::vector<uint32_t>::iterator iter = std::find (buffer_sizes.begin (), buffer_sizes.end (), buffer_size);
_current_state->buffer_size = buffer_size;
return true;
}
-
+
return false;
}
EngineStateController::get_available_inputs_count () const
{
uint32_t available_channel_count = 0;
-
+
PortStateList::const_iterator iter = _current_state->input_channel_states.begin ();
-
+
for (; iter != _current_state->input_channel_states.end (); ++iter) {
if (iter->active) {
++available_channel_count;
}
}
-
+
return available_channel_count;
}
EngineStateController::get_available_outputs_count () const
{
uint32_t available_channel_count = 0;
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::const_iterator iter = output_states->begin ();
-
+
for (; iter != output_states->end (); ++iter) {
if (iter->active) {
++available_channel_count;
}
}
-
+
return available_channel_count;
}
EngineStateController::get_physical_audio_inputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
PortStateList &input_states = _current_state->input_channel_states;
-
+
PortStateList::iterator iter = input_states.begin ();
for (; iter != input_states.end (); ++iter) {
if (iter->active) {
EngineStateController::get_physical_audio_outputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator iter = output_states->begin ();
for (; iter != output_states->end (); ++iter) {
if (iter->active) {
EngineStateController::get_physical_midi_inputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
MidiPortStateList::iterator iter = _midi_inputs.begin ();
for (; iter != _midi_inputs.end (); ++iter) {
if (iter->available && iter->active) {
EngineStateController::get_physical_midi_outputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
MidiPortStateList::iterator iter = _midi_outputs.begin ();
for (; iter != _midi_outputs.end (); ++iter) {
if (iter->available && iter->active) {
PortStateList &input_states = _current_state->input_channel_states;
PortStateList::iterator found_state_iter;
found_state_iter = std::find (input_states.begin (), input_states.end (), PortState (port_name));
-
+
if (found_state_iter != input_states.end () && found_state_iter->active != state ) {
found_state_iter->active = state;
AudioEngine::instance ()->reconnect_session_routes (true, false);
-
+
InputConfigChanged ();
}
}
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator target_state_iter;
target_state_iter = std::find (output_states->begin (), output_states->end (), PortState (port_name));
-
+
if (target_state_iter != output_states->end () && target_state_iter->active != state ) {
target_state_iter->active = state;
-
+
// if StereoOut mode is used
if (Config->get_output_auto_connect () & AutoConnectMaster) {
-
+
// get next element
PortStateList::iterator next_state_iter (target_state_iter);
-
+
// loopback
if (++next_state_iter == output_states->end ()) {
next_state_iter = output_states->begin ();
}
-
-
+
+
// only two outputs should be enabled
if (output_states->size () <= 2) {
-
+
target_state_iter->active = true;
next_state_iter->active = true;
-
+
} else {
-
+
// if current was set to active - activate next and disable the rest
if (target_state_iter->active ) {
next_state_iter->active = true;
target_state_iter->active = true;
}
}
-
+
// now deactivate the rest
while (++next_state_iter != target_state_iter) {
-
+
if (next_state_iter == output_states->end ()) {
next_state_iter = output_states->begin ();
// we jumped, so additional check is required
break;
}
}
-
+
next_state_iter->active = false;
}
-
+
}
}
-
+
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged ();
}
EngineStateController::get_physical_audio_input_state (const std::string& port_name)
{
bool state = false;
-
+
PortStateList &input_states = _current_state->input_channel_states;
PortStateList::iterator found_state_iter;
found_state_iter = std::find (input_states.begin (), input_states.end (), PortState (port_name));
-
+
if (found_state_iter != input_states.end ()) {
state = found_state_iter->active;
}
-
+
return state;
}
EngineStateController::get_physical_audio_output_state (const std::string& port_name)
{
bool state = false;
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator found_state_iter;
found_state_iter = std::find (output_states->begin (), output_states->end (), PortState (port_name));
-
+
if (found_state_iter != output_states->end ()) {
state = found_state_iter->active;
}
void
EngineStateController::set_physical_midi_input_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available && found_state_iter->active != state ) {
found_state_iter->active = state;
-
+
if (_session) {
// reconnect MTC inputs as well
if (found_state_iter->mtc_in) {
}
_session->reconnect_mmc_ports (true);
}
-
+
MIDIInputConfigChanged ();
}
}
void
EngineStateController::set_physical_midi_output_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available && found_state_iter->active != state ) {
found_state_iter->active = state;
-
+
if (_session) {
_session->reconnect_mmc_ports (false);
}
-
+
MIDIOutputConfigChanged ();
}
}
bool
EngineStateController::get_physical_midi_input_state (const std::string& port_name, bool& scene_connected) {
-
+
bool state = false;
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available) {
state = found_state_iter->active;
scene_connected = found_state_iter->scene_connected;
}
-
+
return state;
}
bool
EngineStateController::get_physical_midi_output_state (const std::string& port_name, bool& scene_connected) {
-
+
bool state = false;
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available) {
state = found_state_iter->active;
scene_connected = found_state_iter->scene_connected;
}
-
+
return state;
}
void
EngineStateController::set_physical_midi_scene_in_connection_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available && found_state_iter->active ) {
found_state_iter->scene_connected = state;
-
+
std::vector<std::string> ports;
ports.push_back (port_name);
MIDISceneInputConnectionChanged (ports, state);
void
EngineStateController::set_physical_midi_scenen_out_connection_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available && found_state_iter->active ) {
found_state_iter->scene_connected = state;
-
+
std::vector<std::string> ports;
ports.push_back (port_name);
MIDISceneOutputConnectionChanged (ports, state);
for (; iter != _midi_outputs.end (); ++iter) {
iter->scene_connected = false;
}
-
+
std::vector<std::string> ports;
MIDISceneOutputConnectionChanged (ports, false);
}
MidiPortStateList::iterator iter = _midi_inputs.begin ();
for (; iter != _midi_inputs.end (); ++iter) {
iter->mtc_in = false;
-
+
if (iter->name == port_name) {
iter->mtc_in = true;
-
+
if (_session) {
_session->reconnect_mtc_ports ();
}
}
}
-
+
if (_session && port_name.empty ()) {
_session->reconnect_mtc_ports ();
}
-
+
MTCInputChanged (port_name);
}
EngineStateController::set_state_to_all_inputs (bool state)
{
bool something_changed = false;
-
+
PortStateList::iterator iter = _current_state->input_channel_states.begin ();
for (; iter != _current_state->input_channel_states.end (); ++iter) {
if (iter->active != state) {
something_changed = true;
}
}
-
+
if (something_changed) {
AudioEngine::instance ()->reconnect_session_routes (true, false);
InputConfigChanged ();
if (Config->get_output_auto_connect () & AutoConnectMaster) {
return;
}
-
+
bool something_changed = false;
-
+
PortStateList::iterator iter = _current_state->multi_out_channel_states.begin ();
for (; iter != _current_state->multi_out_channel_states.end (); ++iter) {
if (iter->active != state) {
something_changed = true;
}
}
-
+
if (something_changed) {
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged ();
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
channel_states.assign (output_states->begin (), output_states->end ());
}
EngineStateController::get_physical_midi_input_states (std::vector<MidiPortState>& channel_states)
{
channel_states.clear ();
-
+
MidiPortStateList::iterator iter = _midi_inputs.begin ();
-
+
for (; iter != _midi_inputs.end (); ++iter ) {
if (iter->available) {
MidiPortState state (iter->name);
state.mtc_in = iter->mtc_in;
channel_states.push_back (state);
}
- }
+ }
}
void
EngineStateController::get_physical_midi_output_states (std::vector<MidiPortState>& channel_states)
{
channel_states.clear ();
-
+
MidiPortStateList::iterator iter = _midi_outputs.begin ();
-
+
for (; iter != _midi_outputs.end (); ++iter ) {
if (iter->available) {
MidiPortState state (iter->name);
if (!_session) {
return;
}
-
+
AudioEngine::instance ()->reconnect_session_routes (true, true);
_session->reconnect_mtc_ports ();
_session->reconnect_mmc_ports (true);
_session->reconnect_mmc_ports (false);
-
+
// This is done during session construction
// _session->reconnect_ltc_input ();
// _session->reconnect_ltc_output ();
EngineStateController::_on_sample_rate_change (framecnt_t new_sample_rate)
{
if (_current_state->sample_rate != new_sample_rate) {
-
+
// if sample rate has been changed
framecnt_t sample_rate_to_set = new_sample_rate;
if (AudioEngine::instance ()->session ()) {
// and we have current session we should restore it back to the one tracks uses
sample_rate_to_set = AudioEngine::instance ()->session ()->frame_rate ();
}
-
+
if ( !set_new_sample_rate_in_controller (sample_rate_to_set)) {
// if sample rate can't be set
// switch to NONE device
DeviceError ();
}
}
-
+
SampleRateChanged (); // emit a signal
}
if (_current_state->buffer_size != new_buffer_size) {
_current_state->buffer_size = new_buffer_size;
}
-
+
BufferSizeChanged (); // emit a signal
}
EngineStateController::_on_device_list_change ()
{
bool current_device_disconnected = false;
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<AudioBackend::DeviceStatus> device_vector = backend->enumerate_devices ();
-
+
// find out out if current device is still available if it's not None
if (_current_state->device_name != "None")
{
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (_current_state->device_name));
-
+
// if current device is not available any more - switch to None device
if (device_iter == device_vector.end ()) {
-
+
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (_current_state->backend_name, "None"));
-
+
if (found_state_iter != _states.end ()) {
// found the record - switch to it
_current_state = *found_state_iter;
_validate_current_device_state ();
_states.push_front (_current_state);
}
-
+
push_current_state_to_backend (true);
current_device_disconnected = true;
}
} else {
// if the device which was active before is available now - switch to it
-
+
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (_last_used_real_device));
-
+
if (device_iter != device_vector.end ()) {
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (_current_state->backend_name,
_last_used_real_device));
-
+
if (found_state_iter != _states.end ()) {
-
+
boost::shared_ptr<State> previous_state (_current_state);
_current_state = *found_state_iter;
-
+
if (_validate_current_device_state ()) {
push_current_state_to_backend (false);
} else {
}
}
}
-
- DeviceListChanged (current_device_disconnected); // emit a signal
+
+ DeviceListChanged (current_device_disconnected); // emit a signal
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
// update audio input states
std::vector<std::string> phys_audio_inputs;
backend->get_physical_inputs (DataType::AUDIO, phys_audio_inputs);
-
+
PortStateList new_input_states;
PortStateList &input_states = _current_state->input_channel_states;
-
+
std::vector<std::string>::const_iterator input_iter = phys_audio_inputs.begin ();
for (; input_iter != phys_audio_inputs.end (); ++input_iter) {
-
+
PortState state (*input_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (input_states.begin (), input_states.end (), state);
-
+
if (found_state_iter != input_states.end ()) {
new_input_states.push_back (*found_state_iter);
} else {
}
}
_current_state->input_channel_states = new_input_states;
-
+
// update audio output states (multi out mode)
std::vector<std::string> phys_audio_outputs;
backend->get_physical_outputs (DataType::AUDIO, phys_audio_outputs);
-
+
PortStateList new_output_states;
PortStateList &output_multi_states = _current_state->multi_out_channel_states;
-
+
std::vector<std::string>::const_iterator output_iter = phys_audio_outputs.begin ();
for (; output_iter != phys_audio_outputs.end (); ++output_iter) {
-
+
PortState state (*output_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (output_multi_states.begin (), output_multi_states.end (), state);
-
+
if (found_state_iter != output_multi_states.end ()) {
new_output_states.push_back (*found_state_iter);
} else {
new_output_states.push_back (state);
}
}
-
+
_current_state->multi_out_channel_states = new_output_states;
-
+
// update audio output states (stereo out mode)
new_output_states.clear ();
PortStateList &output_stereo_states = _current_state->stereo_out_channel_states;
-
+
output_iter = phys_audio_outputs.begin ();
for (; output_iter != phys_audio_outputs.end (); ++output_iter) {
-
+
PortState state (*output_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (output_stereo_states.begin (), output_stereo_states.end (), state);
-
+
if (found_state_iter != output_stereo_states.end ()) {
new_output_states.push_back (*found_state_iter);
} else {
_current_state->stereo_out_channel_states = new_output_states;
_refresh_stereo_out_channel_states ();
-
-
+
+
// update midi ports: unlike audio ports which states are saved per device
// each midi port state is saved individualy
// so get all midi ports from the backend
for (; iter != _midi_inputs.end (); ++iter) {
iter->available = false;
}
-
+
for (iter = _midi_outputs.begin (); iter != _midi_outputs.end (); ++iter) {
iter->available = false;
}
-
+
// update midi input ports
std::vector<std::string> phys_midi_inputs;
backend->get_physical_inputs (DataType::MIDI, phys_midi_inputs);
-
+
std::vector<std::string>::const_iterator midi_input_iter = phys_midi_inputs.begin ();
for (; midi_input_iter != phys_midi_inputs.end (); ++midi_input_iter) {
-
+
MidiPortState state (*midi_input_iter);
state.active = false;
state.available = true;
MidiPortStateList::iterator found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), state);
-
+
if (found_state_iter != _midi_inputs.end ()) {
found_state_iter->available = true;
} else {
_midi_inputs.push_back (state);
}
}
-
+
// update midi output ports
std::vector<std::string> phys_midi_outputs;
backend->get_physical_outputs (DataType::MIDI, phys_midi_outputs);
-
+
std::vector<std::string>::const_iterator midi_output_iter = phys_midi_outputs.begin ();
for (; midi_output_iter != phys_midi_outputs.end (); ++midi_output_iter) {
-
+
MidiPortState state (*midi_output_iter);
state.active = false;
state.available = true;
MidiPortStateList::iterator found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), state);
-
+
if (found_state_iter != _midi_outputs.end ()) {
found_state_iter->available = true;
} else {
break;
}
}
-
+
uint32_t pending_active_channels = 2;
PortStateList::iterator iter = output_states.begin ();
// if found active
if (++iter == output_states.end ()) {
iter = output_states.begin ();
}
-
+
(iter++)->active = true;
pending_active_channels = 0;
}
{
AudioEngine::instance ()->reconnect_session_routes (true, true);
_current_state->active = true;
-
+
EngineRunning (); // emit a signal
}
EngineStateController::_on_parameter_changed (const std::string& parameter_name)
{
if (parameter_name == "output-auto-connect") {
-
+
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged (); // emit a signal
OutputConnectionModeChanged (); // emit signal
EngineStateController::_on_ports_registration_update ()
{
_update_device_channels_state ();
-
+
// update MIDI connections
if (_session) {
_session->reconnect_midi_scene_ports (true);
_session->reconnect_midi_scene_ports (false);
-
+
_session->reconnect_mtc_ports ();
-
+
_session->reconnect_mmc_ports (true);
_session->reconnect_mmc_ports (false);
-
+
_session->reconnect_ltc_input ();
_session->reconnect_ltc_output ();
}
-
+
_update_ltc_source_port ();
_update_ltc_output_port ();
-
+
PortRegistrationChanged (); // emit a signal
}
if (!backend) {
return false;
}
-
+
// check if anything changed
bool state_changed = (_current_state->device_name != backend->device_name ()) ||
(_current_state->sample_rate != backend->sample_rate ()) ||
(_current_state->buffer_size != backend->buffer_size ());
-
+
bool was_running = AudioEngine::instance ()->running ();
-
+
Glib::Threads::RecMutex::Lock sl (AudioEngine::instance ()->state_lock ());
if (state_changed) {
if (was_running) {
-
+
if (_current_state->device_name != backend->device_name ()) {
// device has been changed
// the list of ports has been changed too
set_ltc_source_port ("");
set_ltc_output_port ("");
}
-
+
if (AudioEngine::instance ()->stop ()) {
return false;
}
if ((_current_state->device_name != backend->device_name ()) && (result = backend->set_device_name (_current_state->device_name))) {
error << string_compose (_("Cannot set device name to %1"), get_current_device_name ()) << endmsg;
}
-
+
if (!result ) {
std::cout << "EngineStateController::Setting device sample rate " << _current_state->sample_rate << std::endl;
result = backend->set_sample_rate (_current_state->sample_rate);
error << string_compose (_("Cannot set sample rate to %1"), get_current_sample_rate ()) << endmsg;
}
}
-
+
if (!result ) {
std::cout << "EngineStateController::Setting device buffer size " << _current_state->buffer_size << std::endl;
result = backend->set_buffer_size (_current_state->buffer_size);
}
}
}
-
+
if (result) // error during device setup
{
//switch to None device and notify about the issue
return true;
}
}
-
+
if (start || (was_running && state_changed)) {
if (AudioEngine::instance ()->start () && !AudioEngine::instance ()->is_reset_requested ()) {
//switch to None device and notify about the issue
return false;
}
}
-
+
save_audio_midi_settings ();
-
+
return true;
}
return (state_iter->name);
}
}
-
+
return "";
}
projects / ardour.git / blobdiff