#include <unistd.h>
#include <limits.h>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
PBD::Signal0<void> Session::Quit;
PBD::Signal0<void> Session::FeedbackDetected;
PBD::Signal0<void> Session::SuccessfulGraphSort;
+PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
: _engine (eng)
, _target_transport_speed (0.0)
, _requested_return_frame (-1)
+ , _under_nsm_control (false)
, _session_dir (new SessionDirectory(fullpath))
, state_tree (0)
, _state_of_the_state (Clean)
, _butler (new Butler (*this))
, _post_transport_work (0)
, _send_timecode_update (false)
+ , ltc_enc_buf(0)
, _all_route_group (new RouteGroup (*this, "all"))
, routes (new RouteList)
, _total_free_4k_blocks (0)
, _bundles (new BundleList)
, _bundle_xml_node (0)
, _current_trans (0)
- , _click_io ((IO*) 0)
, click_data (0)
, click_emphasis_data (0)
, main_outs (0)
, _suspend_timecode_transmission (0)
{
_locations = new Locations (*this);
+ ltc_encoder = NULL;
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
_state_of_the_state = StateOfTheState (CannotSave|Deletion);
+ /* disconnect from any and all signals that we are connected to */
+
+ drop_connections ();
+
_engine.remove_session ();
/* deregister all ports - there will be no process or any other
Port::PortDrop (); /* EMIT SIGNAL */
+ ltc_tx_cleanup();
+
/* clear history so that no references to objects are held any more */
_history.clear ();
try {
XMLNode* child = 0;
+
+ _ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
+ _ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
+
+ if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
+ _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
+ } else {
+ {
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
+ }
+ reconnect_ltc_input ();
+ }
+
+ if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
+ _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
+ } else {
+ {
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
+ }
+ 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 (_("LTC-in"));
+ _ltc_output->nth (0)->set_name (_("LTC-out"));
_click_io.reset (new ClickIO (*this, "click"));
_click_gain.reset (new Amp (*this));
ControlProtocolManager::instance().midi_connectivity_established ();
if (_is_new && !no_auto_connect()) {
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
auto_connect_master_bus ();
}
BootMessage (_("Connect to engine"));
_engine.set_session (this);
+ _engine.reset_timebase ();
}
void
* pieces of audio as we work on each route.
*/
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ 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
// boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
{
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
}
boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
if (b) {
- _monitor_out->output()->connect_ports_to_bundle (b, this);
+ _monitor_out->output()->connect_ports_to_bundle (b, true, this);
} else {
warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
Config->get_monitor_bus_preferred_bundle())
* pieces of audio as we work on each route.
*/
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ 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
}
if (location->end() <= location->start()) {
- error << _("Session: you can't use a mark for auto loop") << endmsg;
+ error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
return;
}
sync_time_vars();
- Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
-
clear_clicks ();
// XXX we need some equivalent to this, somehow
}
++id;
-
+
} while (id < (UINT_MAX-1));
return false;
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && !tr->is_hidden()) {
+ if (tr && !tr->is_auditioner()) {
in += tr->n_inputs();
out += tr->n_outputs();
}
RouteList new_routes;
list<boost::shared_ptr<MidiTrack> > ret;
- cerr << "Adding MIDI track with in = " << input << " out = " << output << endl;
-
bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
while (how_many) {
// boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
#endif
{
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ 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;
goto failed;
catch (AudioEngine::PortRegistrationFailure& pfe) {
- error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
+ error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
goto failed;
}
return;
}
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
if (with_lock) {
lm.acquire ();
// boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
#endif
{
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
error << string_compose (
// boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
#endif
{
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
bus->add_internal_return ();
ret.push_back (bus);
+
+ ARDOUR::GUIIdle ();
}
}
RouteList
-Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
+Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
{
RouteList ret;
uint32_t control_id;
XMLTree tree;
uint32_t number = 0;
+ const uint32_t being_added = how_many;
if (!tree.read (template_path.c_str())) {
return ret;
node_copy.remove_property_recursively (X_("id"));
try {
- 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 */
char name[32];
- if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
- fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
- /*NOTREACHED*/
+
+ if (!name_base.empty()) {
+
+ /* if we're adding more than one routes, force
+ * all the names of the new routes to be
+ * numbered, via the final parameter.
+ */
+
+ if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
+ fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
+ /*NOTREACHDE*/
+ }
+
+ } 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, sizeof(name), true)) {
+ fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
+ /*NOTREACHED*/
+ }
}
/* set this name in the XML description that we are about to use */
loading this normally happens in a different way.
*/
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
change.after = route->input()->n_ports();
void
Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
+{
+ try {
+ PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
+ add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
+
+ } catch (...) {
+ error << _("Adding new tracks/busses failed") << endmsg;
+ }
+
+ graph_reordered ();
+
+ update_latency (true);
+ update_latency (false);
+
+ set_dirty();
+
+ if (save) {
+ save_state (_current_snapshot_name);
+ }
+
+ RouteAdded (new_routes); /* EMIT SIGNAL */
+}
+
+void
+Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
{
ChanCount existing_inputs;
ChanCount existing_outputs;
}
}
+
if (input_auto_connect || output_auto_connect) {
auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
}
reasonable defaults because they also affect the remote control
ID in most situations.
*/
-
+
if (!r->has_order_key (EditorSort)) {
- if (r->is_hidden()) {
+ if (r->is_auditioner()) {
/* use an arbitrarily high value */
r->set_order_key (EditorSort, UINT_MAX);
r->set_order_key (MixerSort, UINT_MAX);
order++;
}
}
+
+ ARDOUR::GUIIdle ();
}
if (_monitor_out && IO::connecting_legal) {
-
- {
- Glib::Mutex::Lock lm (_engine.process_lock());
-
- for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- if ((*x)->is_monitor()) {
- /* relax */
- } else if ((*x)->is_master()) {
+ 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 */
+ } else if ((*x)->is_master()) {
/* relax */
- } else {
- (*x)->enable_monitor_send ();
- }
+ } else {
+ (*x)->enable_monitor_send ();
}
}
-
- resort_routes ();
- }
-
- set_dirty();
-
- if (save) {
- save_state (_current_snapshot_name);
}
-
- RouteAdded (new_routes); /* EMIT SIGNAL */
- Route::RemoteControlIDChange (); /* EMIT SIGNAL */
}
void
/* new listen: disable all other listen */
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_hidden()) {
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
continue;
}
(*i)->set_listen (false, this);
/* 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_hidden() ||
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
(leave_group_alone && ((*i)->route_group() == rg))) {
continue;
}
bool via_sends_only;
bool in_signal_flow;
- if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
(leave_group_alone && ((*i)->route_group() == rg))) {
continue;
}
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, "\tno feed from\n");
+ 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->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 {
*/
for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
- DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name()));
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
(*i)->mute_changed (this);
}
}
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
+ if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
something_soloed = true;
}
- if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
+ if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
if (Config->get_solo_control_is_listen_control()) {
listeners++;
} else {
_solo_isolated_cnt = isolated;
IsolatedChanged (); /* EMIT SIGNAL */
}
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
+ something_soloed, listeners, isolated));
}
boost::shared_ptr<RouteList>
}
void
-Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool /*others_on*/)
+Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
{
- RouteList rl;
+ RouteList rl2;
vector<string> connections;
- PortSet& ps (rt->input()->ports());
-
- for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
- p->get_connections (connections);
- }
+ /* if we are passed only a single route and we're not told to turn
+ * others off, then just do the simple thing.
+ */
- for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
- routes_using_input_from (*s, rl);
+ if (flip_others == false && rl->size() == 1) {
+ boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
+ if (mt) {
+ mt->set_input_active (onoff);
+ return;
+ }
}
- /* scan all relevant routes to see if others are on or off */
+ for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
- bool others_are_already_on = false;
+ 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) {
- for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
- if ((*r) != rt) {
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
- if (mt) {
+
+ if (!mt) {
+ continue;
+ }
+
+ if ((*r) != (*rt)) {
if (mt->input_active()) {
others_are_already_on = true;
- break;
}
+ } else {
+ /* this one needs changing */
+ mt->set_input_active (onoff);
}
}
- }
-
- /* globally reverse other routes */
+
+ if (flip_others) {
- for (RouteList::iterator r = rl.begin(); r != rl.end(); ++r) {
- if ((*r) != rt) {
- boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
- if (mt) {
- mt->set_input_active (!others_are_already_on);
+ /* 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);
+ if (mt) {
+ mt->set_input_active (!others_are_already_on);
+ }
+ }
}
}
}
void
Session::routes_using_input_from (const string& str, RouteList& rl)
{
- boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> r = routes.reader();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if ((*i)->input()->connected_to (str)) {
RegionFactory::RegionMap::const_iterator i;
boost::shared_ptr<Region> region;
- Glib::Mutex::Lock lm (region_lock);
+ Glib::Threads::Mutex::Lock lm (region_lock);
for (i = regions.begin(); i != regions.end(); ++i) {
for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
{
- Glib::Mutex::Lock ls (source_lock);
+ Glib::Threads::Mutex::Lock ls (source_lock);
/* remove from the main source list */
sources.erase ((*s)->id());
}
entry.second = source;
{
- Glib::Mutex::Lock lm (source_lock);
+ Glib::Threads::Mutex::Lock lm (source_lock);
result = sources.insert (entry);
}
}
{
- Glib::Mutex::Lock lm (source_lock);
+ Glib::Threads::Mutex::Lock lm (source_lock);
if ((i = sources.find (source->id())) != sources.end()) {
sources.erase (i);
boost::shared_ptr<Source>
Session::source_by_id (const PBD::ID& id)
{
- Glib::Mutex::Lock lm (source_lock);
+ Glib::Threads::Mutex::Lock lm (source_lock);
SourceMap::iterator i;
boost::shared_ptr<Source> source;
boost::shared_ptr<Source>
Session::source_by_path_and_channel (const string& path, uint16_t chn)
{
- Glib::Mutex::Lock lm (source_lock);
+ Glib::Threads::Mutex::Lock lm (source_lock);
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
boost::shared_ptr<AudioFileSource> afs
Session::count_sources_by_origin (const string& path)
{
uint32_t cnt = 0;
- Glib::Mutex::Lock lm (source_lock);
+ Glib::Threads::Mutex::Lock lm (source_lock);
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
boost::shared_ptr<FileSource> fs
const string path = new_source_path_from_name(DataType::AUDIO, name);
return boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
}
/** Return a unique name based on \a base for a new internal MIDI source */
return boost::dynamic_pointer_cast<SMFSource> (
SourceFactory::createWritable (
- DataType::MIDI, *this, path, string(), false, frame_rate()));
+ DataType::MIDI, *this, path, false, frame_rate()));
}
from a set_state() call or creating new tracks. Ditto for deletion.
*/
- if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
return;
}
boost::optional<framecnt_t>
Session::available_capture_duration ()
{
+ Glib::Threads::Mutex::Lock lm (space_lock);
+
if (_total_free_4k_blocks_uncertain) {
return boost::optional<framecnt_t> ();
}
try {
fsource = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, buf, string(), false, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
}
catch (failed_constructor& err) {
bool
Session::have_rec_enabled_track () const
{
- return g_atomic_int_get (&_have_rec_enabled_track) == 1;
+ return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
}
/** Update the state of our rec-enabled tracks flag */
RouteRemovedFromRouteGroup (rg, r);
}
-vector<SyncSource>
-Session::get_available_sync_options () const
-{
- vector<SyncSource> ret;
-
- ret.push_back (JACK);
- ret.push_back (MTC);
- ret.push_back (MIDIClock);
-
- return ret;
-}
-
boost::shared_ptr<RouteList>
Session::get_routes_with_regions_at (framepos_t const p) const
{
if (session_dirs.size() == 1) {
switch (type) {
case DataType::AUDIO:
- s.push_back ( _session_dir->sound_path());
+ s.push_back (_session_dir->sound_path());
break;
case DataType::MIDI:
s.push_back (_session_dir->midi_path());
}
}
+ if (type == DataType::AUDIO) {
+ const string sound_path_2X = _session_dir->sound_path_2X();
+ if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
+ if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
+ s.push_back (sound_path_2X);
+ }
+ }
+ }
+
/* now check the explicit (possibly user-specified) search path
*/
}
for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
-
- vector<string>::iterator si;
-
- for (si = s.begin(); si != s.end(); ++si) {
- if ((*si) == *i) {
- break;
- }
- }
-
- if (si == s.end()) {
+ if (find (s.begin(), s.end(), *i) == s.end()) {
s.push_back (*i);
}
}
{
DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
- if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
return;
}
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden() && ((*i)->active())) {
+ if (!(*i)->is_auditioner() && ((*i)->active())) {
_worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
}
}
Session::initialize_latencies ()
{
{
- Glib::Mutex::Lock lm (_engine.process_lock());
+ Glib::Threads::Mutex::Lock lm (_engine.process_lock());
update_latency (false);
update_latency (true);
}
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden() && ((*i)->active())) {
+ if (!(*i)->is_auditioner() && ((*i)->active())) {
framecnt_t tl;
if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
some_track_latency_changed = true;
}
void
-Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
+Session::notify_remote_id_change ()
{
if (deletion_in_progress()) {
return;
default:
break;
}
+}
+
+void
+Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
+{
+ if (deletion_in_progress()) {
+ return;
+ }
/* tell everyone that something has happened to the sort keys
and let them sync up with the change(s)
+ this will give objects that manage the sort order keys the
+ opportunity to keep them in sync if they wish to.
*/
DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
+
+ DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
}
bool
{
return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
}
+
+boost::shared_ptr<Port>
+Session::ltc_input_port () const
+{
+ return _ltc_input->nth (0);
+}
+
+boost::shared_ptr<Port>
+Session::ltc_output_port () const
+{
+ return _ltc_output->nth (0);
+}
+
+void
+Session::reconnect_ltc_input ()
+{
+ if (_ltc_input) {
+
+ string src = Config->get_ltc_source_port();
+
+ _ltc_input->disconnect (this);
+
+ if (src != _("None") && !src.empty()) {
+ _ltc_input->nth (0)->connect (src);
+ }
+ }
+}
+
+void
+Session::reconnect_ltc_output ()
+{
+ if (_ltc_output) {
+
+#if 0
+ string src = Config->get_ltc_sink_port();
+
+ _ltc_output->disconnect (this);
+
+ if (src != _("None") && !src.empty()) {
+ _ltc_output->nth (0)->connect (src);
+ }
+#endif
+ }
+}
projects / ardour.git / blobdiff