#include <string>
#include <vector>
#include <sstream>
-#include <fstream>
#include <cstdio> /* sprintf(3) ... grrr */
#include <cmath>
#include <cerrno>
, loop_changing (false)
, last_loopend (0)
, _session_dir (new SessionDirectory (fullpath))
- , _current_snapshot_name (snapshot_name)
+ , _current_snapshot_name (snapshot_name)
, state_tree (0)
, state_was_pending (false)
, _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
, _route_deletion_in_progress (false)
, destructive_index (0)
, _track_number_decimals(1)
- , solo_update_disabled (false)
, default_fade_steepness (0)
, default_fade_msecs (0)
, _total_free_4k_blocks (0)
pthread_cond_init (&_rt_emit_cond, 0);
pre_engine_init (fullpath);
-
+
if (_is_new) {
Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
-#ifdef USE_TRACKS_CODE_FEATURES
+#ifdef USE_TRACKS_CODE_FEATURES
sr = EngineStateController::instance()->get_current_sample_rate();
#endif
if (ensure_engine (sr)) {
* of a template.
*/
- if (!mix_template.empty()) {
+ if (!mix_template.empty()) {
if (load_state (_current_snapshot_name)) {
throw SessionException (_("Failed to load template/snapshot state"));
}
if (load_state (_current_snapshot_name)) {
throw SessionException (_("Failed to load state"));
}
-
+
/* try to get sample rate from XML state so that we
* can influence the SR if we set up the audio
* engine.
if (state_tree) {
const XMLProperty* prop;
- if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
+ if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
sr = atoi (prop->value());
}
}
_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
+
+ // 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
-
+
_is_new = false;
session_loaded ();
Session::~Session ()
{
-#ifdef PT_TIMING
+#ifdef PT_TIMING
ST.dump ("ST.dump");
-#endif
+#endif
destroy ();
}
* know that the engine is running, but before we either create a
* session or set state for an existing one.
*/
-
+
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
it is a bit slower than the old code with 1 thread.
drop_connections ();
+ /* shutdown control surface protocols while we still have ports
+ and the engine to move data to any devices.
+ */
+
+ ControlProtocolManager::instance().drop_protocols ();
+
_engine.remove_session ();
#ifdef USE_TRACKS_CODE_FEATURES
_butler->drop_references ();
delete _butler;
_butler = 0;
-
+
delete _all_route_group;
DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
delete _locations; _locations = 0;
delete _tempo_map;
-
+
DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
Session::setup_ltc ()
{
XMLNode* child = 0;
-
+
_ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
_ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
-
+
if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
_ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
} else {
}
reconnect_ltc_input ();
}
-
+
if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
_ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
} else {
}
reconnect_ltc_output ();
}
-
+
/* fix up names of LTC ports because we don't want the normal
* IO style of NAME/TYPE-{in,out}N
*/
-
+
_ltc_input->nth (0)->set_name (X_("LTC-in"));
_ltc_output->nth (0)->set_name (X_("LTC-out"));
}
void
Session::setup_click_state (const XMLNode* node)
-{
+{
const XMLNode* child = 0;
-
+
if (node && (child = find_named_node (*node, "Click")) != 0) {
-
+
/* existing state for Click */
int c = 0;
}
}
}
-
+
if (c == 0) {
_clicking = Config->get_clicking ();
if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
return;
}
-
+
// Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
// In this case it means "Multi Out" output mode
if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
/* if requested auto-connect the outputs to the first N physical ports.
*/
-
+
uint32_t limit = _master_out->n_outputs().n_total();
vector<string> outputs[DataType::num_types];
-
+
for (uint32_t i = 0; i < DataType::num_types; ++i) {
_engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
}
-
+
for (uint32_t n = 0; n < limit; ++n) {
boost::shared_ptr<Port> p = _master_out->output()->nth (n);
string connect_to;
if (outputs[p->type()].size() > n) {
connect_to = outputs[p->type()][n];
}
-
+
if (!connect_to.empty() && p->connected_to (connect_to) == false) {
if (_master_out->output()->connect (p, connect_to, this)) {
error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
/* Hold process lock while doing this so that we don't hear bits and
* pieces of audio as we work on each route.
*/
-
+
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
+
/* Connect tracks to monitor section. Note that in an
existing session, the internal sends will already exist, but we want the
routes to notice that they connect to the control out specifically.
*/
-
-
+
+
boost::shared_ptr<RouteList> r = routes.reader ();
PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
-
+
for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
-
+
if ((*x)->is_monitor()) {
/* relax */
} else if ((*x)->is_master()) {
rl.push_back (r);
add_routes (rl, false, false, false);
-
+
assert (_monitor_out);
/* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
are undefined, at best.
*/
-
+
uint32_t limit = _monitor_out->n_inputs().n_audio();
-
+
if (_master_out) {
-
+
/* connect the inputs to the master bus outputs. this
* represents a separate data feed from the internal sends from
* each route. as of jan 2011, it allows the monitor section to
for (uint32_t n = 0; n < limit; ++n) {
boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
-
+
if (o) {
string connect_to = o->name();
if (_monitor_out->input()->connect (p, connect_to, this)) {
}
}
}
-
+
/* if monitor section is not connected, connect it to physical outs
*/
-
+
if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
-
+
if (!Config->get_monitor_bus_preferred_bundle().empty()) {
-
+
boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
-
+
if (b) {
_monitor_out->output()->connect_ports_to_bundle (b, true, this);
} else {
Config->get_monitor_bus_preferred_bundle())
<< endmsg;
}
-
+
} else {
-
+
/* Monitor bus is audio only */
vector<string> outputs[DataType::num_types];
uint32_t mod = outputs[DataType::AUDIO].size();
uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
-
+
if (mod != 0) {
-
+
for (uint32_t n = 0; n < limit; ++n) {
-
+
boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
string connect_to;
if (outputs[DataType::AUDIO].size() > (n % mod)) {
connect_to = outputs[DataType::AUDIO][n % mod];
}
-
+
if (!connect_to.empty()) {
if (_monitor_out->output()->connect (p, connect_to, this)) {
error << string_compose (
/* Hold process lock while doing this so that we don't hear bits and
* pieces of audio as we work on each route.
*/
-
+
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
/* Connect tracks to monitor section. Note that in an
PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
-
+
if ((*x)->is_monitor()) {
/* relax */
} else if ((*x)->is_master()) {
}
}
-
+
last_loopend = location->end();
set_dirty ();
}
//if there is no existing session, we need to make a new session location (should never happen)
existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
}
-
+
if (end <= start) {
error << _("Session: you can't use that location for session start/end)") << endmsg;
return;
}
existing->set( start, end );
-
+
set_dirty();
}
}
}
}
-
+
/* take care of our stuff first */
auto_loop_changed (location);
if (_ignore_skips_updates) {
return;
}
-
+
Locations::LocationList skips;
if (consolidate) {
}
sync_locations_to_skips ();
-
+
set_dirty ();
}
++l;
continue;
}
-
+
switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
case Evoral::OverlapInternal:
case Evoral::OverlapExternal:
Locations::LocationList const & locs (_locations->list());
for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
-
+
Location* location = *i;
-
+
if (location->is_skip() && location->is_skipping()) {
SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
queue_event (ev);
if (location->is_auto_loop()) {
set_auto_loop_location (location);
}
-
+
if (location->is_session_range()) {
/* no need for any signal handling or event setting with the session range,
because we keep a direct reference to it and use its start/end directly.
update_skips (location, true);
}
-
+
set_dirty ();
}
set_auto_loop_location (0);
set_track_loop (false);
}
-
+
if (location->is_auto_punch()) {
set_auto_punch_location (0);
}
}
if (location->is_skip()) {
-
+
update_skips (location, false);
}
void
Session::_locations_changed (const Locations::LocationList& locations)
{
- /* There was some mass-change in the Locations object.
+ /* There was some mass-change in the Locations object.
We might be re-adding a location here but it doesn't actually matter
for all the locations that the Session takes an interest in.
*/
-
+
{
PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
location_added (*i);
}
}
-
+
update_skips (NULL, false);
}
if (rs == Recording) {
break;
}
-
+
if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
_last_record_location = _transport_frame;
clear_clicks ();
reset_write_sources (false);
-
+
// XXX we need some equivalent to this, somehow
// SndFileSource::setup_standard_crossfades (frames_per_second);
::process(). It is therefore fine to do things that block
here.
*/
-
+
{
current_block_size = nframes;
return;
}
+ if (_route_deletion_in_progress) {
+ return;
+ }
+
{
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> r = writer.get_copy ();
/* We are going to build a directed graph of our routes;
this is where the edges of that graph are put.
*/
-
+
GraphEdges edges;
/* Go through all routes doing two things:
* routes directly or indirectly feed them. This information
* is used by the solo code.
*/
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
/* Clear out the route's list of direct or indirect feeds */
/* Attempt a topological sort of the route graph */
boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
-
+
if (sorted_routes) {
/* We got a satisfactory topological sort, so there is no feedback;
use this new graph.
if (_process_graph) {
_process_graph->rechain (sorted_routes, edges);
}
-
+
_current_route_graph = edges;
/* Complete the building of the routes' lists of what directly
so the solo code will think that everything is still connected
as it was before.
*/
-
+
FeedbackDetected (); /* EMIT SIGNAL */
}
routes, but hidden objects like the click track. So check port names
before anything else.
*/
-
+
for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
if (base == *reserved) {
definitely_add_number = true;
break;
}
}
-
+
if (!definitely_add_number && route_by_name (base) == 0) {
/* juse use the base */
name = base;
}
++id;
-
+
} while (id < (UINT_MAX-1));
return false;
* @param instrument plugin info for the instrument to insert pre-fader, if any
*/
list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
+Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
{
string track_name;
{
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (track->input()->ensure_io (input, false, this)) {
- error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
+ error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
goto failed;
}
PluginPtr plugin = instrument->load (*this);
boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
(*r)->add_processor (p, PreFader);
-
+
}
}
}
}
}
-#ifdef USE_TRACKS_CODE_FEATURES
+#ifdef USE_TRACKS_CODE_FEATURES
static bool
compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
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();
} 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 );
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);
-
+
}
}
}
-
+
//auto_connect_route (*rIter, inputs, outputs, false, reconnectIputs);
}
-
+
_master_out->output()->disconnect (this);
auto_connect_master_bus ();
}
-
+
graph_reordered ();
-
+
session_routes_reconnected (); /* EMIT SIGNAL */
}
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);
}
mtc_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->available && state_iter->mtc_in) {
mtc_in_ptr->connect (state_iter->name);
}
}
-
+
if (!_midi_ports->mtc_input_port ()->connected () &&
config.get_external_sync () &&
(Config->get_sync_source () == MTC) ) {
config.set_external_sync (false);
}
-
+
if ( ARDOUR::Profile->get_trx () ) {
// Tracks need this signal to update timecode_source_dropdown
MtcOrLtcInputPortChanged (); //emit signal
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);
}
* @param name_template string to use for the start of the name, or "" to use "Audio".
*/
list< boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
+Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
uint32_t how_many, string name_template)
{
string track_name;
const string name_pattern = default_track_name_pattern (DataType::AUDIO);
bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
-
+
while (how_many) {
if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
RouteList ret;
bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
-
+
while (how_many) {
if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
error << "cannot find name for new audio bus" << endmsg;
bus->add_internal_return ();
ret.push_back (bus);
-
+
RouteAddedOrRemoved (true); /* EMIT SIGNAL */
ARDOUR::GUIIdle ();
} else {
string const route_name = node_copy.property(X_("name"))->value ();
-
+
/* generate a new name by adding a number to the end of the template name */
if (!find_route_name (route_name.c_str(), ++number, name, true)) {
fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
}
}
}
-
+
boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
if (route == 0) {
update_latency (true);
update_latency (false);
-
+
set_dirty();
-
+
if (save) {
save_state (_current_snapshot_name);
}
-
+
reassign_track_numbers();
update_route_record_state ();
-
+
RouteAdded (new_routes); /* EMIT SIGNAL */
}
boost::weak_ptr<Route> wpr (*x);
boost::shared_ptr<Route> r (*x);
- r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
- r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
+ r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _2, wpr));
+ r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _3, wpr));
r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
}
if (_monitor_out && IO::connecting_legal) {
- Glib::Threads::Mutex::Lock lm (_engine.process_lock());
-
+ Glib::Threads::Mutex::Lock lm (_engine.process_lock());
+
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
if ((*x)->is_monitor()) {
/* relax */
void
Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
{
- PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
-
{ // RCU Writer scope
+ PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> rs = writer.get_copy ();
-
-
+
+
for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
-
+
if (*iter == _master_out) {
continue;
}
-
+
(*iter)->set_solo (false, this);
-
+
rs->remove (*iter);
-
+
/* deleting the master out seems like a dumb
idea, but its more of a UI policy issue
than our concern.
*/
-
+
if (*iter == _master_out) {
_master_out = boost::shared_ptr<Route> ();
}
-
+
if (*iter == _monitor_out) {
_monitor_out.reset ();
}
// We need to disconnect the route's inputs and outputs
-
+
(*iter)->input()->disconnect (0);
(*iter)->output()->disconnect (0);
-
+
/* if the route had internal sends sending to it, remove them */
if ((*iter)->internal_return()) {
-
+
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
}
}
}
-
+
/* if the monitoring section had a pointer to this route, remove it */
if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
(*iter)->remove_aux_or_listen (_monitor_out);
}
-
+
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
if (mt && mt->step_editing()) {
if (_step_editors > 0) {
}
}
}
-
+
/* writer goes out of scope, forces route list update */
} // end of RCU Writer scope
-
+
update_route_solo_state ();
RouteAddedOrRemoved (false); /* EMIT SIGNAL */
update_latency_compensation ();
set_dirty();
-
+
/* 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
routes.flush (); // maybe unsafe, see below.
resort_routes ();
#endif
-
+
if (_process_graph) {
_process_graph->clear_other_chain ();
}
-
+
/* get rid of it from the dead wood collection in the route list manager */
/* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
-
+
routes.flush ();
-
+
/* try to cause everyone to drop their references
* and unregister ports from the backend
*/
for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
(*iter)->drop_references ();
}
-
+
Route::RemoteControlIDChange(); /* EMIT SIGNAL */
-
+
/* save the new state of the world */
-
+
if (save_state (_current_snapshot_name)) {
save_history (_current_snapshot_name);
}
}
void
-Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
+Session::route_listen_changed (bool group_override, boost::weak_ptr<Route> wpr)
{
boost::shared_ptr<Route> route = wpr.lock();
if (!route) {
- error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_listen_changed")) << endmsg;
return;
}
if (route->listening_via_monitor ()) {
if (Config->get_exclusive_solo()) {
- /* new listen: disable all other listen */
+ /* new listen: disable all other listen, except solo-grouped channels */
+ RouteGroup* rg = route->route_group ();
+ bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
+ if (group_override && rg) {
+ leave_group_alone = !leave_group_alone;
+ }
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() || (leave_group_alone && ((*i)->route_group() == rg))) {
continue;
}
- (*i)->set_listen (false, this);
+ (*i)->set_listen (false, this, group_override);
}
}
if (!route) {
/* should not happen */
- error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_isolated_changed")) << endmsg;
return;
}
}
void
-Session::routes_solo_changed (boost::shared_ptr<RouteList> solo_change_routes)
-{
- if (solo_update_disabled) {
- // We know already
- DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
- return;
- }
-
- if (solo_change_routes->empty() ) {
- return;
- }
-
- boost::shared_ptr<RouteList> non_solo_change_routes (new RouteList);
- boost::shared_ptr<RouteList> r = routes.reader ();
- int32_t delta;
-
- std::set_difference (r->begin(), r->end(),
- solo_change_routes->begin(), solo_change_routes->end(),
- std::back_inserter(*non_solo_change_routes) );
-
- DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
-
- solo_update_disabled = true;
- RouteList uninvolved;
-
- for (RouteList::iterator route = solo_change_routes->begin(); route != solo_change_routes->end(); ++route) {
-
- if ((*route)->self_soloed() ) {
- delta = 1;
- } else {
- delta = -1;
- }
-
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", (*route)->name()));
-
- for (RouteList::iterator i = non_solo_change_routes->begin(); i != non_solo_change_routes->end(); ++i) {
- bool via_sends_only;
- bool in_signal_flow;
-
- if ((*i) == *route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ) {
- continue;
- }
-
- in_signal_flow = false;
-
- DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
-
- if ((*i)->feeds (*route, &via_sends_only)) {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
- if (!via_sends_only) {
- if (!(*route)->soloed_by_others_upstream()) {
- (*i)->mod_solo_by_others_downstream (delta);
- }
- } else {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
- }
- in_signal_flow = true;
- } else {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
- }
-
- DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
-
- if ((*route)->feeds (*i, &via_sends_only)) {
- /* propagate solo upstream only if routing other than
- sends is involved, but do consider the other route
- (*i) to be part of the signal flow even if only
- sends are involved.
- */
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
- (*route)->name(),
- (*i)->name(),
- via_sends_only,
- (*route)->soloed_by_others_downstream(),
- (*route)->soloed_by_others_upstream()));
- if (!via_sends_only) {
- if (!(*route)->soloed_by_others_downstream()) {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
- (*i)->mod_solo_by_others_upstream (delta);
- } else {
- DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
- }
- } else {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
- }
- in_signal_flow = true;
- } else {
- DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
- }
-
- if (!in_signal_flow) {
- uninvolved.push_back (*i);
- }
- }
- }
- solo_update_disabled = false;
- DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
-
- update_route_solo_state ();
-
- /* now notify that the mute state of the routes not involved in the signal
- pathway of the just-solo-changed route may have altered.
- */
-
- for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name() ));
- (*i)->mute_changed (this);
- }
-
- SoloChanged (); /* EMIT SIGNAL */
- set_dirty();
-}
-
-void
-Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
+Session::route_solo_changed (bool self_solo_change, bool group_override, boost::weak_ptr<Route> wpr)
{
DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
return;
}
- if (solo_update_disabled) {
- // We know already
- DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
- return;
- }
-
boost::shared_ptr<Route> route = wpr.lock ();
assert (route);
RouteGroup* rg = route->route_group ();
bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
-
+ if (group_override && rg) {
+ leave_group_alone = !leave_group_alone;
+ }
if (delta == 1 && Config->get_exclusive_solo()) {
-
+
/* new solo: disable all other solos, but not the group if its solo-enabled */
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
+ if ((*i) == route || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
(leave_group_alone && ((*i)->route_group() == rg))) {
continue;
}
- (*i)->set_solo (false, this);
+ (*i)->set_solo (false, this, group_override);
}
}
DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
- solo_update_disabled = true;
-
RouteList uninvolved;
DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
bool via_sends_only;
bool in_signal_flow;
- if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
+ if ((*i) == route || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
(leave_group_alone && ((*i)->route_group() == rg))) {
continue;
}
in_signal_flow = false;
DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
-
+
if ((*i)->feeds (route, &via_sends_only)) {
DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
if (!via_sends_only) {
if (!route->soloed_by_others_upstream()) {
(*i)->mod_solo_by_others_downstream (delta);
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
}
} else {
DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
} else {
DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
}
-
+
DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
if (route->feeds (*i, &via_sends_only)) {
route->soloed_by_others_downstream(),
route->soloed_by_others_upstream()));
if (!via_sends_only) {
- if (!route->soloed_by_others_downstream()) {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
- (*i)->mod_solo_by_others_upstream (delta);
- } else {
- DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
- }
+ //NB. Triggers Invert Push, which handles soloed by downstream
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
+ (*i)->mod_solo_by_others_upstream (delta);
} else {
DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
}
}
}
- solo_update_disabled = false;
DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
update_route_solo_state (r);
return false;
}
}
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if ((*i)->name() == name) {
return false;
for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
PortSet& ps ((*rt)->input()->ports());
-
+
for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
p->get_connections (connections);
}
-
+
for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
routes_using_input_from (*s, rl2);
}
-
+
/* scan all relevant routes to see if others are on or off */
-
+
bool others_are_already_on = false;
-
+
for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
mt->set_input_active (onoff);
}
}
-
+
if (flip_others) {
/* globally reverse other routes */
-
+
for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
if ((*r) != (*rt)) {
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
/* yay, new source */
boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
-
+
if (fs) {
if (!fs->within_session()) {
ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
}
}
-
+
set_dirty();
boost::shared_ptr<AudioFileSource> afs;
= boost::dynamic_pointer_cast<MidiSource>(s->second);
boost::shared_ptr<FileSource> fs
= boost::dynamic_pointer_cast<FileSource>(s->second);
-
+
if (ms && fs && fs->path() == path) {
return ms;
}
string session_path;
bool in_another_session = true;
-
+
if (filepath.find (interchange_dir_string) != string::npos) {
-
+
session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
} else {
in_another_session = false;
}
-
+
if (in_another_session) {
SessionDirectory sd (session_path);
if (!in_session) {
path = Glib::path_get_dirname (filepath);
}
-
+
return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
}
string
Session::new_audio_source_path_for_embedded (const std::string& path)
{
- /* embedded source:
+ /* embedded source:
*
* we know that the filename is already unique because it exists
- * out in the filesystem.
+ * out in the filesystem.
*
* However, when we bring it into the session, we could get a
* collision.
*
* Eg. two embedded files:
- *
+ *
* /foo/bar/baz.wav
* /frob/nic/baz.wav
*
- * When merged into session, these collide.
+ * When merged into session, these collide.
*
* There will not be a conflict with in-memory sources
* because when the source was created we already picked
SessionDirectory sdir (get_best_session_directory_for_new_audio());
string base = Glib::path_get_basename (path);
string newpath = Glib::build_filename (sdir.sound_path(), base);
-
+
if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
MD5 md5;
md5.digestString (path.c_str());
md5.writeToString ();
base = md5.digestChars;
-
+
string ext = get_suffix (path);
if (!ext.empty()) {
base += '.';
base += ext;
}
-
+
newpath = Glib::build_filename (sdir.sound_path(), base);
/* if this collides, we're screwed */
return newpath;
}
-/** Return true if there are no audio file sources that use @param name as
- * the filename component of their path.
+/** Return true if there are no audio file sources that use @param name as
+ * the filename component of their path.
*
* Return false otherwise.
*
- * This method MUST ONLY be used to check in-session, mono files since it
+ * This method MUST ONLY be used to check in-session, mono files since it
* hard-codes the channel of the audio file source we are looking for as zero.
- *
+ *
* If/when Ardour supports native files in non-mono formats, the logic here
* will need to be revisited.
*/
uint32_t existing = 0;
for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
-
+
/* note that we search *without* the extension so that
we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
in the event that this new name is required for
*/
const string spath = *i;
-
+
if (matching_unsuffixed_filename_exists_in (spath, name)) {
existing++;
break;
}
-
+
/* it is possible that we have the path already
* assigned to a source that has not yet been written
* (ie. the write source for a diskstream). we have to
* two Sources point to the same file with different
* notions of their removability.
*/
-
-
+
+
string possible_path = Glib::build_filename (spath, name);
if (audio_source_by_path_and_channel (possible_path, 0)) {
{
ostringstream sstr;
const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
-
+
if (Profile->get_trx() && destructive) {
sstr << 'T';
sstr << setfill ('0') << setw (4) << cnt;
sstr << legalized_base;
} else {
sstr << legalized_base;
-
+
if (take_required || related_exists) {
sstr << '-';
sstr << cnt;
}
}
-
+
if (nchan == 2) {
if (chan == 0) {
sstr << "%L";
sstr << chan+1;
}
}
-
+
sstr << ext;
return sstr.str();
for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
-
+
if (audio_source_name_is_unique (possible_name)) {
break;
}
-
+
some_related_source_name_exists = true;
if (cnt > limit) {
vector<space_and_path>::iterator i;
uint32_t existing = 0;
-
+
for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
possible_name = buf;
possible_path = Glib::build_filename (*i, possible_name);
-
+
if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
existing++;
}
Session::create_midi_source_for_session (string const & basic_name)
{
const string path = new_midi_source_path (basic_name);
-
+
if (!path.empty()) {
return boost::dynamic_pointer_cast<SMFSource> (
SourceFactory::createWritable (
Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
{
/* the caller passes in the track the source will be used in,
- so that we can keep the numbering sane.
-
+ so that we can keep the numbering sane.
+
Rationale: a track with the name "Foo" that has had N
captures carried out so far will ALREADY have a write source
named "Foo-N+1.mid" waiting to be used for the next capture.
-
+
If we call new_midi_source_name() we will get "Foo-N+2". But
there is no region corresponding to "Foo-N+1", so when
"Foo-N+2" appears in the track, the gap presents the user
with odd behaviour - why did it skip past Foo-N+1?
-
+
We could explain this to the user in some odd way, but
instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
use "Foo-N+1" here.
-
+
If that attempted rename fails, we get "Foo-N+2.mid" anyway.
*/
-
+
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
assert (mt);
std::string name = track->steal_write_source_name ();
if (_total_free_4k_blocks_uncertain) {
return boost::optional<framecnt_t> ();
}
-
+
float sample_bytes_on_disk = 4.0; // keep gcc happy
switch (config.get_native_file_data_format()) {
boost::shared_ptr<Region>
Session::write_one_track (Track& track, framepos_t start, framepos_t end,
bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
- InterThreadInfo& itt,
+ InterThreadInfo& itt,
boost::shared_ptr<Processor> endpoint, bool include_endpoint,
bool for_export, bool for_freeze)
{
string path = ((track.data_type() == DataType::AUDIO)
? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
: new_midi_source_path (legal_playlist_name));
-
+
if (path.empty()) {
goto out;
}
break;
}
}
-
+
g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
-
+
if (record_status() == Recording && record_arm_state_changed ) {
RecordArmStateChanged ();
}
-
+
}
void
(some_track_latency_changed ? "yes" : "no")));
DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
-
+
if (some_track_latency_changed || force_whole_graph) {
_engine.update_latencies ();
}
return 0;
}
-uint32_t
+uint32_t
Session::next_control_id () const
{
int subtract = 0;
*/
reconnect_existing_routes(true, true);
#endif
-
+
}
void
_object_selection = Evoral::Range<framepos_t> (-1,-1);
#ifdef USE_TRACKS_CODE_FEATURES
follow_playhead_priority ();
-#endif
+#endif
}
projects / ardour.git / blobdiff