#include "ardour/tape_file_matcher.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "ardour/graph.h"
#include "midi++/jack.h"
_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 ();
}
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
/* 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.
/*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;
}
update_route_solo_state ();
- find_current_end ();
+ update_session_range_location_marker ();
// We need to disconnect the route's inputs and outputs
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 */
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