ardour/ardour
ardour/ardour
13
1
Fork 0
Code Pull Requests Releases Activity

goodbye USE_TRACKS_CODE_FEATURES and is_tracks_build

Browse Source
This commit is contained in:
Paul Davis 2019-09-25 12:16:13 -06:00
parent 13c874d8b0
commit 5ec5bc4523
16 changed files with 4 additions and 3208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/ardour/ardour/audioengine.h
View File

@ -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"; }

652
libs/ardour/ardour/engine_state_controller.h
View File

@ -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__) */

20
libs/ardour/ardour/rc_configuration_vars.h
View File

@ -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)

3
libs/ardour/ardour/session.h
View File

@ -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);

11
libs/ardour/ardour/session_configuration_vars.h
View File

@ -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

12
libs/ardour/audioengine.cc
View File

@ -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 ()
{

1906
libs/ardour/engine_state_controller.cc
View File

File diff suppressed because it is too large Load Diff

8
libs/ardour/filesystem_paths.cc
View File

@ -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

60
libs/ardour/route.cc
View File

@ -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

336
libs/ardour/session.cc
View File

@ -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
routes.flush (); // maybe unsafe, see below.
resort_routes ();
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

79
libs/ardour/session_transport.cc
View File

@ -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 ()
{

2
libs/ardour/wscript
View File

@ -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'):

4
libs/canvas/xfade_curve.cc
View File

@ -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)

94
libs/gtkmm2ext/cairo_widget.cc
View File

@ -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.
*/

10
libs/panners/wscript
View File

@ -20,19 +20,13 @@ def configure(conf):
autowaf.set_recursive()
autowaf.configure(conf)
if conf.is_tracks_build():
panners = [ '1in2out', 'vbap', 'stereobalance' ]
else:
panners = [ '2in2out', '1in2out', 'vbap', 'stereobalance' ]
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' ]
panners = [ '2in2out', '1in2out', 'vbap', 'stereobalance' ]
for i in panners:
bld.recurse(i)

13
wscript
View File

@ -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