goodbye USE_TRACKS_CODE_FEATURES and is_tracks_build
This commit is contained in:
parent
13c874d8b0
commit
5ec5bc4523
@ -156,8 +156,6 @@ class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
|
||||
void remove_session (); // not a replacement for SessionHandle::session_going_away()
|
||||
Session* session() const { return _session; }
|
||||
|
||||
void reconnect_session_routes (bool reconnect_inputs = true, bool reconnect_outputs = true);
|
||||
|
||||
class NoBackendAvailable : public std::exception {
|
||||
public:
|
||||
virtual const char *what() const throw() { return "could not connect to engine backend"; }
|
||||
|
@ -1,652 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2015-2017 Paul Davis <paul@linuxaudiosystems.com>
|
||||
*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#ifndef __gtk2_ardour__engine_state_controller__
|
||||
#define __gtk2_ardour__engine_state_controller__
|
||||
|
||||
#include <vector>
|
||||
#include <list>
|
||||
|
||||
#include "ardour/types.h"
|
||||
#include "ardour/audio_backend.h"
|
||||
|
||||
namespace ARDOUR {
|
||||
|
||||
class AudioBackendInfo;
|
||||
|
||||
/**
|
||||
* @class EngineStateController
|
||||
* @brief EngineStateController class.
|
||||
*
|
||||
* Implements usecases for Audio devices and Audio/Midi ports.
|
||||
* Persistantly saves to the config device configuration settings and audio/midi port states
|
||||
*/
|
||||
class EngineStateController
|
||||
{
|
||||
public:
|
||||
|
||||
// public data types:
|
||||
|
||||
/**
|
||||
* @struct PortState
|
||||
* Structure which represents AudioPort state
|
||||
*/
|
||||
struct PortState {
|
||||
std::string name; ///< Audio Port name
|
||||
bool active; ///< Audio Port state
|
||||
|
||||
PortState ()
|
||||
: name("")
|
||||
, active(false)
|
||||
{
|
||||
}
|
||||
|
||||
PortState (const std::string& name)
|
||||
: name(name)
|
||||
, active(false)
|
||||
{
|
||||
}
|
||||
|
||||
bool operator==(const PortState& rhs) {return rhs.name == name; }
|
||||
|
||||
};
|
||||
|
||||
/// @typedef Type for the list of all available audio ports
|
||||
typedef std::list<PortState> PortStateList;
|
||||
|
||||
/**
|
||||
* @struct MidiPortState
|
||||
* Structure which represents MidiPort state.
|
||||
*/
|
||||
struct MidiPortState
|
||||
{
|
||||
std::string name; ///< Midi Port name
|
||||
bool active; ///< Midi Port state
|
||||
bool available; ///< Midi Port availability - if it is physicaly available or not
|
||||
bool scene_connected; ///< Is midi port used for scene MIDI marker in/out
|
||||
bool mtc_in; ///< Is midi port used as MTC in
|
||||
|
||||
MidiPortState(const std::string& name)
|
||||
: name(name)
|
||||
, active(false)
|
||||
, available(false)
|
||||
, scene_connected(false)
|
||||
, mtc_in(false)
|
||||
{}
|
||||
|
||||
bool operator==(const MidiPortState& rhs)
|
||||
{
|
||||
return name == rhs.name;
|
||||
}
|
||||
};
|
||||
|
||||
/// @typedef Type for the list of MidiPorts ever registered in the system
|
||||
typedef std::list<MidiPortState> MidiPortStateList;
|
||||
|
||||
|
||||
//Interfaces
|
||||
|
||||
/** Get an instance of EngineStateController singleton.
|
||||
* @return EngineStateController instance pointer
|
||||
*/
|
||||
static EngineStateController* instance ();
|
||||
|
||||
/** Associate session with EngineStateController instance.
|
||||
*/
|
||||
void set_session (Session* session);
|
||||
|
||||
/** Remove link to the associated session.
|
||||
*/
|
||||
void remove_session ();
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// General backend/device information methods
|
||||
|
||||
/** Provides names of all available backends.
|
||||
*
|
||||
* @param[out] available_backends - vector of available backends
|
||||
*/
|
||||
void available_backends (std::vector<const AudioBackendInfo*>& available_backends);
|
||||
|
||||
/** Provides the name of currently used backend.
|
||||
*
|
||||
* @return the name of currently used backend
|
||||
*/
|
||||
const std::string& get_current_backend_name() const;
|
||||
|
||||
/** Provides the name of currently used device.
|
||||
*
|
||||
* @return the name of currently used device
|
||||
*/
|
||||
const std::string& get_current_device_name () const;
|
||||
|
||||
/** Provides names for all available devices.
|
||||
*
|
||||
* @param[out] device_vector - vector of available devices
|
||||
*/
|
||||
void enumerate_devices (std::vector<ARDOUR::AudioBackend::DeviceStatus>& device_vector) const;
|
||||
|
||||
/** Get sample rate used by current device.
|
||||
*
|
||||
* @return current sample rate
|
||||
*/
|
||||
ARDOUR::samplecnt_t get_current_sample_rate () const;
|
||||
|
||||
/** Get default sample rate for current backend.
|
||||
*
|
||||
* @return default sample rate for current backend
|
||||
*/
|
||||
ARDOUR::samplecnt_t get_default_sample_rate () const;
|
||||
|
||||
/** Get sample rates which are supported by current device and current backend.
|
||||
*
|
||||
* @param[out] sample_rates - vector of supported sample rates
|
||||
*/
|
||||
void available_sample_rates_for_current_device (std::vector<float>& sample_rates) const;
|
||||
|
||||
/** Get buffer size used by current device.
|
||||
*
|
||||
* @return current buffer size
|
||||
*/
|
||||
ARDOUR::pframes_t get_current_buffer_size () const;
|
||||
|
||||
/** Get default buffer size for current backend.
|
||||
*
|
||||
* @return default buffer size for current backend
|
||||
*/
|
||||
ARDOUR::pframes_t get_default_buffer_size () const;
|
||||
|
||||
/** Get buffer sizes which are supported by current device and current backend.
|
||||
*
|
||||
* @param[out] buffer_sizes - vector of supported buffer_sizes
|
||||
*/
|
||||
void available_buffer_sizes_for_current_device (std::vector<ARDOUR::pframes_t>& buffer_sizes) const;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// device state control methods
|
||||
|
||||
/** Get the number of all enabled Audio inputs.
|
||||
*
|
||||
* @return number of all enabled Audio inputs
|
||||
*/
|
||||
uint32_t get_available_inputs_count() const;
|
||||
/** Get the number of all enabled Audio outputs.
|
||||
*
|
||||
* @return number of all enabled Audio outputs
|
||||
*/
|
||||
uint32_t get_available_outputs_count () const;
|
||||
|
||||
/** Get vector of all enabled physical Audio input port names.
|
||||
*
|
||||
* @param[out] port_names - vector of all enabled Audio input names
|
||||
*/
|
||||
void get_physical_audio_inputs (std::vector<std::string>& port_names);
|
||||
/** Get vector of all enabled physical Audio input port names.
|
||||
*
|
||||
* @param[out] port_names - vector of all enabled Audio input names
|
||||
*/
|
||||
void get_physical_audio_outputs (std::vector<std::string>& port_names);
|
||||
|
||||
/** Get vector of all enabled physical MIDI input port names.
|
||||
*
|
||||
* @param[out] port_names - vector of all enabled MIDI input names
|
||||
*/
|
||||
void get_physical_midi_inputs (std::vector<std::string>& port_names);
|
||||
/** Get vector of all enabled physical MIDI output port names.
|
||||
*
|
||||
* @param[out] port_names - vector of all enabled MIDI output names
|
||||
*/
|
||||
void get_physical_midi_outputs (std::vector<std::string>& port_names);
|
||||
|
||||
/** Sets new state to all Audio inputs.
|
||||
*
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_state_to_all_inputs(bool state);
|
||||
/** Sets new state to all Audio outputs.
|
||||
* @note Does nothing in Stereo Out mode
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_state_to_all_outputs(bool state);
|
||||
|
||||
/** Get vector of states for all physical Audio input ports.
|
||||
*
|
||||
* @param[out] channel_states - vector of input port states
|
||||
*/
|
||||
void get_physical_audio_input_states(std::vector<PortState>& channel_states);
|
||||
/** Get vector of states for all physical Audio output ports.
|
||||
*
|
||||
* @param[out] channel_states - vector of output port states
|
||||
*/
|
||||
void get_physical_audio_output_states(std::vector<PortState>& channel_states);
|
||||
|
||||
/** Set state of the specified Audio input port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_audio_input_state(const std::string& port_name, bool state);
|
||||
/** Set state of the specified Audio output port.
|
||||
*
|
||||
* @param[in] port_name - output name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_audio_output_state(const std::string& port_name, bool state);
|
||||
|
||||
/** Get state of the specified Audio input port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @return input state
|
||||
*/
|
||||
bool get_physical_audio_input_state(const std::string& port_name);
|
||||
/** Get state of the specified Audi output port.
|
||||
*
|
||||
* @param[in] port_name - output name
|
||||
* @return output state
|
||||
*/
|
||||
bool get_physical_audio_output_state(const std::string& port_name);
|
||||
|
||||
|
||||
/** Get vector of all enabled MIDI input port names.
|
||||
*
|
||||
* @param[out] channel_states - vector of enabled inputs
|
||||
*/
|
||||
void get_physical_midi_input_states (std::vector<MidiPortState>& channel_states);
|
||||
/** Get vector of all enabled MIDI output port names.
|
||||
*
|
||||
* @param[out] channel_states - vector of enabled outputs
|
||||
*/
|
||||
void get_physical_midi_output_states (std::vector<MidiPortState>& channel_states);
|
||||
|
||||
/** Get name of mtc source port
|
||||
*
|
||||
* return name of mtc source port
|
||||
*/
|
||||
std::string get_mtc_source_port ();
|
||||
|
||||
/** Set ltc source port
|
||||
*
|
||||
* @param[in] port - name of ltc source port
|
||||
*/
|
||||
void set_ltc_source_port (const std::string& port);
|
||||
/** Get name of ltc source port
|
||||
*
|
||||
* return name of ltc source port
|
||||
*/
|
||||
std::string get_ltc_source_port ();
|
||||
|
||||
/** Set ltc output port
|
||||
*
|
||||
* @param[in] port - name of ltc output port
|
||||
*/
|
||||
void set_ltc_output_port (const std::string&);
|
||||
/** Get name of ltc output port
|
||||
*
|
||||
* return name of ltc output port
|
||||
*/
|
||||
std::string get_ltc_output_port ();
|
||||
|
||||
/** Set state of the specified MIDI input port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_midi_input_state(const std::string& port_name, bool state);
|
||||
/** Set state of the specified MIDI output port.
|
||||
*
|
||||
* @param[in] port_name - output name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_midi_output_state(const std::string& port_name, bool state);
|
||||
/** Get state of the specified MIDI input port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @param[out] scene_connected - is port used as Scene In or not
|
||||
* @return input state
|
||||
*/
|
||||
bool get_physical_midi_input_state(const std::string& port_name, bool& scene_connected);
|
||||
/** Get state of the specified MIDI output port.
|
||||
*
|
||||
* @param[in] port_name - output name
|
||||
* @param[out] scene_connected - is port used as Scene Out or not
|
||||
* @return output state
|
||||
*/
|
||||
bool get_physical_midi_output_state(const std::string& port_name, bool& scene_connected);
|
||||
|
||||
/** Set state of Scene In connection for the specified MIDI input port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_midi_scene_in_connection_state(const std::string& port_name, bool state);
|
||||
/** Set state of Scene Out connection for the specified MIDI output port.
|
||||
*
|
||||
* @param[in] port_name - input name
|
||||
* @param[in] state - new state
|
||||
*/
|
||||
void set_physical_midi_scenen_out_connection_state(const std::string&, bool);
|
||||
|
||||
/** Disocnnect all MIDI input ports from Scene In.
|
||||
*/
|
||||
void set_all_midi_scene_inputs_disconnected();
|
||||
/** Disocnnect all MIDI output ports from Scene Out.
|
||||
*/
|
||||
void set_all_midi_scene_outputs_disconnected();
|
||||
|
||||
/** Set MIDI TimeCode input port
|
||||
* @note There is a sense to choose MIDI TimeCode input only because
|
||||
* our MIDI TimeCode is propagated to all midi output ports.
|
||||
*/
|
||||
void set_mtc_source_port (const std::string&);
|
||||
|
||||
/** Check if AudioEngine setup is required
|
||||
* @return true if setup is required, otherwise - false
|
||||
*/
|
||||
bool is_setup_required() const {return ARDOUR::AudioEngine::instance()->setup_required (); }
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Methods set parameters inside the controller
|
||||
// the state of engine won't change untill we make a "push" of this state to the backend
|
||||
// NOTE: Use push_state_to_backend() method to update backend with the most recent controller state
|
||||
|
||||
/** Set new sample rate for current device in EngineStateController database
|
||||
* @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
|
||||
* @param sample_rate - new sample rate
|
||||
*/
|
||||
bool set_new_sample_rate_in_controller(samplecnt_t sample_rate);
|
||||
/** Set new buffer size for current device in EngineStateController database
|
||||
* @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
|
||||
* @param buffer_size - new buffer size
|
||||
*/
|
||||
bool set_new_buffer_size_in_controller(pframes_t buffer_size);
|
||||
|
||||
/** @brief push current controller state to backend.
|
||||
* Propagate and set all current EngineStateController parameters to the backend
|
||||
* @note Engine will be restarted if it's running when this method is called.
|
||||
* @note If an attempt ot set parameters is unsuccessful current device will be switched to "None".
|
||||
* @param start - start the Engine if it was not running when this function was called.
|
||||
* @return true on success, otherwise - false
|
||||
*/
|
||||
bool push_current_state_to_backend(bool start);
|
||||
/** Switch to new backend
|
||||
* @note The change will be propagated emmidiatelly as if push_current_state_to_backend () was called.
|
||||
* @param backend_name - new backend name.
|
||||
* @return true on success, otherwise - false
|
||||
*/
|
||||
bool set_new_backend_as_current(const std::string& backend_name);
|
||||
/** Switch to new device
|
||||
* @note The change will be propagated emmidiatelly as if push_current_state_to_backend () was called.
|
||||
* @param device_name - new device name.
|
||||
* @return true on success, otherwise - false
|
||||
*/
|
||||
bool set_new_device_as_current(const std::string& device_name);
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Methods to save/serialize setting states
|
||||
|
||||
/** Serialize Audio/Midi settings (entire EngineStateController database) to XML
|
||||
* @return XML note with serialized states
|
||||
*/
|
||||
XMLNode& serialize_audio_midi_settings();
|
||||
/** Save Audio/Midi settings (entire EngineStateController database) to config persistently
|
||||
*/
|
||||
void save_audio_midi_settings();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//UPDATE SIGNALS
|
||||
/** This signal is emitted if the sample rate changes */
|
||||
PBD::Signal0<void> SampleRateChanged;
|
||||
/** This signal is emitted if the buffer size changes */
|
||||
PBD::Signal0<void> BufferSizeChanged;
|
||||
/** This signal is emitted if the device list changes */
|
||||
PBD::Signal1<void, bool> DeviceListChanged;
|
||||
/** This signal is emitted if the device cannot operate properly */
|
||||
PBD::Signal0<void> DeviceError;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//ENGINE STATE SIGNALS
|
||||
/** This signal is emitted when the engine is started */
|
||||
PBD::Signal0<void> EngineRunning;
|
||||
/** This signal is emitted when the engine is stopped */
|
||||
PBD::Signal0<void> EngineStopped;
|
||||
/** This signal is emitted if Engine processing is terminated */
|
||||
PBD::Signal0<void> EngineHalted;
|
||||
|
||||
/** This signal is emitted if the AUDIO input channel configuration changes */
|
||||
PBD::Signal0<void> InputConfigChanged;
|
||||
/** This signal is emitted if the AUDIO output channel configuration changes */
|
||||
PBD::Signal0<void> OutputConfigChanged;
|
||||
/** This signal is emitted if the AUDIO output connection mode changes
|
||||
* @note By output connection mode "Stereo Out" or "Multi Out" is meant
|
||||
*/
|
||||
PBD::Signal0<void> OutputConnectionModeChanged;
|
||||
|
||||
/** This signals is emitted if the MIDI input channel configuration changes */
|
||||
PBD::Signal0<void> MIDIInputConfigChanged;
|
||||
/** This signals is emitted if the MIDI output channel configuration changes */
|
||||
PBD::Signal0<void> MIDIOutputConfigChanged;
|
||||
/** This signals is emitted if the MIDI Scene In connection changes */
|
||||
PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneInputConnectionChanged;
|
||||
/** This signals is emitted if the MIDI Scene Out connection changes */
|
||||
PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneOutputConnectionChanged;
|
||||
|
||||
/** This signal is emitted if the MTC Input channel is changed */
|
||||
PBD::Signal1<void, const std::string&> MTCInputChanged;
|
||||
|
||||
/** This signal is emitted if new Audio/MIDI ports are registered or unregistered */
|
||||
PBD::Signal0<void> PortRegistrationChanged;
|
||||
|
||||
private:
|
||||
|
||||
EngineStateController(); /// singleton
|
||||
~EngineStateController(); /// singleton
|
||||
EngineStateController(const EngineStateController& ); /// prohibited
|
||||
EngineStateController& operator=(const EngineStateController&); /// prohibited
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// private data structures
|
||||
|
||||
/** @struct Engine state
|
||||
* @brief State structure.
|
||||
* Contains information about single device/backend state
|
||||
*/
|
||||
struct State {
|
||||
std::string backend_name; ///< state backend name
|
||||
std::string device_name; ///< state device name
|
||||
ARDOUR::samplecnt_t sample_rate; ///< sample rate used by the device in this state
|
||||
ARDOUR::pframes_t buffer_size; ///< buffer size used by the device in this state
|
||||
|
||||
PortStateList input_channel_states; ///< states of device Audio inputs
|
||||
PortStateList multi_out_channel_states; ///< states of device Audio inputs in Multi Out mode
|
||||
PortStateList stereo_out_channel_states; ///< states of device Audio inputs in Stereo Out mode
|
||||
bool active; ///< was this state the most recent active one
|
||||
|
||||
State()
|
||||
: sample_rate(0)
|
||||
, buffer_size(0)
|
||||
, input_channel_states (0)
|
||||
, multi_out_channel_states (0)
|
||||
, stereo_out_channel_states (0)
|
||||
, active (false)
|
||||
{
|
||||
}
|
||||
|
||||
bool operator==(const State& rhs)
|
||||
{
|
||||
return (backend_name == rhs.backend_name) && (device_name == rhs.device_name);
|
||||
}
|
||||
|
||||
/** Forms string name for the state
|
||||
* @return name string
|
||||
*/
|
||||
std::string form_state_name() {
|
||||
return std::string("State:" + backend_name + ":" + device_name);
|
||||
}
|
||||
|
||||
/** @struct StatepPredicate
|
||||
* This predicate is used to identify a state during search in the list of states
|
||||
*/
|
||||
struct StatePredicate
|
||||
{
|
||||
StatePredicate(const std::string& backend_name, const std::string& device_name)
|
||||
: _backend_name (backend_name)
|
||||
, _device_name (device_name)
|
||||
{}
|
||||
|
||||
bool operator()(boost::shared_ptr<ARDOUR::EngineStateController::State> rhs)
|
||||
{
|
||||
return (_backend_name == rhs->backend_name) && (_device_name == rhs->device_name);
|
||||
}
|
||||
|
||||
private:
|
||||
std::string _backend_name;
|
||||
std::string _device_name;
|
||||
};
|
||||
};
|
||||
|
||||
/// @typedef Type for the state pointer
|
||||
typedef boost::shared_ptr<State> StatePtr;
|
||||
/// @typedef Type for the list of states
|
||||
typedef std::list<StatePtr> StateList;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// methods to manage setting states
|
||||
|
||||
/** Deserializes and loads Engine and Audio port states from the config to EngineStateController
|
||||
*/
|
||||
void _deserialize_and_load_engine_states();
|
||||
/** Deserializes and loads MIDI port states from the config to EngineStateController
|
||||
*/
|
||||
void _deserialize_and_load_midi_port_states();
|
||||
/** Serializes Engine and Audio port states from EngineStateController to XML node
|
||||
* @param[in,out] audio_midi_settings_node - node to serialize the satets to
|
||||
*/
|
||||
void _serialize_engine_states(XMLNode* audio_midi_settings_node);
|
||||
/** Serializes MIDI port states from EngineStateController to XML node
|
||||
* @param[in,out] audio_midi_settings_node - node to serialize the satets to
|
||||
*/
|
||||
void _serialize_midi_port_states(XMLNode* audio_midi_settings_node);
|
||||
|
||||
/** Provides initial state configuration.
|
||||
* It loades the last active state if there is one and it is aplicable.
|
||||
* Otherwise default state (None device with default sample rate and buffer size) is loaded.
|
||||
*/
|
||||
void _do_initial_engine_setup();
|
||||
|
||||
/** Loades provided state.
|
||||
* @note It's possible that provided state can't be loaded
|
||||
* (device disconnected or reqested parameters are not supported anymore).
|
||||
* @param state - state to apply
|
||||
* @return true on success, otherwise - false
|
||||
*/
|
||||
bool _apply_state(const StatePtr& state);
|
||||
|
||||
/** Gets available device channels from engine and updates internal controller state
|
||||
*/
|
||||
void _update_device_channels_state();
|
||||
|
||||
/** Check "Stereo Out" mode channels state configuration and make it correspond Stereo Out mode requirements
|
||||
*/
|
||||
void _refresh_stereo_out_channel_states();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// internal helper functions
|
||||
/** make sure that current device parameters are supported and fit session requirements
|
||||
* @return true if current state is valid and all parameters are supported, otherwise - false
|
||||
*/
|
||||
bool _validate_current_device_state();
|
||||
|
||||
/** change ltc source port in case of the input ports list change
|
||||
*/
|
||||
void _update_ltc_source_port ();
|
||||
/** change ltc source port in case of the output ports list change
|
||||
*/
|
||||
void _update_ltc_output_port ();
|
||||
|
||||
/** check that port is still existed in the list of input ports
|
||||
@param[in] port - port name
|
||||
@return true if current port is existed, otherwise - false
|
||||
*/
|
||||
bool _audio_input_port_exists (const std::string& port);
|
||||
/** check that port is still existed in the list of output ports
|
||||
@param[in] port - port name
|
||||
@return true if current port is existed, otherwise - false
|
||||
*/
|
||||
bool _audio_output_port_exists (const std::string& port);
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////
|
||||
// callbacks
|
||||
/** Invoked when Engine starts running
|
||||
*/
|
||||
void _on_engine_running();
|
||||
/** Invoked when Engine is halted
|
||||
*/
|
||||
void _on_engine_halted();
|
||||
/** Invoked when Engine processing is terminated
|
||||
*/
|
||||
void _on_engine_stopped();
|
||||
/** Invoked when Device error accured, it failed to start or didn't accept the change which should
|
||||
*/
|
||||
void _on_device_error();
|
||||
/** Invoked when current device changes sample rate
|
||||
*/
|
||||
void _on_sample_rate_change(ARDOUR::samplecnt_t);
|
||||
/** Invoked when current device changes buffer size
|
||||
*/
|
||||
void _on_buffer_size_change(ARDOUR::pframes_t);
|
||||
/** Invoked when the list of available devices is changed
|
||||
*/
|
||||
void _on_device_list_change();
|
||||
/** Invoked when the config parameter is changed
|
||||
*/
|
||||
void _on_parameter_changed (const std::string&);
|
||||
/** Invoked when Audio/MIDI ports are registered or unregistered
|
||||
*/
|
||||
void _on_ports_registration_update ();
|
||||
/** Invoked when session loading process is complete
|
||||
*/
|
||||
void _on_session_loaded();
|
||||
////////////////////////////////////////
|
||||
|
||||
////////////////////////////////////////
|
||||
// attributes
|
||||
StatePtr _current_state; ///< current state pointer
|
||||
// list of system states
|
||||
StateList _states; ///< list of all available states
|
||||
|
||||
MidiPortStateList _midi_inputs; ///< midi input states
|
||||
MidiPortStateList _midi_outputs; ///< midi output states
|
||||
|
||||
std::string _last_used_real_device; ///< last active non-default (real) device
|
||||
|
||||
Session* _session; ///< current session
|
||||
|
||||
// Engine connections stuff
|
||||
PBD::ScopedConnectionList update_connections; ///< connection container for update signals
|
||||
PBD::ScopedConnectionList session_connections; ///< connection container for session signals
|
||||
PBD::ScopedConnection running_connection; ///< connection container for EngineRunning signal
|
||||
PBD::ScopedConnection halt_connection; ///< connection container for EngineHalted signal
|
||||
PBD::ScopedConnection stopped_connection; ///< connection container for EngineStopped signal
|
||||
};
|
||||
|
||||
} // namespace ARDOUR
|
||||
|
||||
#endif /* defined(__gtk2_ardour__engine_state_controller__) */
|
@ -76,9 +76,6 @@ CONFIG_VARIABLE (bool, midi_input_follows_selection, "midi-input-follows-selecti
|
||||
CONFIG_VARIABLE (bool, run_all_transport_masters_always, "run-all-transport-masters-always", true)
|
||||
CONFIG_VARIABLE (int, mtc_qf_speed_tolerance, "mtc-qf-speed-tolerance", 5)
|
||||
CONFIG_VARIABLE (bool, timecode_sync_frame_rate, "timecode-sync-frame-rate", true)
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
CONFIG_VARIABLE (SyncSource, sync_source, "sync-source", MTC)
|
||||
#endif
|
||||
CONFIG_VARIABLE (bool, send_ltc, "send-ltc", false)
|
||||
CONFIG_VARIABLE (bool, ltc_send_continuously, "ltc-send-continuously", true)
|
||||
CONFIG_VARIABLE (std::string, ltc_output_port, "ltc-output-port", "")
|
||||
@ -120,11 +117,7 @@ CONFIG_VARIABLE (RegionSelectionAfterSplit, region_selection_after_split, "regio
|
||||
|
||||
/* monitoring, mute, solo etc */
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
CONFIG_VARIABLE (bool, mute_affects_pre_fader, "mute-affects-pre-fader", true)
|
||||
#else
|
||||
CONFIG_VARIABLE (bool, mute_affects_pre_fader, "mute-affects-pre-fader", false)
|
||||
#endif
|
||||
CONFIG_VARIABLE (bool, mute_affects_post_fader, "mute-affects-post-fader", true)
|
||||
CONFIG_VARIABLE (bool, mute_affects_control_outs, "mute-affects-control-outs", true)
|
||||
CONFIG_VARIABLE (bool, mute_affects_main_outs, "mute-affects-main-outs", true)
|
||||
@ -169,11 +162,7 @@ CONFIG_VARIABLE (bool, create_xrun_marker, "create-xrun-marker", true)
|
||||
CONFIG_VARIABLE (bool, stop_at_session_end, "stop-at-session-end", false)
|
||||
CONFIG_VARIABLE (bool, seamless_loop, "seamless-loop", false)
|
||||
CONFIG_VARIABLE (float, preroll_seconds, "preroll-seconds", -2.0f)
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
CONFIG_VARIABLE (bool, loop_is_mode, "loop-is-mode", true)
|
||||
#else
|
||||
CONFIG_VARIABLE (bool, loop_is_mode, "loop-is-mode", false)
|
||||
#endif
|
||||
CONFIG_VARIABLE (samplecnt_t, preroll, "preroll", 0)
|
||||
CONFIG_VARIABLE (samplecnt_t, postroll, "postroll", 0)
|
||||
CONFIG_VARIABLE (float, shuttle_speed_factor, "shuttle-speed-factor", 1.0f) // used for MMC shuttle
|
||||
@ -183,21 +172,12 @@ CONFIG_VARIABLE (ShuttleUnits, shuttle_units, "shuttle-units", Percentage)
|
||||
CONFIG_VARIABLE (float, shuttle_max_speed, "shuttle-max-speed", 8.0f)
|
||||
CONFIG_VARIABLE (bool, locate_while_waiting_for_sync, "locate-while-waiting-for-sync", false)
|
||||
CONFIG_VARIABLE (bool, disable_disarm_during_roll, "disable-disarm-during-roll", false)
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
CONFIG_VARIABLE (AutoReturnTarget, auto_return_target_list, "auto-return-target-list", AutoReturnTarget(LastLocate) )
|
||||
#else
|
||||
CONFIG_VARIABLE (AutoReturnTarget, auto_return_target_list, "auto-return-target-list", AutoReturnTarget(LastLocate|RangeSelectionStart|Loop|RegionSelectionStart))
|
||||
#endif
|
||||
|
||||
/* metering */
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
CONFIG_VARIABLE (float, meter_falloff, "meter-falloff", 60.0f)
|
||||
CONFIG_VARIABLE (MeterType, meter_type_master, "meter-type-master", MeterPeak)
|
||||
#else
|
||||
CONFIG_VARIABLE (float, meter_falloff, "meter-falloff", 13.3f)
|
||||
CONFIG_VARIABLE (MeterType, meter_type_master, "meter-type-master", MeterK14)
|
||||
#endif
|
||||
CONFIG_VARIABLE (MeterType, meter_type_track, "meter-type-track", MeterPeak)
|
||||
CONFIG_VARIABLE (MeterType, meter_type_bus, "meter-type-bus", MeterPeak)
|
||||
|
||||
|
@ -1232,9 +1232,6 @@ protected:
|
||||
friend class AudioEngine;
|
||||
void set_block_size (pframes_t nframes);
|
||||
void set_sample_rate (samplecnt_t nframes);
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true);
|
||||
#endif
|
||||
|
||||
friend class Route;
|
||||
void update_latency_compensation (bool force = false);
|
||||
|
@ -89,14 +89,3 @@ CONFIG_VARIABLE (bool, show_solo_on_meterbridge, "show-solo-on-meterbridge", fal
|
||||
CONFIG_VARIABLE (bool, show_monitor_on_meterbridge, "show-monitor-on-meterbridge", false)
|
||||
CONFIG_VARIABLE (bool, show_name_on_meterbridge, "show-name-on-meterbridge", true)
|
||||
CONFIG_VARIABLE (uint32_t, meterbridge_label_height, "meterbridge-label-height", 0)
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
/* This variable was not discussed with Ardour developers and is considered
|
||||
weakly conceived. It is also poorly named, since we have "groups" already
|
||||
present in libardour but this variable has nothing to do with it. There
|
||||
should have been more discussion about what was required and the best
|
||||
way to accomplish it.
|
||||
*/
|
||||
CONFIG_VARIABLE (bool, enable_group_edit, "enable-group-edit", false)
|
||||
/* These are GUI-only properties and should not be present in this context */
|
||||
#endif
|
||||
|
@ -689,18 +689,6 @@ AudioEngine::remove_session ()
|
||||
remove_all_ports ();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
AudioEngine::reconnect_session_routes (bool reconnect_inputs, bool reconnect_outputs)
|
||||
{
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
if (_session) {
|
||||
_session->reconnect_existing_routes(true, true, reconnect_inputs, reconnect_outputs);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
AudioEngine::died ()
|
||||
{
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -58,13 +58,6 @@ user_config_directory_name (int version = -1)
|
||||
product name etc.
|
||||
*/
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
/* Tracks does not use versioned configuration folders, which may or
|
||||
may not be problematic in the future.
|
||||
*/
|
||||
return X_(PROGRAM_NAME);
|
||||
|
||||
#else
|
||||
const string config_dir_name = string_compose ("%1%2", X_(PROGRAM_NAME), version);
|
||||
|
||||
#if defined (__APPLE__) || defined (PLATFORM_WINDOWS)
|
||||
@ -74,7 +67,6 @@ user_config_directory_name (int version = -1)
|
||||
/* use lower case folder name on Linux */
|
||||
return downcase (config_dir_name);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string
|
||||
|
@ -5975,65 +5975,6 @@ Route::set_loop (Location* l)
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
|
||||
/* This is the Tracks version of Track::monitoring_state().
|
||||
*
|
||||
* Ardour developers: try to flag or fix issues if parts of the libardour API
|
||||
* change in ways that invalidate this
|
||||
*/
|
||||
|
||||
MonitorState
|
||||
Route::monitoring_state () const
|
||||
{
|
||||
/* Explicit requests */
|
||||
|
||||
if (_monitoring != MonitorInput) {
|
||||
return MonitoringInput;
|
||||
}
|
||||
|
||||
if (_monitoring & MonitorDisk) {
|
||||
return MonitoringDisk;
|
||||
}
|
||||
|
||||
/* This is an implementation of the truth table in doc/monitor_modes.pdf;
|
||||
I don't think it's ever going to be too pretty too look at.
|
||||
*/
|
||||
|
||||
// GZ: NOT USED IN TRACKS
|
||||
//bool const auto_input = _session.config.get_auto_input ();
|
||||
//bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
|
||||
//bool const tape_machine_mode = Config->get_tape_machine_mode ();
|
||||
|
||||
bool const roll = _session.transport_rolling ();
|
||||
bool const track_rec = _diskstream->record_enabled ();
|
||||
bool session_rec = _session.actively_recording ();
|
||||
|
||||
if (track_rec) {
|
||||
|
||||
if (!session_rec && roll) {
|
||||
return MonitoringDisk;
|
||||
} else {
|
||||
return MonitoringInput;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
if (roll) {
|
||||
return MonitoringDisk;
|
||||
}
|
||||
}
|
||||
|
||||
return MonitoringSilence;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* This is the Ardour/Mixbus version of Track::monitoring_state().
|
||||
*
|
||||
* Tracks developers: do NOT modify this method under any circumstances.
|
||||
*/
|
||||
|
||||
MonitorState
|
||||
Route::monitoring_state () const
|
||||
{
|
||||
@ -6072,4 +6013,3 @@ Route::monitoring_state () const
|
||||
|
||||
return get_auto_monitoring_state();
|
||||
}
|
||||
#endif
|
||||
|
@ -79,9 +79,6 @@
|
||||
#include "ardour/debug.h"
|
||||
#include "ardour/disk_reader.h"
|
||||
#include "ardour/directory_names.h"
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
#include "ardour/engine_state_controller.h"
|
||||
#endif
|
||||
#include "ardour/filename_extensions.h"
|
||||
#include "ardour/gain_control.h"
|
||||
#include "ardour/graph.h"
|
||||
@ -168,13 +165,7 @@ PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
|
||||
const samplecnt_t Session::bounce_chunk_size = 8192;
|
||||
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
|
||||
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
|
||||
|
||||
// seconds should be added after the region exceeds end marker
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
const uint32_t Session::session_end_shift = 5;
|
||||
#else
|
||||
const uint32_t Session::session_end_shift = 0;
|
||||
#endif
|
||||
|
||||
/** @param snapshot_name Snapshot name, without .ardour suffix */
|
||||
Session::Session (AudioEngine &eng,
|
||||
@ -352,9 +343,6 @@ Session::Session (AudioEngine &eng,
|
||||
|
||||
Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
sr = EngineStateController::instance()->get_current_sample_rate();
|
||||
#endif
|
||||
if (ensure_engine (sr, true)) {
|
||||
destroy ();
|
||||
throw SessionException (_("Cannot connect to audio/midi engine"));
|
||||
@ -472,49 +460,6 @@ Session::Session (AudioEngine &eng,
|
||||
_engine.set_session (this);
|
||||
_engine.reset_timebase ();
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
|
||||
EngineStateController::instance()->set_session(this);
|
||||
|
||||
if (_is_new ) {
|
||||
if ( ARDOUR::Profile->get_trx () ) {
|
||||
|
||||
/* Waves Tracks: fill session with tracks basing on the amount of inputs.
|
||||
* each available input must have corresponding track when session starts.
|
||||
*/
|
||||
|
||||
uint32_t how_many (0);
|
||||
|
||||
std::vector<std::string> inputs;
|
||||
EngineStateController::instance()->get_physical_audio_inputs(inputs);
|
||||
|
||||
how_many = inputs.size();
|
||||
|
||||
list<boost::shared_ptr<AudioTrack> > tracks;
|
||||
|
||||
// Track names after driver
|
||||
if (Config->get_tracks_auto_naming() == NameAfterDriver) {
|
||||
string track_name = "";
|
||||
for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
|
||||
string track_name;
|
||||
track_name = inputs[i];
|
||||
replace_all (track_name, "system:capture", "");
|
||||
|
||||
list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
|
||||
tracks.insert(tracks.begin(), single_track.front());
|
||||
}
|
||||
} else { // Default track names
|
||||
tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
|
||||
}
|
||||
|
||||
if (tracks.size() != how_many) {
|
||||
destroy ();
|
||||
throw failed_constructor ();
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
ensure_subdirs (); // archived or zipped sessions may lack peaks/ analysis/ etc
|
||||
|
||||
if (!mix_template.empty ()) {
|
||||
@ -685,10 +630,6 @@ Session::destroy ()
|
||||
|
||||
_engine.remove_session ();
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
EngineStateController::instance()->remove_session();
|
||||
#endif
|
||||
|
||||
/* deregister all ports - there will be no process or any other
|
||||
* callbacks from the engine any more.
|
||||
*/
|
||||
@ -2655,254 +2596,6 @@ Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::wea
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
|
||||
static bool
|
||||
compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
|
||||
{
|
||||
return route1->remote_control_id() < route2->remote_control_id();
|
||||
}
|
||||
|
||||
void
|
||||
Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
|
||||
{
|
||||
// it is not allowed to perform connection
|
||||
if (!IO::connecting_legal) {
|
||||
return;
|
||||
}
|
||||
|
||||
// if we are deleting routes we will call this once at the end
|
||||
if (_route_deletion_in_progress) {
|
||||
return;
|
||||
}
|
||||
|
||||
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
|
||||
|
||||
if (withLock) {
|
||||
lm.acquire ();
|
||||
}
|
||||
|
||||
// We need to disconnect the route's inputs and outputs first
|
||||
// basing on autoconnect configuration
|
||||
bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
|
||||
bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
|
||||
|
||||
ChanCount existing_inputs;
|
||||
ChanCount existing_outputs;
|
||||
count_existing_track_channels (existing_inputs, existing_outputs);
|
||||
|
||||
//ChanCount inputs = ChanCount::ZERO;
|
||||
//ChanCount outputs = ChanCount::ZERO;
|
||||
|
||||
RouteList existing_routes = *routes.reader ();
|
||||
existing_routes.sort (compare_routes_by_remote_id);
|
||||
|
||||
{
|
||||
PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
|
||||
|
||||
vector<string> physinputs;
|
||||
vector<string> physoutputs;
|
||||
|
||||
EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
|
||||
EngineStateController::instance()->get_physical_audio_inputs(physinputs);
|
||||
|
||||
uint32_t input_n = 0;
|
||||
uint32_t output_n = 0;
|
||||
RouteList::iterator rIter = existing_routes.begin();
|
||||
const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
|
||||
const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
|
||||
for (; rIter != existing_routes.end(); ++rIter) {
|
||||
if (*rIter == _master_out || *rIter == _monitor_out ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (current_output_auto_connection == AutoConnectPhysical) {
|
||||
(*rIter)->amp()->deactivate();
|
||||
} else if (current_output_auto_connection == AutoConnectMaster) {
|
||||
(*rIter)->amp()->activate();
|
||||
}
|
||||
|
||||
if (reconnectIputs) {
|
||||
(*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
|
||||
|
||||
for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
|
||||
|
||||
if (current_input_auto_connection & AutoConnectPhysical) {
|
||||
|
||||
if ( input_n == physinputs.size() ) {
|
||||
break;
|
||||
}
|
||||
|
||||
string port = physinputs[input_n];
|
||||
|
||||
if (port.empty() ) {
|
||||
error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
|
||||
}
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
|
||||
++input_n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (reconnectOutputs) {
|
||||
|
||||
//normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
|
||||
if (current_output_auto_connection & AutoConnectPhysical) {
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->output()->disconnect (this);
|
||||
size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
|
||||
|
||||
} else if (current_output_auto_connection & AutoConnectMaster){
|
||||
|
||||
if (!reconnect_master) {
|
||||
continue;
|
||||
}
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->output()->disconnect (this);
|
||||
|
||||
if (_master_out) {
|
||||
uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
|
||||
(*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
|
||||
} else {
|
||||
error << error << "Master bus is not available" << endmsg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
|
||||
if (current_output_auto_connection & AutoConnectPhysical) {
|
||||
|
||||
if ( output_n == physoutputs.size() ) {
|
||||
break;
|
||||
}
|
||||
|
||||
string port = physoutputs[output_n];
|
||||
|
||||
if (port.empty() ) {
|
||||
error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
|
||||
}
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
|
||||
++output_n;
|
||||
|
||||
} else if (current_output_auto_connection & AutoConnectMaster) {
|
||||
|
||||
if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
|
||||
break;
|
||||
}
|
||||
|
||||
// connect to master bus
|
||||
string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
|
||||
|
||||
if (port.empty() ) {
|
||||
error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
|
||||
}
|
||||
|
||||
|
||||
//GZ: check this; could be heavy
|
||||
(*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_master_out->output()->disconnect (this);
|
||||
auto_connect_master_bus ();
|
||||
}
|
||||
|
||||
graph_reordered ();
|
||||
|
||||
session_routes_reconnected (); /* EMIT SIGNAL */
|
||||
}
|
||||
|
||||
void
|
||||
Session::reconnect_midi_scene_ports(bool inputs)
|
||||
{
|
||||
if (inputs ) {
|
||||
|
||||
boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
|
||||
if (scene_in_ptr) {
|
||||
scene_in_ptr->disconnect_all ();
|
||||
|
||||
std::vector<EngineStateController::MidiPortState> midi_port_states;
|
||||
EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
|
||||
|
||||
std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
|
||||
|
||||
for (; state_iter != midi_port_states.end(); ++state_iter) {
|
||||
if (state_iter->active && state_iter->available && state_iter->scene_connected) {
|
||||
scene_in_ptr->connect (state_iter->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
|
||||
|
||||
if (scene_out_ptr ) {
|
||||
scene_out_ptr->disconnect_all ();
|
||||
|
||||
std::vector<EngineStateController::MidiPortState> midi_port_states;
|
||||
EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
|
||||
|
||||
std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
|
||||
|
||||
for (; state_iter != midi_port_states.end(); ++state_iter) {
|
||||
if (state_iter->active && state_iter->available && state_iter->scene_connected) {
|
||||
scene_out_ptr->connect (state_iter->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Session::reconnect_mmc_ports(bool inputs)
|
||||
{
|
||||
if (inputs ) { // get all enabled midi input ports
|
||||
|
||||
boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
|
||||
if (mmc_in_ptr) {
|
||||
mmc_in_ptr->disconnect_all ();
|
||||
std::vector<std::string> enabled_midi_inputs;
|
||||
EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
|
||||
|
||||
std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
|
||||
|
||||
for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
|
||||
mmc_in_ptr->connect (*port_iter);
|
||||
}
|
||||
|
||||
}
|
||||
} else { // get all enabled midi output ports
|
||||
|
||||
boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
|
||||
if (mmc_out_ptr ) {
|
||||
mmc_out_ptr->disconnect_all ();
|
||||
std::vector<std::string> enabled_midi_outputs;
|
||||
EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
|
||||
|
||||
std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
|
||||
|
||||
for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
|
||||
mmc_out_ptr->connect (*port_iter);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
bool
|
||||
Session::ensure_stripable_sort_order ()
|
||||
{
|
||||
@ -3737,15 +3430,10 @@ Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
|
||||
|
||||
/* Re-sort routes to remove the graph's current references to the one that is
|
||||
* going away, then flush old references out of the graph.
|
||||
* Wave Tracks: reconnect routes
|
||||
*/
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
reconnect_existing_routes(true, false);
|
||||
#else
|
||||
routes.flush (); // maybe unsafe, see below.
|
||||
resort_routes ();
|
||||
#endif
|
||||
|
||||
if (_process_graph && !deletion_in_progress() && _engine.running()) {
|
||||
_process_graph->clear_other_chain ();
|
||||
@ -6951,14 +6639,6 @@ Session::notify_presentation_info_change ()
|
||||
}
|
||||
|
||||
reassign_track_numbers();
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
/* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
|
||||
* if track order has been changed by user
|
||||
*/
|
||||
reconnect_existing_routes(true, true);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
bool
|
||||
@ -6992,36 +6672,24 @@ void
|
||||
Session::set_range_selection (samplepos_t start, samplepos_t end)
|
||||
{
|
||||
_range_selection = Evoral::Range<samplepos_t> (start, end);
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
follow_playhead_priority ();
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
Session::set_object_selection (samplepos_t start, samplepos_t end)
|
||||
{
|
||||
_object_selection = Evoral::Range<samplepos_t> (start, end);
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
follow_playhead_priority ();
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
Session::clear_range_selection ()
|
||||
{
|
||||
_range_selection = Evoral::Range<samplepos_t> (-1,-1);
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
follow_playhead_priority ();
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
Session::clear_object_selection ()
|
||||
{
|
||||
_object_selection = Evoral::Range<samplepos_t> (-1,-1);
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
follow_playhead_priority ();
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -1425,83 +1425,6 @@ Session::non_realtime_locate ()
|
||||
clear_clicks ();
|
||||
}
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
bool
|
||||
Session::select_playhead_priority_target (samplepos_t& jump_to)
|
||||
{
|
||||
jump_to = -1;
|
||||
|
||||
AutoReturnTarget autoreturn = Config->get_auto_return_target_list ();
|
||||
|
||||
if (!autoreturn) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (Profile->get_trx() && transport_rolling() ) {
|
||||
// We're playing, so do nothing.
|
||||
// Next stop will put us where we need to be.
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Note that the order of checking each AutoReturnTarget flag defines
|
||||
the priority each flag.
|
||||
|
||||
Ardour/Mixbus: Last Locate
|
||||
Range Selection
|
||||
Loop Range
|
||||
Region Selection
|
||||
|
||||
Tracks: Range Selection
|
||||
Loop Range
|
||||
Region Selection
|
||||
Last Locate
|
||||
*/
|
||||
|
||||
if (autoreturn & RangeSelectionStart) {
|
||||
if (!_range_selection.empty()) {
|
||||
jump_to = _range_selection.from;
|
||||
} else {
|
||||
if (transport_rolling ()) {
|
||||
/* Range selection no longer exists, but we're playing,
|
||||
so do nothing. Next stop will put us where
|
||||
we need to be.
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (jump_to < 0 && (autoreturn & Loop) && get_play_loop()) {
|
||||
/* don't try to handle loop play when synced to JACK */
|
||||
|
||||
if (!synced_to_engine()) {
|
||||
Location *location = _locations->auto_loop_location();
|
||||
|
||||
if (location) {
|
||||
jump_to = location->start();
|
||||
|
||||
if (Config->get_seamless_loop()) {
|
||||
/* need to get track buffers reloaded */
|
||||
set_track_loop (true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (jump_to < 0 && (autoreturn & RegionSelectionStart)) {
|
||||
if (!_object_selection.empty()) {
|
||||
jump_to = _object_selection.from;
|
||||
}
|
||||
}
|
||||
|
||||
if (jump_to < 0 && (autoreturn & LastLocate)) {
|
||||
jump_to = _last_roll_location;
|
||||
}
|
||||
|
||||
return jump_to >= 0;
|
||||
}
|
||||
#else
|
||||
|
||||
bool
|
||||
Session::select_playhead_priority_target (samplepos_t& jump_to)
|
||||
{
|
||||
@ -1513,8 +1436,6 @@ Session::select_playhead_priority_target (samplepos_t& jump_to)
|
||||
return jump_to >= 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void
|
||||
Session::follow_playhead_priority ()
|
||||
{
|
||||
|
@ -373,8 +373,6 @@ def build(bld):
|
||||
|
||||
# operate on copy to avoid adding sources twice
|
||||
sources = list(libardour_sources)
|
||||
if bld.is_tracks_build():
|
||||
sources += [ 'engine_state_controller.cc' ]
|
||||
|
||||
# Library
|
||||
if bld.is_defined ('INTERNAL_SHARED_LIBS'):
|
||||
|
@ -28,11 +28,7 @@ using namespace ArdourCanvas;
|
||||
using std::min;
|
||||
using std::max;
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
static const bool show_bg_fades = false;
|
||||
#else
|
||||
static const bool show_bg_fades = true;
|
||||
#endif
|
||||
|
||||
XFadeCurve::XFadeCurve (Canvas* c)
|
||||
: Item (c)
|
||||
|
@ -138,98 +138,6 @@ CairoWidget::background_color ()
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_TRACKS_CODE_FEATURES
|
||||
|
||||
/* This is Tracks version of this method.
|
||||
|
||||
The use of get_visible_window() in this method is an abuse of the GDK/GTK
|
||||
semantics. It can and may break on different GDK backends, and uses a
|
||||
side-effect/unintended behaviour in GDK/GTK to try to accomplish something
|
||||
which should be done differently. I (Paul) have confirmed this with the GTK
|
||||
development team.
|
||||
|
||||
For this reason, this code is not acceptable for ordinary merging into the Ardour libraries.
|
||||
|
||||
Ardour Developers: you are not obligated to maintain the internals of this
|
||||
implementation in the face of build-time environment changes (e.g. -D
|
||||
defines etc).
|
||||
*/
|
||||
|
||||
bool
|
||||
CairoWidget::on_expose_event (GdkEventExpose *ev)
|
||||
{
|
||||
cairo_rectangle_t expose_area;
|
||||
expose_area.width = ev->area.width;
|
||||
expose_area.height = ev->area.height;
|
||||
|
||||
#ifdef USE_CAIRO_IMAGE_SURFACE_FOR_CAIRO_WIDGET
|
||||
Cairo::RefPtr<Cairo::Context> cr;
|
||||
if (get_visible_window ()) {
|
||||
expose_area.x = 0;
|
||||
expose_area.y = 0;
|
||||
if (!_image_surface) {
|
||||
_image_surface = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, get_width(), get_height());
|
||||
}
|
||||
cr = Cairo::Context::create (_image_surface);
|
||||
} else {
|
||||
expose_area.x = ev->area.x;
|
||||
expose_area.y = ev->area.y;
|
||||
cr = get_window()->create_cairo_context ();
|
||||
}
|
||||
#else
|
||||
expose_area.x = ev->area.x;
|
||||
expose_area.y = ev->area.y;
|
||||
Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context ();
|
||||
#endif
|
||||
|
||||
cr->rectangle (expose_area.x, expose_area.y, expose_area.width, expose_area.height);
|
||||
cr->clip ();
|
||||
|
||||
/* paint expose area the color of the parent window bg
|
||||
*/
|
||||
|
||||
if (get_visible_window ()) {
|
||||
Gdk::Color bg (get_parent_bg());
|
||||
cr->rectangle (expose_area.x, expose_area.y, expose_area.width, expose_area.height);
|
||||
cr->set_source_rgb (bg.get_red_p(), bg.get_green_p(), bg.get_blue_p());
|
||||
cr->fill ();
|
||||
}
|
||||
|
||||
render (cr, &expose_area);
|
||||
|
||||
#ifdef USE_CAIRO_IMAGE_SURFACE_FOR_CAIRO_WIDGET
|
||||
if(get_visible_window ()) {
|
||||
_image_surface->flush();
|
||||
/* now blit our private surface back to the GDK one */
|
||||
|
||||
Cairo::RefPtr<Cairo::Context> cairo_context = get_window()->create_cairo_context ();
|
||||
|
||||
cairo_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
|
||||
cairo_context->clip ();
|
||||
cairo_context->set_source (_image_surface, ev->area.x, ev->area.y);
|
||||
cairo_context->set_operator (Cairo::OPERATOR_OVER);
|
||||
cairo_context->paint ();
|
||||
}
|
||||
#endif
|
||||
|
||||
Gtk::Widget* child = get_child ();
|
||||
|
||||
if (child) {
|
||||
propagate_expose (*child, ev);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* Ardour mainline: not using Tracks code features.
|
||||
|
||||
Tracks Developers: please do not modify this version of
|
||||
::on_expose_event(). The version used by Tracks is before the preceding
|
||||
#else and contains hacks required for the Tracks GUI to work.
|
||||
*/
|
||||
|
||||
bool
|
||||
CairoWidget::on_expose_event (GdkEventExpose *ev)
|
||||
{
|
||||
@ -307,8 +215,6 @@ CairoWidget::on_expose_event (GdkEventExpose *ev)
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/** Marks the widget as dirty, so that render () will be called on
|
||||
* the next GTK expose event.
|
||||
*/
|
||||
|
@ -20,18 +20,12 @@ def configure(conf):
|
||||
autowaf.set_recursive()
|
||||
autowaf.configure(conf)
|
||||
|
||||
if conf.is_tracks_build():
|
||||
panners = [ '1in2out', 'vbap', 'stereobalance' ]
|
||||
else:
|
||||
panners = [ '2in2out', '1in2out', 'vbap', 'stereobalance' ]
|
||||
|
||||
for i in panners:
|
||||
sub_config_and_use(conf, i)
|
||||
|
||||
def build(bld):
|
||||
if bld.is_tracks_build():
|
||||
panners = [ '1in2out', 'vbap', 'stereobalance' ]
|
||||
else:
|
||||
panners = [ '2in2out', '1in2out', 'vbap', 'stereobalance' ]
|
||||
|
||||
for i in panners:
|
||||
|
13
wscript
13
wscript
@ -27,11 +27,6 @@ class i18n_mo(BuildContext):
|
||||
cmd = 'i18n_mo'
|
||||
fun = 'i18n_mo'
|
||||
|
||||
def is_tracks_build(self, *k, **kw):
|
||||
return self.env['PROGRAM_NAME'] == 'Tracks Live'
|
||||
|
||||
Context.Context.is_tracks_build = is_tracks_build
|
||||
|
||||
compiler_flags_dictionaries= {
|
||||
'gcc' : {
|
||||
# Flags required when building a debug build
|
||||
@ -712,9 +707,6 @@ def create_resource_file(icon):
|
||||
print('Could not open gtk2_ardour/windows_icon.rc for writing\n')
|
||||
sys.exit(-1)
|
||||
|
||||
def is_tracks_build (conf):
|
||||
return conf.env['PROGRAM_NAME'] == 'Tracks Live'
|
||||
|
||||
#----------------------------------------------------------------
|
||||
|
||||
# Waf stages
|
||||
@ -1388,11 +1380,6 @@ def build(bld):
|
||||
# set up target directories
|
||||
lwrcase_dirname = 'ardour' + bld.env['MAJOR']
|
||||
|
||||
if bld.is_tracks_build():
|
||||
bld.env.append_value ('CXXFLAGS', '-DUSE_TRACKS_CODE_FEATURES')
|
||||
bld.env.append_value ('CFLAGS', '-DUSE_TRACKS_CODE_FEATURES')
|
||||
lwrcase_dirname = 'trx'
|
||||
|
||||
# configuration files go here
|
||||
bld.env['CONFDIR'] = os.path.join(bld.env['SYSCONFDIR'], lwrcase_dirname)
|
||||
# data files loaded at run time go here
|
||||
|
Loading…
Reference in New Issue
Block a user