#include <sigc++/bind.h>
-#include <pbd/failed_constructor.h>
-#include <pbd/stl_delete.h>
-#include <pbd/xml++.h>
-#include <pbd/stacktrace.h>
-
-#include <ardour/playlist.h>
-#include <ardour/session.h>
-#include <ardour/region.h>
-#include <ardour/region_factory.h>
-#include <ardour/playlist_factory.h>
-#include <ardour/transient_detector.h>
+#include "pbd/failed_constructor.h"
+#include "pbd/stl_delete.h"
+#include "pbd/xml++.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/playlist.h"
+#include "ardour/session.h"
+#include "ardour/region.h"
+#include "ardour/region_factory.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/transient_detector.h"
#include "i18n.h"
}
};
+struct RegionSortByLayerWithPending {
+ bool operator () (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
+
+ double p = a->layer ();
+ if (a->pending_explicit_relayer()) {
+ p += 0.5;
+ }
+
+ double q = b->layer ();
+ if (b->pending_explicit_relayer()) {
+ q += 0.5;
+ }
+
+ return p < q;
+ }
+};
+
struct RegionSortByPosition {
bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->position() < b->position();
_frozen = false;
layer_op_counter = 0;
freeze_length = 0;
+ _explicit_relayering = false;
Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty));
}
-Playlist::Playlist (const Playlist& pl)
- : SessionObject(pl._session, pl._name)
- , _type(pl.data_type())
-{
- fatal << _("playlist const copy constructor called") << endmsg;
-}
-
-Playlist::Playlist (Playlist& pl)
- : SessionObject(pl._session, pl._name)
- , _type(pl.data_type())
-{
- fatal << _("playlist non-const copy constructor called") << endmsg;
-}
-
Playlist::~Playlist ()
{
{
pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
pending_modified = false;
+ RegionRemoved (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
Modified (); /* EMIT SIGNAL */
}
}
void
Playlist::notify_region_moved (boost::shared_ptr<Region> r)
{
- Evoral::RangeMove const move (r->last_position (), r->length (), r->position ());
+ Evoral::RangeMove<nframes_t> const move (r->last_position (), r->length (), r->position ());
if (holding_state ()) {
} else {
- Evoral::RangeMoveList m;
+ list< Evoral::RangeMove<nframes_t> > m;
m.push_back (move);
RangesMoved (m);
-
}
}
pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
pending_modified = false;
+ RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
Modified (); /* EMIT SIGNAL */
}
}
// pending_bounds.sort (cmp);
for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
- if (Config->get_layer_model() == MoveAddHigher) {
+ if (_session.config.get_layer_model() == MoveAddHigher) {
timestamp_layer_op (*r);
}
+
pending_length = true;
dependent_checks_needed.insert (*r);
- n++;
- }
- for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
- dependent_checks_needed.insert (*s);
n++;
}
for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
remove_dependents (*s);
+ RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ n++;
+ }
+
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ dependent_checks_needed.insert (*s);
n++;
}
}
pending_modified = false;
Modified (); /* EMIT SIGNAL */
-
}
for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
*************************************************************/
void
-Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times, bool auto_partition)
{
RegionLock rlock (this);
times = fabs (times);
int itimes = (int) floor (times);
nframes_t pos = position;
+
+ if(times == 1 && auto_partition){
+ partition(pos, (nframes_t) (pos + region->length()), true);
+ }
if (itimes >= 1) {
add_region_internal (region, pos);
add_region_internal (sub, pos);
}
-
possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
}
bool
Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position)
{
- if (region->data_type() != _type)
+ if (region->data_type() != _type){
return false;
+ }
RegionSortByPosition cmp;
+
nframes_t old_length = 0;
if (!holding_state()) {
notify_region_added (region);
if (!holding_state ()) {
+
check_dependents (region, false);
+
if (old_length != _get_maximum_extent()) {
notify_length_changed ();
}
}
void
-Playlist::partition (nframes_t start, nframes_t end, bool just_top_level)
+Playlist::partition (nframes_t start, nframes_t end, bool cut)
{
RegionList thawlist;
- partition_internal (start, end, false, thawlist);
+ partition_internal (start, end, cut, thawlist);
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("separation");
{
RegionLock rlock (this);
+
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> current;
string new_name;
RegionList copy = regions;
for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
-
+
tmp = i;
++tmp;
current = *i;
if (current->first_frame() >= start && current->last_frame() < end) {
+
if (cutting) {
remove_region_internal (current);
}
+
continue;
}
pos4 = current->last_frame();
if (overlap == OverlapInternal) {
-
/* split: we need 3 new regions, the front, middle and end.
cut: we need 2 regions, the front and end.
*/
*/
if (!cutting) {
-
/* "middle" ++++++ */
_session.region_name (new_name, current->name(), false);
_session.region_name (new_name, current->name(), false);
region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name,
regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-
+
add_region_internal (region, end);
new_regions.push_back (region);
current->freeze ();
thawlist.push_back (current);
current->trim_end (pos2, this);
-
+
} else if (overlap == OverlapEnd) {
-
+
/*
start end
---------------*************************------------
*/
if (!cutting) {
-
+
/* end +++++ */
_session.region_name (new_name, current->name(), false);
region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
+
add_region_internal (region, start);
new_regions.push_back (region);
}
current->freeze ();
thawlist.push_back (current);
current->trim_end (pos2, this);
-
+
} else if (overlap == OverlapStart) {
-
+
/* split: we need 2 regions: the front and the end.
cut: just trim current to skip the cut area
*/
*/
if (!cutting) {
-
/* front **** */
_session.region_name (new_name, current->name(), false);
region = RegionFactory::create (current, 0, pos3 - pos1, new_name,
regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
+
add_region_internal (region, pos1);
new_regions.push_back (region);
}
current->freeze ();
thawlist.push_back (current);
current->trim_front (pos3, this);
-
} else if (overlap == OverlapExternal) {
-
+
/* split: no split required.
cut: remove the region.
*/
if (cutting) {
remove_region_internal (current);
}
+
new_regions.push_back (current);
}
}
-
+
in_partition = false;
}
if (holding_state ()) {
pending_bounds.push_back (region);
} else {
- if (Config->get_layer_model() == MoveAddHigher) {
+ if (_session.config.get_layer_model() == MoveAddHigher) {
/* it moved or changed length, so change the timestamp */
timestamp_layer_op (region);
}
std::list<sigc::connection>::iterator i = region_state_changed_connections.begin ();
i != region_state_changed_connections.end ();
++i
- ) {
-
- i->disconnect ();
-
+ ) {
+ i->disconnect ();
}
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
pending_removes.insert (*i);
}
+
regions.clear ();
}
delete rlist;
return region;
-}
+}
+
+boost::shared_ptr<Region>
+Playlist::top_unmuted_region_at (nframes_t frame)
+
+{
+ RegionLock rlock (this);
+ RegionList *rlist = find_regions_at (frame);
+
+ for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
+
+ RegionList::iterator tmp = i;
+ ++tmp;
+
+ if ((*i)->muted()) {
+ rlist->erase (i);
+ }
+
+ i = tmp;
+ }
+
+ boost::shared_ptr<Region> region;
+
+ if (rlist->size()) {
+ RegionSortByLayer cmp;
+ rlist->sort (cmp);
+ region = rlist->back();
+ }
+
+ delete rlist;
+ return region;
+}
Playlist::RegionList*
Playlist::regions_to_read (nframes_t start, nframes_t end)
boost::shared_ptr<Region> ret;
nframes_t closest = max_frames;
+ bool end_iter = false;
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if(end_iter) break;
+
nframes_t distance;
boost::shared_ptr<Region> r = (*i);
nframes_t pos = 0;
pos = r->last_frame ();
break;
case SyncPoint:
- pos = r->adjust_to_sync (r->first_frame());
+ pos = r->sync_position ();
+ // r->adjust_to_sync (r->first_frame());
break;
}
switch (dir) {
case 1: /* forwards */
- if (pos >= frame) {
+ if (pos > frame) {
if ((distance = pos - frame) < closest) {
closest = distance;
ret = r;
+ end_iter = true;
}
}
break;
default: /* backwards */
-
- if (pos <= frame) {
+
+ if (pos < frame) {
if ((distance = frame - pos) < closest) {
closest = distance;
ret = r;
}
}
+ else {
+ end_iter = true;
+ }
+
break;
}
}
+
void
Playlist::mark_session_dirty ()
{
XMLNode&
Playlist::get_state()
{
- return state(true);
+ return state (true);
}
XMLNode&
Playlist::get_template()
{
- return state(false);
+ return state (false);
}
+/** @param full_state true to include regions in the returned state, otherwise false.
+ */
XMLNode&
Playlist::state (bool full_state)
{
/* don't send multiple Modified notifications
when multiple regions are relayered.
*/
-
+
freeze ();
- /* build up a new list of regions on each layer */
+ /* Build up a new list of regions on each layer, stored in a set of lists
+ each of which represent some period of time on some layer. The idea
+ is to avoid having to search the entire region list to establish whether
+ each region overlaps another */
- std::vector<RegionList> layers;
+ /* how many pieces to divide this playlist's time up into */
+ int const divisions = 512;
+
+ /* find the start and end positions of the regions on this playlist */
+ nframes_t start = UINT_MAX;
+ nframes_t end = 0;
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ start = min (start, (*i)->position());
+ end = max (end, (*i)->position() + (*i)->length());
+ }
+
+ /* hence the size of each time division */
+ double const division_size = (end - start) / double (divisions);
+
+ vector<vector<RegionList> > layers;
+ layers.push_back (vector<RegionList> (divisions));
/* we want to go through regions from desired lowest to desired highest layer,
which depends on the layer model
RegionList copy = regions;
- /* sort according to the model */
+ /* sort according to the model and the layering mode that we're in */
+
+ if (_explicit_relayering) {
+
+ copy.sort (RegionSortByLayerWithPending ());
+
+ } else if (_session.config.get_layer_model() == MoveAddHigher || _session.config.get_layer_model() == AddHigher) {
- if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
- RegionSortByLastLayerOp cmp;
- copy.sort (cmp);
+ copy.sort (RegionSortByLastLayerOp ());
+
}
-
+
for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+ /* reset the pending explicit relayer flag for every region, now that we're relayering */
+ (*i)->set_pending_explicit_relayer (false);
+
+ /* find the time divisions that this region covers */
+ int const start_division = floor ( ((*i)->position() - start) / division_size);
+ int end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size );
+ if (end_division == divisions) {
+ end_division--;
+ }
+
+ assert (end_division < divisions);
+
/* find the lowest layer that this region can go on */
size_t j = layers.size();
while (j > 0) {
/* try layer j - 1; it can go on if it overlaps no other region
that is already on that layer
*/
- RegionList::iterator k = layers[j - 1].begin();
- while (k != layers[j - 1].end()) {
- if ((*k)->overlap_equivalent (*i)) {
+
+ bool overlap = false;
+ for (int k = start_division; k <= end_division; ++k) {
+ RegionList::iterator l = layers[j-1][k].begin ();
+ while (l != layers[j-1][k].end()) {
+ if ((*l)->overlap_equivalent (*i)) {
+ overlap = true;
+ break;
+ }
+ l++;
+ }
+
+ if (overlap) {
break;
}
- k++;
}
- if (k != layers[j - 1].end()) {
- /* no overlap, so we can use this layer */
+ if (overlap) {
+ /* overlap, so we must use layer j */
break;
}
-
- j--;
+
+ --j;
}
if (j == layers.size()) {
/* we need a new layer for this region */
- layers.push_back (RegionList ());
+ layers.push_back (vector<RegionList> (divisions));
}
- layers[j].push_back (*i);
- }
-
- /* first pass: set up the layer numbers in the regions */
- for (size_t j = 0; j < layers.size(); ++j) {
- for (RegionList::iterator i = layers[j].begin(); i != layers[j].end(); ++i) {
- (*i)->set_layer (j);
+ /* put a reference to this region in each of the divisions that it exists in */
+ for (int k = start_division; k <= end_division; ++k) {
+ layers[j][k].push_back (*i);
}
+
+ (*i)->set_layer (j);
}
/* sending Modified means that various kinds of layering
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((Config->get_layer_model() == MoveAddHigher) ||
- (Config->get_layer_model() == AddHigher)) {
+ if ((_session.config.get_layer_model() == MoveAddHigher) ||
+ (_session.config.get_layer_model() == AddHigher)) {
timestamp_layer_op (region);
relayer ();
}
Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((Config->get_layer_model() == MoveAddHigher) ||
- (Config->get_layer_model() == AddHigher)) {
+ if ((_session.config.get_layer_model() == MoveAddHigher) ||
+ (_session.config.get_layer_model() == AddHigher)) {
region->set_last_layer_op (0);
relayer ();
}
thaw ();
}
+
+void
+Playlist::foreach_region (sigc::slot<void, boost::shared_ptr<Region> > s)
+{
+ RegionLock rl (this, false);
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ s (*i);
+ }
+}
+
+void
+Playlist::set_explicit_relayering (bool e)
+{
+ if (e == false && _explicit_relayering == true) {
+
+ /* We are changing from explicit to implicit relayering; layering may have been changed whilst
+ we were in explicit mode, and we don't want that to be undone next time an implicit relayer
+ occurs. Hence now we'll set up region last_layer_op values so that an implicit relayer
+ at this point would keep regions on the same layers.
+
+ From then on in, it's just you and your towel.
+ */
+
+ RegionLock rl (this);
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ (*i)->set_last_layer_op ((*i)->layer ());
+ }
+ }
+
+ _explicit_relayering = e;
+}