#include "ardour/tape_file_matcher.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "ardour/graph.h"
#include "midi++/jack.h"
+#include "midi++/mmc.h"
#include "i18n.h"
: _engine (eng),
_target_transport_speed (0.0),
_requested_return_frame (-1),
- mmc (0),
- _mmc_port (default_mmc_port),
+ _mmc (0),
_mtc_port (default_mtc_port),
_midi_port (default_midi_port),
_midi_clock_port (default_midi_clock_port),
_butler (new Butler (*this)),
_post_transport_work (0),
_send_timecode_update (false),
+ route_graph (new Graph(*this)),
routes (new RouteList),
_total_free_4k_blocks (0),
_bundles (new BundleList),
_is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
if (_is_new) {
- if (create (mix_template, compute_initial_length(), bus_profile)) {
+ if (create (mix_template, bus_profile)) {
destroy ();
throw failed_constructor ();
}
Crossfade::set_buffer_size (0);
- delete mmc;
+ delete _mmc;
/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
playlists.reset ();
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, true));
- c->add_channel (_("mono"));
+ c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
add_bundle (c);
char buf[32];
snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
shared_ptr<Bundle> c (new Bundle (buf, true));
- c->add_channel (_("L"));
+ c->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
- c->add_channel (_("R"));
+ c->add_channel (_("R"), DataType::AUDIO);
c->set_port (1, _engine.get_nth_physical_output (DataType::AUDIO, np + 1));
add_bundle (c);
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, false));
- c->add_channel (_("mono"));
+ c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
add_bundle (c);
snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
shared_ptr<Bundle> c (new Bundle (buf, false));
- c->add_channel (_("L"));
+ c->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
- c->add_channel (_("R"));
+ c->add_channel (_("R"), DataType::AUDIO);
c->set_port (1, _engine.get_nth_physical_input (DataType::AUDIO, np + 1));
add_bundle (c);
void
Session::playlist_length_changed ()
{
- /* we can't just increase session_range_location->end() if pl->get_maximum_extent()
- if larger. if the playlist used to be the longest playlist,
- and its now shorter, we have to decrease session_range_location->end(). hence,
- we have to iterate over all diskstreams and check the
- playlists currently in use.
- */
- find_current_end ();
+ update_session_range_location_marker ();
}
void
playlist->LengthChanged.connect_same_thread (*this, boost::bind (&Session::playlist_length_changed, this));
}
- /* see comment in playlist_length_changed () */
- find_current_end ();
+ update_session_range_location_marker ();
}
bool
if (g_atomic_int_get (&_record_status) != Recording) {
g_atomic_int_set (&_record_status, Recording);
_last_record_location = _transport_frame;
- deliver_mmc(MIDI::MachineControl::cmdRecordStrobe, _last_record_location);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
+ }
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
if ((!Config->get_latched_record_enable () && !play_loop) || force) {
g_atomic_int_set (&_record_status, Disabled);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
+ }
} else {
if (rs == Recording) {
g_atomic_int_set (&_record_status, Enabled);
}
}
- // FIXME: timestamp correct? [DR]
- // FIXME FIXME FIXME: rt_context? this must be called in the process thread.
- // does this /need/ to be sent in all cases?
- if (rt_context) {
- deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
- }
-
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<RouteList> rl = routes.reader ();
enable_record ();
}
} else {
- deliver_mmc (MIDI::MachineControl::cmdRecordPause, _transport_frame);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
+ }
RecordStateChanged (); /* EMIT SIGNAL */
}
return;
}
-
{
-
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> r = writer.get_copy ();
resort_routes_using (r);
/* writer goes out of scope and forces update */
}
+ //route_graph->dump(1);
+
#ifndef NDEBUG
boost::shared_ptr<RouteList> rl = routes.reader ();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
{
RouteList::iterator i, j;
- for (i = r->begin(); i != r->end(); ++i) {
- (*i)->check_physical_connections ();
- }
-
for (i = r->begin(); i != r->end(); ++i) {
(*i)->clear_fed_by ();
RouteSorter cmp;
r->sort (cmp);
- find_route_levels (r);
+ route_graph->rechain (r);
#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 level %3\n",
- (*i)->name(), (*i)->order_key ("signal"),
- (*i)->graph_level()));
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
+ (*i)->name(), (*i)->order_key ("signal")));
}
#endif
}
-void
-Session::find_route_levels (shared_ptr<RouteList> rl)
-{
- uint32_t setcnt = 0;
- uint32_t limit = rl->size();
- RouteList last_level;
- RouteList this_level;
-
- for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) {
-
- /* find routes with direct physical connections,
- or routes with no connections at all. Mark them
- with "special" level values, and push them into
- the "last_level" set.
-
- All other routes get marked with a graph level
- of -1, which indicates that it needs to be set.
-
- */
-
- if ((*r)->physically_connected()) {
- last_level.push_back (*r);
- (*r)->set_graph_level (0);
- setcnt++;
- } else if (!(*r)->output()->connected()) {
- last_level.push_back (*r);
- (*r)->set_graph_level (INT32_MAX/2);
- setcnt++;
- } else {
- (*r)->set_graph_level (-1);
- }
- }
-
- // until we've set the graph level for every route ...
-
- while (setcnt < limit) {
-
- for (RouteList::reverse_iterator r = rl->rbegin(); r != rl->rend(); ++r) {
-
- int32_t l = INT32_MAX;
- bool found = false;
-
- if ((*r)->graph_level() != -1) {
- // we already have the graph level for this route
- continue;
- }
-
- /* check if this route (r) has a direction connection to anything in
- the set of routes we processed last time. On the first pass
- through this, last_level will contain routes with either
- no connections or direct "physical" connections. If there is
- at least 1 connection, store the lowest graph level of whatever
- r is connected to.
- */
-
- for (RouteList::iterator o = last_level.begin(); o != last_level.end(); ++o) {
- bool sends_only;
- if ((*r)->direct_feeds (*o, &sends_only)) {
- if (!sends_only) {
- l = min (l, (*o)->graph_level());
- found = true;
- }
- }
- }
-
- /* if we found any connections, then mark the graph level of r, and push
- it into the "this_level" set that will become "last_level" next time
- around the while() loop.
- */
-
- if (found) {
- (*r)->set_graph_level (l + 1);
- this_level.push_back (*r);
- setcnt++;
- }
- }
-
- last_level = this_level;
- this_level.clear ();
- }
-}
-
-
/** Find the route name starting with \a base with the lowest \a id.
*
* Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
}
shared_ptr<MidiTrack> track;
-
+
try {
MidiTrack* mt = new MidiTrack (*this, track_name, Route::Flag (0), mode);
auto_connect_route (track, existing_inputs, existing_outputs);
track->non_realtime_input_change();
+
if (route_group) {
route_group->add (track);
}
? ChanCount::max(existing_inputs, existing_outputs)
: existing_outputs;
- static string empty_string;
- string& port = empty_string;
-
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
vector<string> physinputs;
vector<string> physoutputs;
if (!physinputs.empty()) {
uint32_t nphysical_in = physinputs.size();
for (uint32_t i = 0; i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
- port = empty_string;
+ string port;
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
if (!physoutputs.empty()) {
uint32_t nphysical_out = physoutputs.size();
for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
- port = empty_string;
+ string port;
if (Config->get_output_auto_connect() & AutoConnectPhysical) {
port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
/*NOTREACHED*/
}
- IO::set_name_in_state (*node_copy.children().front(), name);
+ /* set IO children to use the new name */
+ XMLNodeList const & children = node_copy.children ();
+ for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
+ if ((*i)->name() == IO::state_node_name) {
+ IO::set_name_in_state (**i, name);
+ }
+ }
Track::zero_diskstream_id_in_xml (node_copy);
try {
shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
-
+
if (route == 0) {
error << _("Session: cannot create track/bus from template description") << endmsg;
goto out;
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->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));
r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
void
Session::remove_route (shared_ptr<Route> route)
{
+ if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
+ return;
+ }
+
{
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> rs = writer.get_copy ();
_monitor_out.reset ();
}
- update_route_solo_state ();
-
/* writer goes out of scope, forces route list update */
}
- find_current_end ();
+ update_route_solo_state ();
+ update_session_range_location_marker ();
- // We need to disconnect the routes inputs and outputs
+ // We need to disconnect the route's inputs and outputs
route->input()->disconnect (0);
route->output()->disconnect (0);
update_latency_compensation (false, false);
set_dirty();
+ /* flush references out of the graph
+ */
+
+ route_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) */
}
if (route->listening()) {
+
+ if (Config->get_exclusive_solo()) {
+ /* new listen: disable all other listen */
+ 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()) {
+ continue;
+ }
+ (*i)->set_listen (false, this);
+ }
+ }
+
_listen_cnt++;
+
} else if (_listen_cnt > 0) {
+
_listen_cnt--;
}
}
+void
+Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
+{
+ boost::shared_ptr<Route> route = wpr.lock ();
+ if (!route) {
+ /* should not happen */
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ return;
+ }
+
+ bool send_changed = false;
+
+ if (route->solo_isolated()) {
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ _solo_isolated_cnt++;
+ } else if (_solo_isolated_cnt > 0) {
+ _solo_isolated_cnt--;
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ }
+
+ if (send_changed) {
+ IsolatedChanged (); /* EMIT SIGNAL */
+ }
+}
+
void
Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
{
delta = -1;
}
- if (delta == 1 && !Config->get_solo_latched()) {
+ if (delta == 1 && Config->get_exclusive_solo()) {
/* new solo: disable all other solos */
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)->feeds (route, &via_sends_only)) {
if (!via_sends_only) {
- (*i)->mod_solo_by_others_downstream (delta);
+ if (!route->soloed_by_others_upstream()) {
+ (*i)->mod_solo_by_others_downstream (delta);
+ }
in_signal_flow = true;
}
}
bool something_soloed = false;
uint32_t listeners = 0;
+ uint32_t isolated = 0;
if (!r) {
r = routes.reader();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
something_soloed = true;
- break;
}
if (!(*i)->is_hidden() && (*i)->listening()) {
(*i)->set_listen (false, this);
}
}
+
+ if ((*i)->solo_isolated()) {
+ isolated++;
+ }
}
if (something_soloed != _non_soloed_outs_muted) {
SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
}
- if (listeners) {
- _listen_cnt = listeners;
+ _listen_cnt = listeners;
+
+ if (isolated != _solo_isolated_cnt) {
+ _solo_isolated_cnt = isolated;
+ IsolatedChanged (); /* EMIT SIGNAL */
}
}
return shared_ptr<Route> ((Route*) 0);
}
+/** If either end of the session range location marker lies inside the current
+ * session extent, move it to the corresponding session extent.
+ */
void
-Session::find_current_end ()
+Session::update_session_range_location_marker ()
{
if (_state_of_the_state & Loading) {
return;
}
- nframes_t max = get_maximum_extent ();
+ pair<nframes_t, nframes_t> const ext = get_extent ();
- if (max > _session_range_location->end()) {
- _session_range_location->set_end (max);
- set_dirty();
- DurationChanged(); /* EMIT SIGNAL */
+ if (_session_range_location == 0) {
+ /* we don't have a session range yet; use this one (provided it is valid) */
+ if (ext.first != max_frames) {
+ add_session_range_location (ext.first, ext.second);
+ }
+ } else {
+ /* update the existing session range */
+ if (ext.first < _session_range_location->start()) {
+ _session_range_location->set_start (ext.first);
+ set_dirty ();
+ }
+
+ if (ext.second > _session_range_location->end()) {
+ _session_range_location->set_end (ext.second);
+ set_dirty ();
+ }
+
}
}
-nframes_t
-Session::get_maximum_extent () const
+/** @return Extent of the session's contents; if the session is empty, the first value of
+ * the pair will equal max_frames.
+ */
+pair<nframes_t, nframes_t>
+Session::get_extent () const
{
- nframes_t max = 0;
- nframes_t me;
+ pair<nframes_t, nframes_t> ext (max_frames, 0);
boost::shared_ptr<RouteList> rl = routes.reader ();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (!tr || tr->destructive()) {
- //ignore tape tracks when getting max extents
+ // ignore tape tracks when getting extents
continue;
}
-
- boost::shared_ptr<Playlist> pl = tr->playlist();
- if ((me = pl->get_maximum_extent()) > max) {
- max = me;
+
+ pair<nframes_t, nframes_t> e = tr->playlist()->get_extent ();
+ if (e.first < ext.first) {
+ ext.first = e.first;
+ }
+ if (e.second > ext.second) {
+ ext.second = e.second;
}
}
- return max;
+ return ext;
}
/* Region management */
}
int
-Session::destroy_region (boost::shared_ptr<Region> region)
+Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
{
- vector<boost::shared_ptr<Source> > srcs;
-
- {
- if (region->playlist()) {
- region->playlist()->destroy_region (region);
- }
+ set<boost::shared_ptr<Region> > relevant_regions;
- for (uint32_t n = 0; n < region->n_channels(); ++n) {
- srcs.push_back (region->source (n));
- }
+ for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
+ RegionFactory::get_regions_using_source (*s, relevant_regions);
}
- region->drop_references ();
+ cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
+
+ for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
+ set<boost::shared_ptr<Region> >::iterator tmp;
+
+ tmp = r;
+ ++tmp;
+
+ cerr << "Cleanup " << (*r)->name() << " UC = " << (*r).use_count() << endl;
+
+ playlists->destroy_region (*r);
+ RegionFactory::map_remove (*r);
- for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
+ (*r)->drop_sources ();
+ (*r)->drop_references ();
- (*i)->mark_for_remove ();
- (*i)->drop_references ();
+ cerr << "\tdone UC = " << (*r).use_count() << endl;
+
+ relevant_regions.erase (r);
+
+ r = tmp;
+ }
+
+ for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
- cerr << "source was not used by any playlist\n";
- }
+ {
+ Glib::Mutex::Lock ls (source_lock);
+ /* remove from the main source list */
+ sources.erase ((*s)->id());
+ }
- return 0;
-}
+ (*s)->mark_for_remove ();
+ (*s)->drop_references ();
+
+ s = srcs.erase (s);
+ }
-int
-Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
-{
- for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
- destroy_region (*i);
- }
return 0;
}
int
Session::remove_last_capture ()
{
- list<boost::shared_ptr<Region> > r;
+ list<boost::shared_ptr<Source> > srcs;
boost::shared_ptr<RouteList> rl = routes.reader ();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
continue;
}
- list<boost::shared_ptr<Region> >& l = tr->last_capture_regions();
+ list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
if (!l.empty()) {
- r.insert (r.end(), l.begin(), l.end());
+ srcs.insert (srcs.end(), l.begin(), l.end());
l.clear ();
}
}
- destroy_regions (r);
+ destroy_sources (srcs);
save_state (_current_snapshot_name);
}
if (result.second) {
- set_dirty();
- }
- boost::shared_ptr<AudioFileSource> afs;
+ /* yay, new source */
- if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
- if (Config->get_auto_analyse_audio()) {
- Analyser::queue_source_for_analysis (source, false);
- }
- }
+ set_dirty();
+
+ boost::shared_ptr<AudioFileSource> afs;
+
+ if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
+ if (Config->get_auto_analyse_audio()) {
+ Analyser::queue_source_for_analysis (source, false);
+ }
+ }
+ }
}
void
/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
-Session::create_midi_source_for_session (string const & n)
+Session::create_midi_source_for_session (Track* track, string const & n)
{
+ /* try to use the existing write source for the track, to keep numbering sane
+ */
+
+ if (track) {
+ /*MidiTrack* mt = dynamic_cast<Track*> (track);
+ assert (mt);
+ */
+
+ list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
+
+ if (!l.empty()) {
+ assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
+ return boost::dynamic_pointer_cast<MidiSource> (l.front());
+ }
+ }
+
const string name = new_midi_source_name (n);
const string path = new_source_path_from_name (DataType::MIDI, name);
automation_lists[al->id()] = al;
}
-nframes_t
-Session::compute_initial_length ()
-{
- return _engine.frame_rate() * 60 * 5;
-}
-
void
Session::sync_order_keys (std::string const & base)
{
return rl;
}
+
+void
+Session::goto_end ()
+{
+ if (_session_range_location) {
+ request_locate (_session_range_location->end(), false);
+ } else {
+ request_locate (0, false);
+ }
+}
+
+void
+Session::goto_start ()
+{
+ if (_session_range_location) {
+ request_locate (_session_range_location->start(), false);
+ } else {
+ request_locate (0, false);
+ }
+}
+
+void
+Session::set_session_start (nframes_t start)
+{
+ if (_session_range_location) {
+ _session_range_location->set_start (start);
+ } else {
+ add_session_range_location (start, start);
+ }
+}
+
+void
+Session::set_session_end (nframes_t end)
+{
+ if (_session_range_location) {
+ _session_range_location->set_end (end);
+ } else {
+ add_session_range_location (end, end);
+ }
+}
+
+nframes_t
+Session::current_start_frame () const
+{
+ return _session_range_location ? _session_range_location->start() : 0;
+}
+
+nframes_t
+Session::current_end_frame () const
+{
+ return _session_range_location ? _session_range_location->end() : 0;
+}
+
+void
+Session::add_session_range_location (nframes_t start, nframes_t end)
+{
+ _session_range_location = new Location (start, end, _("session"), Location::IsSessionRange);
+ _locations.add (_session_range_location);
+}
projects / ardour.git / blobdiff