#include <unistd.h>
#include <limits.h>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
#include "pbd/file_utils.h"
#include "pbd/convert.h"
#include "pbd/strsplit.h"
-#include "pbd/strsplit.h"
#include "pbd/unwind.h"
#include "ardour/amp.h"
#include "ardour/graph.h"
#include "ardour/midi_track.h"
#include "ardour/midi_ui.h"
-#include "ardour/named_selection.h"
#include "ardour/operations.h"
#include "ardour/playlist.h"
#include "ardour/plugin.h"
PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
-PBD::Signal0<void> Session::AutoBindingOn;
-PBD::Signal0<void> Session::AutoBindingOff;
PBD::Signal2<void,std::string, std::string> Session::Exported;
PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
PBD::Signal0<void> Session::Quit;
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
-/** @param snapshot_name Snapshot name, without .ardour prefix */
+/** @param snapshot_name Snapshot name, without .ardour suffix */
Session::Session (AudioEngine &eng,
const string& fullpath,
const string& snapshot_name,
, _all_route_group (new RouteGroup (*this, "all"))
, routes (new RouteList)
, _total_free_4k_blocks (0)
+ , _total_free_4k_blocks_uncertain (false)
, _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);
+#ifdef HAVE_LTC
+ ltc_encoder = NULL;
+#endif
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
_engine.remove_session ();
+ /* deregister all ports - there will be no process or any other
+ * callbacks from the engine any more.
+ */
+
+ Port::PortDrop (); /* EMIT SIGNAL */
+
+#ifdef HAVE_LTC
+ ltc_tx_cleanup();
+#endif
+
/* clear history so that no references to objects are held any more */
_history.clear ();
_butler->drop_references ();
delete _butler;
+ _butler = 0;
+
delete midi_control_ui;
delete _all_route_group;
/* tell everyone to drop references and delete objects as we go */
- DEBUG_TRACE (DEBUG::Destruction, "delete named selections\n");
- named_selections.clear ();
-
DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
RegionFactory::delete_all_regions ();
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 ();
+ }
+
_click_io.reset (new ClickIO (*this, "click"));
_click_gain.reset (new Amp (*this));
_click_gain->activate ();
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
replace_event (SessionEvent::PunchOut, when_to_stop);
}
+/** @param loc A loop location.
+ * @param pos Filled in with the start time of the required fade-out (in session frames).
+ * @param length Filled in with the length of the required fade-out.
+ */
+void
+Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
+{
+ pos = max (loc->start(), loc->end() - 64);
+ length = loc->end() - pos;
+}
+
void
Session::auto_loop_changed (Location* location)
{
replace_event (SessionEvent::AutoLoop, location->end(), location->start());
+ framepos_t dcp;
+ framecnt_t dcl;
+ auto_loop_declick_range (location, dcp, dcl);
+ replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
if (transport_rolling() && play_loop) {
loop_connections.drop_connections ();
existing->set_auto_loop (false, this);
remove_event (existing->end(), SessionEvent::AutoLoop);
+ framepos_t dcp;
+ framecnt_t dcl;
+ auto_loop_declick_range (existing, dcp, dcl);
+ remove_event (dcp, SessionEvent::AutoLoopDeclick);
auto_loop_location_changed (0);
}
of audible frames, we have not moved yet.
`Start position' in this context means the time we last
- either started or changed transport direction.
+ either started, located, or changed transport direction.
*/
if (_transport_speed > 0.0f) {
trace_terminal (*i, *i);
}
- r = sorted_routes;
+ *r = *sorted_routes;
#ifndef NDEBUG
DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
- (*i)->name(), (*i)->order_key ("signal")));
+ (*i)->name(), (*i)->order_key (MixerSort)));
}
#endif
* @param instrument plugin info for the instrument to insert pre-fader, if any
*/
list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (boost::shared_ptr<PluginInfo> instrument, TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
+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)
{
char track_name[32];
uint32_t track_id = 0;
string port;
RouteList new_routes;
list<boost::shared_ptr<MidiTrack> > ret;
- uint32_t control_id;
- control_id = next_control_id ();
+ cerr << "Adding MIDI track with in = " << input << " out = " << output << endl;
bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
// boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
#endif
{
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
- error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
+ 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;
}
- if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
- error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
+ if (track->output()->ensure_io (output, false, this)) {
+ error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
goto failed;
}
}
}
track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
- track->set_remote_control_id (control_id);
+
+ if (Config->get_remote_model() == UserOrdered) {
+ track->set_remote_control_id (next_control_id());
+ }
new_routes.push_back (track);
ret.push_back (track);
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 ();
string port;
RouteList new_routes;
list<boost::shared_ptr<AudioTrack> > ret;
- uint32_t control_id;
-
- control_id = next_control_id ();
bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
// 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 (
track->non_realtime_input_change();
track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
- track->set_remote_control_id (control_id);
- ++control_id;
+ if (Config->get_remote_model() == UserOrdered) {
+ track->set_remote_control_id (next_control_id());
+ }
new_routes.push_back (track);
ret.push_back (track);
return ret;
}
-void
-Session::set_remote_control_ids ()
-{
- RemoteModel m = Config->get_remote_model();
- bool emit_signal = false;
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (MixerOrdered == m) {
- int32_t order = (*i)->order_key(N_("signal"));
- (*i)->set_remote_control_id (order+1, false);
- emit_signal = true;
- } else if (EditorOrdered == m) {
- int32_t order = (*i)->order_key(N_("editor"));
- (*i)->set_remote_control_id (order+1, false);
- emit_signal = true;
- } else if (UserOrdered == m) {
- //do nothing ... only changes to remote id's are initiated by user
- }
- }
-
- if (emit_signal) {
- Route::RemoteControlIDChange();
- }
-}
-
/** Caller must not hold process lock.
* @param name_template string to use for the start of the name, or "" to use "Bus".
*/
uint32_t bus_id = 0;
string port;
RouteList ret;
- uint32_t control_id;
-
- control_id = next_control_id ();
bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
// 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"),
if (route_group) {
route_group->add (bus);
}
- bus->set_remote_control_id (control_id);
- ++control_id;
+ if (Config->get_remote_model() == UserOrdered) {
+ bus->set_remote_control_id (next_control_id());
+ }
bus->add_internal_return ();
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();
{
ChanCount existing_inputs;
ChanCount existing_outputs;
+ uint32_t order = next_control_id();
count_existing_track_channels (existing_inputs, existing_outputs);
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));
r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
- r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
if (r->is_master()) {
_master_out = r;
if (input_auto_connect || output_auto_connect) {
auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
}
+
+ /* order keys are a GUI responsibility but we need to set up
+ reasonable defaults because they also affect the remote control
+ ID in most situations.
+ */
+
+ if (!r->has_order_key (EditorSort)) {
+ if (r->is_hidden()) {
+ /* use an arbitrarily high value */
+ r->set_order_key (EditorSort, UINT_MAX);
+ r->set_order_key (MixerSort, UINT_MAX);
+ } else {
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
+ r->set_order_key (EditorSort, order);
+ r->set_order_key (MixerSort, order);
+ order++;
+ }
+ }
}
if (_monitor_out && IO::connecting_legal) {
{
- Glib::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()) {
}
RouteAdded (new_routes); /* EMIT SIGNAL */
- Route::RemoteControlIDChange (); /* EMIT SIGNAL */
}
void
route->drop_references ();
- sync_order_keys (N_("session"));
-
Route::RemoteControlIDChange(); /* EMIT SIGNAL */
/* save the new state of the world */
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);
}
/* 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;
}
{
- 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
SessionDirectory sdir(get_best_session_directory_for_new_source());
- sys::path p;
+ std::string p;
if (type == DataType::AUDIO) {
p = sdir.sound_path();
} else if (type == DataType::MIDI) {
return "";
}
- p /= name;
- return p.to_string();
+ return Glib::build_filename (p, name);
}
string
Session::peak_path (string base) const
{
- sys::path peakfile_path(_session_dir->peak_path());
- peakfile_path /= base + peakfile_suffix;
- return peakfile_path.to_string();
+ return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
}
/** Return a unique name based on \a base for a new internal audio source */
SessionDirectory sdir((*i).path);
- string spath = sdir.sound_path().to_string();
+ string spath = sdir.sound_path();
/* note that we search *without* the extension so that
we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
SessionDirectory sdir((*i).path);
- sys::path p = sdir.midi_path();
- p /= legalized;
+ std::string p = Glib::build_filename (sdir.midi_path(), legalized);
- snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
- if (sys::exists (buf)) {
+ if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
existing++;
}
}
if (b->is_monitor()) {
return false;
}
- return a->order_key(N_("signal")) < b->order_key(N_("signal"));
+ return a->order_key (MixerSort) < b->order_key (MixerSort);
}
bool
}
}
-framecnt_t
+/** @return Number of frames that there is disk space available to write,
+ * if known.
+ */
+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> ();
+ }
+
float sample_bytes_on_disk = 4.0; // keep gcc happy
switch (config.get_native_file_data_format()) {
}
}
-
-/* Named Selection management */
-
-boost::shared_ptr<NamedSelection>
-Session::named_selection_by_name (string name)
-{
- Glib::Mutex::Lock lm (named_selection_lock);
- for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
- if ((*i)->name == name) {
- return *i;
- }
- }
- return boost::shared_ptr<NamedSelection>();
-}
-
-void
-Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
-{
- {
- Glib::Mutex::Lock lm (named_selection_lock);
- named_selections.insert (named_selections.begin(), named_selection);
- }
-
- set_dirty();
-
- NamedSelectionAdded (); /* EMIT SIGNAL */
-}
-
-void
-Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
-{
- bool removed = false;
-
- {
- Glib::Mutex::Lock lm (named_selection_lock);
-
- NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
-
- if (i != named_selections.end()) {
- named_selections.erase (i);
- set_dirty();
- removed = true;
- }
- }
-
- if (removed) {
- NamedSelectionRemoved (); /* EMIT SIGNAL */
- }
-}
-
void
Session::reset_native_file_format ()
{
framepos_t to_do;
BufferSet buffers;
SessionDirectory sdir(get_best_session_directory_for_new_source ());
- const string sound_dir = sdir.sound_path().to_string();
+ const string sound_dir = sdir.sound_path();
framepos_t len = end - start;
bool need_block_size_reset = false;
string ext;
return ProcessThread::gain_automation_buffer ();
}
+gain_t*
+Session::send_gain_automation_buffer() const
+{
+ return ProcessThread::send_gain_automation_buffer ();
+}
+
pan_t**
Session::pan_automation_buffer() const
{
automation_lists[al->id()] = al;
}
-void
-Session::sync_order_keys (std::string const & base)
-{
- if (deletion_in_progress()) {
- return;
- }
-
- if (!Config->get_sync_all_route_ordering()) {
- /* leave order keys as they are */
- return;
- }
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->sync_order_keys (base);
- }
-
- Route::SyncOrderKeys (base); // EMIT SIGNAL
-
- /* this might not do anything */
-
- set_remote_control_ids ();
-}
-
/** @return true if there is at least one record-enabled track, otherwise false */
bool
Session::have_rec_enabled_track () const
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
{
_locations->add (_session_range_location);
}
-/** Called when one of our routes' order keys has changed */
-void
-Session::route_order_key_changed ()
-{
- RouteOrderKeyChanged (); /* EMIT SIGNAL */
-}
-
void
Session::step_edit_status_change (bool yn)
{
if (session_dirs.size() == 1) {
switch (type) {
case DataType::AUDIO:
- s.push_back ( _session_dir->sound_path().to_string());
+ s.push_back ( _session_dir->sound_path());
break;
case DataType::MIDI:
- s.push_back (_session_dir->midi_path().to_string());
+ s.push_back (_session_dir->midi_path());
break;
}
} else {
SessionDirectory sdir (i->path);
switch (type) {
case DataType::AUDIO:
- s.push_back (sdir.sound_path().to_string());
+ s.push_back (sdir.sound_path());
break;
case DataType::MIDI:
- s.push_back (sdir.midi_path().to_string());
+ s.push_back (sdir.midi_path());
break;
}
}
}
+ 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)) {
+ s.push_back (sound_path_2X);
+ }
+ }
+
/* now check the explicit (possibly user-specified) search path
*/
search_path = config.get_midi_search_path ();
break;
}
-
+
split (search_path, dirs, ':');
for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
On Windows, I think we could just do if (*i == path) here.
*/
- if (inodes_same (*i, path)) {
+ if (PBD::equivalent_paths (*i, path)) {
return;
}
}
Session::initialize_latencies ()
{
{
- Glib::Mutex::Lock lm (_engine.process_lock());
+ Glib::Threads::Mutex::Lock lm (_engine.process_lock());
update_latency (false);
update_latency (true);
}
uint32_t
Session::next_control_id () const
{
- return ntracks() + nbusses() + 1;
+ int subtract = 0;
+
+ /* the monitor bus remote ID is in a different
+ * "namespace" than regular routes. its existence doesn't
+ * affect normal (low) numbered routes.
+ */
+
+ if (_monitor_out) {
+ subtract++;
+ }
+
+ return nroutes() - subtract;
+}
+
+void
+Session::notify_remote_id_change ()
+{
+ if (deletion_in_progress()) {
+ return;
+ }
+
+ switch (Config->get_remote_model()) {
+ case MixerSort:
+ case EditorSort:
+ Route::RemoteControlIDChange (); /* EMIT SIGNAL */
+ break;
+ 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
+Session::operation_in_progress (GQuark op) const
+{
+ 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