#include "pbd/stacktrace.h"
#include "pbd/file_utils.h"
+#include "ardour/amp.h"
#include "ardour/analyser.h"
#include "ardour/audio_buffer.h"
#include "ardour/audio_diskstream.h"
#include "ardour/auditioner.h"
#include "ardour/buffer_set.h"
#include "ardour/bundle.h"
+#include "ardour/butler.h"
#include "ardour/click.h"
#include "ardour/configuration.h"
#include "ardour/crossfade.h"
#include "ardour/cycle_timer.h"
#include "ardour/data_type.h"
#include "ardour/filename_extensions.h"
+#include "ardour/internal_send.h"
#include "ardour/io_processor.h"
#include "ardour/midi_diskstream.h"
#include "ardour/midi_playlist.h"
#include "ardour/plugin_insert.h"
#include "ardour/port_insert.h"
#include "ardour/processor.h"
+#include "ardour/rc_configuration.h"
#include "ardour/recent_sessions.h"
#include "ardour/region_factory.h"
#include "ardour/return.h"
sigc::signal<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
sigc::signal<void> Session::SendFeedback;
-sigc::signal<void> Session::SMPTEOffsetChanged;
+sigc::signal<void> Session::TimecodeOffsetChanged;
sigc::signal<void> Session::StartTimeChanged;
sigc::signal<void> Session::EndTimeChanged;
sigc::signal<void> Session::AutoBindingOn;
_session_dir (new SessionDirectory(fullpath)),
pending_events (2048),
state_tree (0),
- butler_mixdown_buffer (0),
- butler_gain_buffer (0),
- post_transport_work((PostTransportWork)0),
- _send_smpte_update (false),
+ _butler (new Butler (this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
midi_thread (pthread_t (0)),
midi_requests (128), // the size of this should match the midi request pool size
diskstreams (new DiskstreamList),
throw failed_constructor();
}
- cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
+ info << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
n_physical_outputs = _engine.n_physical_outputs(DataType::AUDIO);
n_physical_inputs = _engine.n_physical_inputs(DataType::AUDIO);
_session_dir ( new SessionDirectory(fullpath)),
pending_events (2048),
state_tree (0),
- butler_mixdown_buffer (0),
- butler_gain_buffer (0),
- post_transport_work((PostTransportWork)0),
- _send_smpte_update (false),
+ _butler (new Butler (this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
midi_thread (pthread_t (0)),
midi_requests (16),
diskstreams (new DiskstreamList),
throw failed_constructor();
}
- cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
+ info << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
n_physical_outputs = _engine.n_physical_outputs (DataType::AUDIO);
n_physical_inputs = _engine.n_physical_inputs (DataType::AUDIO);
delete state_tree;
- terminate_butler_thread ();
+ /* reset dynamic state version back to default */
+
+ Stateful::loading_state_version = 0;
+
+ _butler->terminate_thread ();
//terminate_midi_thread ();
if (click_data != default_click) {
delete *i;
}
- delete [] butler_mixdown_buffer;
- delete [] butler_gain_buffer;
-
Crossfade::set_buffer_size (0);
delete mmc;
if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
/* existing state for Click */
+ int c;
- if (_click_io->set_state (*child->children().front()) == 0) {
+ if (Stateful::loading_state_version < 3000) {
+ c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
+ } else {
+ c = _click_io->set_state (*child->children().front(), Stateful::loading_state_version);
+ }
+
+ if (c == 0) {
_clicking = Config->get_clicking ();
-
+
} else {
-
+
error << _("could not setup Click I/O") << endmsg;
_clicking = false;
}
+
} else {
/* default state for Click: dual-mono to first 2 physical outputs */
for (int physport = 0; physport < 2; ++physport) {
string physical_output = _engine.get_nth_physical_output (DataType::AUDIO, physport);
-
+
if (physical_output.length()) {
if (_click_io->add_port (physical_output, this)) {
// relax, even though its an error
}
}
}
-
+
if (_click_io->n_ports () > ChanCount::ZERO) {
_clicking = Config->get_clicking ();
}
mono and stereo bundles, so that the common cases of mono
and stereo tracks get bundles to put in their mixer strip
in / out menus. There may be a nicer way of achieving that;
- it doesn't really scale that well to higher channel counts
+ it doesn't really scale that well to higher channel counts
*/
/* mono output bundles */
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
- shared_ptr<Bundle> c (new Bundle (buf, true));
+ shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("mono"));
- c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+ c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
- add_bundle (c);
+ add_bundle (c);
}
/* stereo output bundles */
char buf[32];
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
- shared_ptr<Bundle> c (new Bundle (buf, false));
+ shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("mono"));
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
- add_bundle (c);
+ add_bundle (c);
}
/* stereo input bundles */
add_bundle (c);
}
}
-
+
BootMessage (_("Setup signal flow and plugins"));
hookup_io ();
if (!no_auto_connect()) {
if (_master_out && Config->get_auto_connect_standard_busses()) {
-
+
/* if requested auto-connect the outputs to the first N physical ports.
*/
uint32_t limit = _master_out->n_outputs().n_total();
-
+
for (uint32_t n = 0; n < limit; ++n) {
Port* p = _master_out->output()->nth (n);
string connect_to = _engine.get_nth_physical_output (DataType (p->type()), n);
- if (!connect_to.empty()) {
+ 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)
+ error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
<< endmsg;
break;
}
are undefined, at best.
*/
- /* control out listens to master bus (but ignores it
+ /* control out listens to master bus (but ignores it
under some conditions)
*/
uint32_t limit = _control_out->n_inputs().n_audio();
-
+
if (_master_out) {
for (uint32_t n = 0; n < limit; ++n) {
AudioPort* p = _control_out->input()->ports().nth_audio_port (n);
AudioPort* o = _master_out->output()->ports().nth_audio_port (n);
-
+
if (o) {
string connect_to = o->name();
if (_control_out->input()->connect (p, connect_to, this)) {
- error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
+ error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
<< endmsg;
break;
}
}
}
- /* if control out is not connected,
+ /* if control out is not connected,
connect control out to physical outs, but use ones after the master if possible
*/
_control_out->output()->connect_ports_to_bundle (b, this);
} else {
warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
- Config->get_monitor_bus_preferred_bundle())
+ Config->get_monitor_bus_preferred_bundle())
<< endmsg;
}
} else {
/* XXX this logic is wrong for mixed port types */
-
+
uint32_t shift = _master_out->n_outputs().n_audio();
uint32_t mod = _engine.n_physical_outputs (DataType::AUDIO);
limit = _control_out->n_outputs().n_audio();
cerr << "Connecting " << limit << " control out ports, shift is " << shift << " mod is " << mod << endl;
-
+
for (uint32_t n = 0; n < limit; ++n) {
-
+
Port* p = _control_out->output()->nth (n);
string connect_to = _engine.get_nth_physical_output (DataType (p->type()), (n+shift) % mod);
-
+
if (!connect_to.empty()) {
if (_control_out->output()->connect (p, connect_to, this)) {
- error << string_compose (_("cannot connect control output %1 to %2"), n, connect_to)
+ error << string_compose (_("cannot connect control output %1 to %2"), n, connect_to)
<< endmsg;
break;
}
if (_control_out) {
boost::shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
if ((*x)->is_control() || (*x)->is_master()) {
continue;
}
- (*x)->listen_via (_control_out, false);
+ (*x)->listen_via (_control_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
}
}
}
void
-Session::diskstream_playlist_changed (boost::shared_ptr<Diskstream> dstream)
+Session::diskstream_playlist_changed (boost::weak_ptr<Diskstream> wp)
{
+ boost::shared_ptr<Diskstream> dstream = wp.lock ();
+ if (!dstream) {
+ return;
+ }
+
boost::shared_ptr<Playlist> playlist;
if ((playlist = dstream->playlist()) != 0) {
Session::record_enabling_legal () const
{
/* this used to be in here, but survey says.... we don't need to restrict it */
- // if (record_status() == Recording) {
- // return false;
- // }
+ // if (record_status() == Recording) {
+ // return false;
+ // }
if (Config->get_all_safe()) {
return false;
if (transport_rolling() && play_loop) {
- //if (_transport_frame < location->start() || _transport_frame > location->end()) {
- if (_transport_frame > location->end()) {
+ // if (_transport_frame > location->end()) {
+
+ if (_transport_frame < location->start() || _transport_frame > location->end()) {
// relocate to beginning of loop
clear_events (Event::LocateRoll);
auto_loop_end_changed_connection.disconnect();
auto_loop_changed_connection.disconnect();
- auto_loop_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_loop_changed));
- auto_loop_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_loop_changed));
- auto_loop_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_loop_changed));
+ auto_loop_start_changed_connection = location->start_changed.connect (
+ mem_fun (this, &Session::auto_loop_changed));
+ auto_loop_end_changed_connection = location->end_changed.connect (
+ mem_fun (this, &Session::auto_loop_changed));
+ auto_loop_changed_connection = location->changed.connect (
+ mem_fun (this, &Session::auto_loop_changed));
location->set_auto_loop (true, this);
}
void
-Session::locations_added (Location* ignored)
+Session::locations_added (Location *)
{
set_dirty ();
}
set_dirty();
}
-nframes_t
+nframes64_t
Session::audible_frame () const
{
- nframes_t ret;
+ nframes64_t ret;
+ nframes64_t tf;
nframes_t offset;
- nframes_t tf;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
} else {
tf = _transport_frame;
}
-
+
ret = tf;
if (!non_realtime_work_pending()) {
if (tf < _last_roll_location + offset) {
return _last_roll_location;
}
- }
-
+ }
+
/* forwards */
ret -= offset;
}
void
-Session::set_default_fade (float steepness, float fade_msecs)
+Session::set_default_fade (float /*steepness*/, float /*fade_msecs*/)
{
#if 0
nframes_t fade_frames;
}
- if (track->output()->ensure_io (ChanCount(DataType::AUDIO, 1), false, this)) {
+ if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
goto failed;
}
<< endmsg;
goto failed;
}
-
+
if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
input_channels, output_channels)
for (uint32_t x = 0; x < track->n_outputs().n_audio(); ++x) {
port = "";
-
+
if (Config->get_output_auto_connect() & AutoConnectPhysical) {
port = physoutputs[(channels_used+x)%nphysical_out];
} else if (Config->get_output_auto_connect() & AutoConnectMaster) {
port = _master_out->input()->nth (x % _master_out->input()->n_ports().n_audio())->name();
}
}
-
+
if (port.length() && track->output()->connect (track->output()->nth(x), port, this)) {
break;
}
RouteList
-Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
+Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
{
char bus_name[32];
uint32_t bus_id = 1;
for (uint32_t x = 0; n_physical_audio_inputs && x < bus->input()->n_ports().n_audio(); ++x) {
port = "";
-
+
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[((n+x)%n_physical_audio_inputs)];
- }
-
+ }
+
if (port.length() && bus->input()->connect (bus->input()->nth (x), port, this)) {
break;
}
bus->set_remote_control_id (control_id);
++control_id;
+ if (aux) {
+ bus->add_internal_return ();
+ }
+
ret.push_back (bus);
}
while (how_many) {
XMLNode node_copy (*node); // make a copy so we can change the name if we need to
-
+
std::string node_name = IO::name_from_state (*node_copy.children().front());
/* generate a new name by adding a number to the end of the template name */
-
+
do {
snprintf (name, sizeof (name), "%s %" PRIu32, node_name.c_str(), number);
-
+
number++;
-
+
if (route_by_name (name) == 0) {
break;
}
-
+
} while (number < UINT_MAX);
-
+
if (number == UINT_MAX) {
fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
/*NOTREACHED*/
}
-
+
IO::set_name_in_state (*node_copy.children().front(), name);
Track::zero_diskstream_id_in_xml (node_copy);
try {
- shared_ptr<Route> route (XMLRouteFactory (node_copy));
+ shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
if (route == 0) {
error << _("Session: cannot create track/bus from template description") << endmsg;
route->input()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
route->output()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
}
-
+
route->set_remote_control_id (control_id);
++control_id;
-
+
ret.push_back (route);
}
-
+
catch (failed_constructor &err) {
error << _("Session: could not create new route from template") << endmsg;
goto out;
}
-
+
catch (AudioEngine::PortRegistrationFailure& pfe) {
error << pfe.what() << endmsg;
goto out;
}
-
+
--how_many;
}
/* if there is no control out and we're not in the middle of loading,
resort the graph here. if there is a control out, we will resort
- toward the end of this method. if we are in the middle of loading,
+ toward the end of this method. if we are in the middle of loading,
we will resort when done.
*/
if ((*x)->is_control() || (*x)->is_master()) {
continue;
}
- cerr << "Add listen via control outs\n";
- (*x)->listen_via (_control_out, false);
+ (*x)->listen_via (_control_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
}
resort_routes ();
}
void
-Session::globally_add_internal_sends (boost::shared_ptr<Route> dest)
+Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
+{
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<Send> s;
+
+ /* only tracks */
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (boost::dynamic_pointer_cast<Track>(*i)) {
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (0.0);
+ }
+ }
+ }
+}
+
+void
+Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
+{
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<Send> s;
+
+ /* only tracks */
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (boost::dynamic_pointer_cast<Track>(*i)) {
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (1.0);
+ }
+ }
+ }
+}
+
+void
+Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
+{
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<Send> s;
+
+ /* only tracks */
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (boost::dynamic_pointer_cast<Track>(*i)) {
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
+ }
+ }
+ }
+}
+
+void
+Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p)
{
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<RouteList> t (new RouteList);
}
}
- add_internal_sends (dest, t);
+ add_internal_sends (dest, p, t);
}
void
-Session::add_internal_sends (boost::shared_ptr<Route> dest, boost::shared_ptr<RouteList> senders)
+Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
{
if (dest->is_control() || dest->is_master()) {
return;
continue;
}
- cerr << (*i)->name() << " listening via " << dest->name() << endl;
- (*i)->listen_via (dest, true);
+ (*i)->listen_via (dest, p, true, true);
}
+
+ graph_reordered ();
}
void
/* writer goes out of scope, copies ds back to main */
}
- dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
+ dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), boost::weak_ptr<Diskstream> (dstream)));
/* this will connect to future changes, and check the current length */
- diskstream_playlist_changed (dstream);
+ diskstream_playlist_changed (boost::weak_ptr<Diskstream> (dstream));
dstream->RecordEnableChanged.connect (mem_fun (*this, &Session::update_have_rec_enabled_diskstream));
}
void
-Session::route_mute_changed (void* src)
+Session::route_mute_changed (void* /*src*/)
{
set_dirty ();
}
void
-Session::route_listen_changed (void* src, boost::weak_ptr<Route> wpr)
+Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
boost::shared_ptr<Route> route = wpr.lock();
if (!route) {
}
void
-Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
+Session::route_solo_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
if (solo_update_disabled) {
// We know already
shared_ptr<RouteList> r = routes.reader ();
int32_t delta;
- if (route->soloed()) {
+ if (route->self_soloed()) {
delta = 1;
} else {
delta = -1;
/* now mod the solo level of all other routes except master & control outs
so that they will be silent if appropriate.
*/
-
+
solo_update_disabled = true;
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ bool via_sends_only;
- if ((*i)->feeds (route) && !(*i)->is_hidden() && !(*i)->is_master() && !(*i)->is_control()) {
- /* do it */
- (*i)->mod_solo_level (delta);
- }
+
+ if ((*i) == route || !(*i)->solo_isolated() || !(*i)->is_master() || !(*i)->is_control() || (*i)->is_hidden()) {
+ continue;
+ } else if ((*i)->feeds (route, &via_sends_only)) {
+ if (!via_sends_only) {
+ (*i)->mod_solo_by_others (delta);
+ }
+ }
}
/* make sure master is never muted by solo */
- if (route != _master_out && _master_out->solo_level() == 0 && !_master_out->soloed()) {
- _master_out->mod_solo_level (1);
- }
-
+ if (_master_out && route != _master_out && _master_out->soloed_by_others() == 0 && !_master_out->soloed()) {
+ _master_out->mod_solo_by_others (1);
+ }
+
/* ditto for control outs make sure master is never muted by solo */
- if (route != _control_out && _control_out && _control_out->solo_level() == 0) {
- _control_out->mod_solo_level (1);
+ if (_control_out && route != _control_out && _control_out && _control_out->soloed_by_others() == 0) {
+ _control_out->mod_solo_by_others (1);
}
solo_update_disabled = false;
}
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_master() && !(*i)->is_control() && !(*i)->is_hidden() && (*i)->soloed()) {
+ if (!(*i)->is_master() && !(*i)->is_control() && !(*i)->is_hidden() && (*i)->self_soloed()) {
something_soloed = true;
break;
}
}
}
+boost::shared_ptr<RouteList>
+Session::get_routes_with_internal_returns() const
+{
+ shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> rl (new RouteList);
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if ((*i)->internal_return ()) {
+ rl->push_back (*i);
+ }
+ }
+ return rl;
+}
+
shared_ptr<Route>
Session::route_by_name (string name)
{
Session::update_region_name_map (boost::shared_ptr<Region> region)
{
string::size_type last_period = region->name().find_last_of ('.');
-
+
if (last_period != string::npos && last_period < region->name().length() - 1) {
-
+
string base = region->name().substr (0, last_period);
string number = region->name().substr (last_period+1);
map<string,uint32_t>::iterator x;
-
+
/* note that if there is no number, we get zero from atoi,
which is just fine
*/
-
+
region_name_map[base] = atoi (number);
}
}
}
}
+/** Return the number of playlists (not regions) that contain @a src */
+uint32_t
+Session::source_use_count (boost::shared_ptr<const Source> src) const
+{
+ uint32_t count = 0;
+ for (PlaylistList::const_iterator p = playlists.begin(); p != playlists.end(); ++p) {
+ for (Playlist::RegionList::const_iterator r = (*p)->region_list().begin();
+ r != (*p)->region_list().end(); ++r) {
+ if ((*r)->uses_source(src)) {
+ ++count;
+ break;
+ }
+ }
+ }
+ return count;
+}
+
boost::shared_ptr<Source>
Session::source_by_id (const PBD::ID& id)
{
Session::set_audition (boost::shared_ptr<Region> r)
{
pending_audition_region = r;
- post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
- schedule_butler_transport_work ();
+ add_post_transport_work (PostTransportAudition);
+ _butler->schedule_transport_work ();
}
void
Session::bundle_by_name (string name) const
{
boost::shared_ptr<BundleList> b = _bundles.reader ();
-
+
for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
void
-Session::tempo_map_changed (Change ignored)
+Session::tempo_map_changed (Change)
{
clear_clicks ();
}
boost::shared_ptr<Region>
-Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
- bool overwrite, vector<boost::shared_ptr<Source> >& srcs,
+Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
+ bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
InterThreadInfo& itt, bool enable_processing)
{
boost::shared_ptr<Region> result;
/* construct a region to represent the bounced material */
result = RegionFactory::create (srcs, 0,
- srcs.front()->length(srcs.front()->timeline_position()),
+ srcs.front()->length(srcs.front()->timeline_position()),
region_name_from_path (srcs.front()->name(), true));
}
if (afs) {
afs->mark_for_remove ();
}
-
+
(*src)->drop_references ();
}
{
RouteGroupChanged (); /* EMIT SIGNAL */
}
+
+vector<SyncSource>
+Session::get_available_sync_options () const
+{
+ vector<SyncSource> ret;
+
+ ret.push_back (JACK);
+
+ if (mtc_port()) {
+ ret.push_back (MTC);
+ }
+
+ if (midi_clock_port()) {
+ ret.push_back (MIDIClock);
+ }
+
+ return ret;
+}
projects / ardour.git / blobdiff