#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>
}
};
+
Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
- : _session (sess)
+ : SessionObject(sess, nom)
, _type(type)
{
init (hide);
}
Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
- : _session (sess)
+ : SessionObject(sess, "unnamed playlist")
, _type(type)
{
const XMLProperty* prop = node.property("type");
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
- : _name (namestr), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
+ : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
init (hide);
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
- : _name (str), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
+ : SessionObject(other->_session, str), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
RegionLock rlock2 (const_cast<Playlist*> (other.get()));
_refcnt = 0;
_hidden = hide;
_splicing = false;
+ _shuffling = false;
_nudging = false;
in_set_state = 0;
_edit_mode = Config->get_edit_mode();
}
Playlist::Playlist (const Playlist& pl)
- : _session (pl._session)
+ : SessionObject(pl._session, pl._name)
, _type(pl.data_type())
{
fatal << _("playlist const copy constructor called") << endmsg;
}
Playlist::Playlist (Playlist& pl)
- : _session (pl._session)
+ : SessionObject(pl._session, pl._name)
, _type(pl.data_type())
{
fatal << _("playlist non-const copy constructor called") << endmsg;
/* GoingAway must be emitted by derived classes */
}
-void
-Playlist::set_name (string str)
+bool
+Playlist::set_name (const string& str)
{
/* in a typical situation, a playlist is being used
by one diskstream and also is referenced by the
*/
if (_refcnt > 2) {
- return;
+ return false;
+ } else {
+ return SessionObject::set_name(str);
}
-
- _name = str;
- NameChanged(); /* EMIT SIGNAL */
}
/***********************************************************************
/* this might not be true, but we have to act
as though it could be.
*/
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
pending_modified = true;
pending_length = true;
} else {
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
if (holding_state ()) {
pending_length = true;
} else {
+ pending_length = false;
LengthChanged(); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
if (n || pending_modified) {
if (!in_set_state) {
- possibly_splice ();
relayer ();
}
pending_modified = false;
Modified (); /* EMIT SIGNAL */
+
}
for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
{
RegionLock rlock (this);
-
+ delay_notifications();
times = fabs (times);
int itimes = (int) floor (times);
--itimes;
}
- /* later regions will all be spliced anyway */
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
-
/* note that itimes can be zero if we being asked to just
insert a single fraction of the region.
*/
pos += region->length();
}
+ nframes_t length = 0;
+
if (floor (times) != times) {
- nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
+ length = (nframes_t) floor (region->length() * (times - floor (times)));
string name;
_session.region_name (name, region->name(), false);
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
add_region_internal (sub, pos);
}
+
+
+ possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
+ release_notifications ();
}
void
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
all_regions.insert (region);
+ possibly_splice_unlocked (position, region->length(), region);
+
if (!holding_state () && !in_set_state) {
/* layers get assigned from XML state */
relayer ();
{
RegionLock rlock (this);
+ bool old_sp = _splicing;
+ _splicing = true;
+
remove_region_internal (old);
add_region_internal (newr, pos);
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
+ _splicing = old_sp;
+
+ possibly_splice_unlocked (pos, (nframes64_t) old->length() - (nframes64_t) newr->length());
}
void
{
RegionLock rlock (this);
remove_region_internal (region);
-
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
}
int
-Playlist::remove_region_internal (boost::shared_ptr<Region>region)
+Playlist::remove_region_internal (boost::shared_ptr<Region> region)
{
RegionList::iterator i;
nframes_t old_length = 0;
for (i = regions.begin(); i != regions.end(); ++i) {
if (*i == region) {
+ nframes_t pos = (*i)->position();
+ nframes64_t distance = (*i)->length();
+
regions.erase (i);
+ possibly_splice_unlocked (pos, -distance);
+
if (!holding_state ()) {
relayer ();
remove_dependents (region);
return 0;
}
}
+
+
+
return -1;
}
}
partition_internal (start, start+cnt-1, true, thawlist);
- possibly_splice ();
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("playlist cut");
pos += shift;
}
- possibly_splice_unlocked ();
/* XXX shall we handle fractional cases at some point? */
string before_name;
string after_name;
+ /* split doesn't change anything about length, so don't try to splice */
+
+ bool old_sp = _splicing;
+ _splicing = true;
+
before = playlist_position - region->position();
after = region->length() - before;
-
_session.region_name (before_name, region->name(), false);
left = RegionFactory::create (region, 0, before, before_name, region->layer(), Region::Flag (region->flags()|Region::LeftOfSplit));
add_region_internal (left, region->position());
add_region_internal (right, region->position() + before);
-
+
uint64_t orig_layer_op = region->last_layer_op();
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->last_layer_op() > orig_layer_op) {
finalize_split_region (region, left, right);
- if (remove_region_internal (region)) {
- return;
- }
+ remove_region_internal (region);
+
+ _splicing = old_sp;
}
void
-Playlist::possibly_splice ()
+Playlist::possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
+ if (_splicing || in_set_state) {
+ /* don't respond to splicing moves or state setting */
+ return;
+ }
+
if (_edit_mode == Splice) {
- splice_locked ();
+ splice_locked (at, distance, exclude);
}
}
void
-Playlist::possibly_splice_unlocked ()
+Playlist::possibly_splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
+ if (_splicing || in_set_state) {
+ /* don't respond to splicing moves or state setting */
+ return;
+ }
+
if (_edit_mode == Splice) {
- splice_unlocked ();
+ splice_unlocked (at, distance, exclude);
}
}
void
-Playlist::splice_locked ()
+Playlist::splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
{
RegionLock rl (this);
- core_splice ();
+ core_splice (at, distance, exclude);
}
-
- notify_length_changed ();
}
void
-Playlist::splice_unlocked ()
+Playlist::splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
- core_splice ();
- notify_length_changed ();
+ core_splice (at, distance, exclude);
}
void
-Playlist::core_splice ()
+Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
_splicing = true;
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-
- RegionList::iterator next;
-
- next = i;
- ++next;
-
- if (next == regions.end()) {
- break;
+
+ if (exclude && (*i) == exclude) {
+ continue;
+ }
+
+ if ((*i)->position() >= at) {
+ nframes64_t new_pos = (*i)->position() + distance;
+ if (new_pos < 0) {
+ new_pos = 0;
+ } else if (new_pos >= max_frames - (*i)->length()) {
+ new_pos = max_frames - (*i)->length();
+ }
+
+ (*i)->set_position (new_pos, this);
}
-
- (*next)->set_position ((*i)->last_frame() + 1, this);
}
-
+
_splicing = false;
+
+ notify_length_changed ();
}
void
Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr<Region> region)
{
- if (in_set_state || _splicing || _nudging) {
+ if (in_set_state || _splicing || _nudging || _shuffling) {
return;
}
regions.erase (i);
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
-
}
if (what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) {
+
+ nframes64_t delta = 0;
+
+ if (what_changed & ARDOUR::PositionChanged) {
+ delta = (nframes64_t) region->position() - (nframes64_t) region->last_position();
+ }
+
+ if (what_changed & ARDOUR::LengthChanged) {
+ delta += (nframes64_t) region->length() - (nframes64_t) region->last_length();
+ }
+
+ if (delta) {
+ possibly_splice (region->last_position() + region->last_length(), delta, region);
+ }
+
if (holding_state ()) {
pending_bounds.push_back (region);
} else {
timestamp_layer_op (region);
}
- possibly_splice ();
notify_length_changed ();
relayer ();
check_dependents (region, false);
save = !(_splicing || _nudging);
}
- if ((what_changed & Region::MuteChanged) &&
- !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ if ((what_changed & our_interests) &&
+ !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
check_dependents (region, false);
}
}
if (with_signals) {
+ pending_length = false;
LengthChanged ();
+ pending_modified = false;
Modified ();
}
return region;
}
+Playlist::RegionList*
+Playlist::regions_to_read (nframes_t start, nframes_t end)
+{
+ /* Caller must hold lock */
+
+ RegionList covering;
+ set<nframes_t> to_check;
+ set<boost::shared_ptr<Region> > unique;
+ RegionList here;
+
+ to_check.insert (start);
+ to_check.insert (end);
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ /* find all/any regions that span start+end */
+
+ switch ((*i)->coverage (start, end)) {
+ case OverlapNone:
+ break;
+
+ case OverlapInternal:
+ covering.push_back (*i);
+ break;
+
+ case OverlapStart:
+ to_check.insert ((*i)->position());
+ covering.push_back (*i);
+ break;
+
+ case OverlapEnd:
+ to_check.insert ((*i)->last_frame());
+ covering.push_back (*i);
+ break;
+
+ case OverlapExternal:
+ covering.push_back (*i);
+ to_check.insert ((*i)->position());
+ to_check.insert ((*i)->last_frame());
+ break;
+ }
+
+ /* don't go too far */
+
+ if ((*i)->position() > end) {
+ break;
+ }
+ }
+
+ RegionList* rlist = new RegionList;
+
+ /* find all the regions that cover each position .... */
+
+ if (covering.size() == 1) {
+
+ rlist->push_back (covering.front());
+
+ } else {
+
+ for (set<nframes_t>::iterator t = to_check.begin(); t != to_check.end(); ++t) {
+
+ here.clear ();
+
+ for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) {
+
+ if ((*x)->covers (*t)) {
+ here.push_back (*x);
+ }
+ }
+
+ RegionSortByLayer cmp;
+ here.sort (cmp);
+
+ /* ... and get the top/transparent regions at "here" */
+
+ for (RegionList::reverse_iterator c = here.rbegin(); c != here.rend(); ++c) {
+
+ unique.insert (*c);
+
+ if ((*c)->opaque()) {
+
+ /* the other regions at this position are hidden by this one */
+
+ break;
+ }
+ }
+ }
+
+ for (set<boost::shared_ptr<Region> >::iterator s = unique.begin(); s != unique.end(); ++s) {
+ rlist->push_back (*s);
+ }
+
+ if (rlist->size() > 1) {
+ /* now sort by time order */
+
+ RegionSortByPosition cmp;
+ rlist->sort (cmp);
+ }
+ }
+
+ return rlist;
+}
+
Playlist::RegionList *
Playlist::find_regions_at (nframes_t frame)
{
+ /* Caller must hold lock */
+
RegionList *rlist = new RegionList;
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
return ret;
}
+nframes64_t
+Playlist::find_next_region_boundary (nframes64_t frame, int dir)
+{
+ RegionLock rlock (this);
+
+ nframes64_t closest = max_frames;
+ nframes64_t ret = -1;
+
+ if (dir > 0) {
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ boost::shared_ptr<Region> r = (*i);
+ nframes64_t distance;
+ nframes64_t end = r->position() + r->length();
+ bool reset;
+
+ reset = false;
+
+ if (r->first_frame() > frame) {
+
+ distance = r->first_frame() - frame;
+
+ if (distance < closest) {
+ ret = r->first_frame();
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (end > frame) {
+
+ distance = end - frame;
+
+ if (distance < closest) {
+ ret = end;
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (reset) {
+ break;
+ }
+ }
+
+ } else {
+
+ for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) {
+
+ boost::shared_ptr<Region> r = (*i);
+ nframes64_t distance;
+ bool reset;
+
+ reset = false;
+
+ if (r->last_frame() < frame) {
+
+ distance = frame - r->last_frame();
+
+ if (distance < closest) {
+ ret = r->last_frame();
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (r->first_frame() < frame) {
+ distance = frame - r->last_frame();
+
+ if (distance < closest) {
+ ret = r->first_frame();
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (reset) {
+ break;
+ }
+ }
+ }
+
+ return ret;
+}
+
/***********************************************************************/
/* don't send multiple Modified notifications
when multiple regions are relayered.
*/
-
+
freeze ();
/* build up a new list of regions on each layer */
/* 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 */
+
if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
RegionSortByLastLayerOp cmp;
copy.sort (cmp);
layers[j].push_back (*i);
}
- /* set up the layer numbers in the regions */
+ /* 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);
/* XXX these layer functions are all deprecated */
+void
+Playlist::raise_region (boost::shared_ptr<Region> region)
+{
+ uint32_t rsz = regions.size();
+ layer_t target = region->layer() + 1U;
+
+ if (target >= rsz) {
+ /* its already at the effective top */
+ return;
+ }
+
+ move_region_to_layer (target, region, 1);
+}
+
+void
+Playlist::lower_region (boost::shared_ptr<Region> region)
+{
+ if (region->layer() == 0) {
+ /* its already at the bottom */
+ return;
+ }
+
+ layer_t target = region->layer() - 1U;
+
+ move_region_to_layer (target, region, -1);
+}
+
void
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
}
}
+int
+Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr<Region> region, int dir)
+{
+ RegionList::iterator i;
+ typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
+ list<LayerInfo> layerinfo;
+ layer_t dest;
+
+ {
+ RegionLock rlock (const_cast<Playlist *> (this));
+
+ for (i = regions.begin(); i != regions.end(); ++i) {
+
+ if (region == *i) {
+ continue;
+ }
+
+ if (dir > 0) {
+
+ /* region is moving up, move all regions on intermediate layers
+ down 1
+ */
+
+ if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) {
+ dest = (*i)->layer() - 1;
+ } else {
+ /* not affected */
+ continue;
+ }
+ } else {
+
+ /* region is moving down, move all regions on intermediate layers
+ up 1
+ */
+
+ if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) {
+ dest = (*i)->layer() + 1;
+ } else {
+ /* not affected */
+ continue;
+ }
+ }
+
+ LayerInfo newpair;
+
+ newpair.first = *i;
+ newpair.second = dest;
+
+ layerinfo.push_back (newpair);
+ }
+ }
+
+ /* now reset the layers without holding the region lock */
+
+ for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
+ x->first->set_layer (x->second);
+ }
+
+ region->set_layer (target_layer);
+
+#if 0
+ /* now check all dependents */
+
+ for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
+ check_dependents (x->first, false);
+ }
+
+ check_dependents (region, false);
+#endif
+
+ return 0;
+}
+
void
Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards)
{
region->set_last_layer_op (++layer_op_counter);
}
+
+void
+Playlist::shuffle (boost::shared_ptr<Region> region, int dir)
+{
+ bool moved = false;
+ nframes_t new_pos;
+
+ if (region->locked()) {
+ return;
+ }
+
+ _shuffling = true;
+
+ {
+ RegionLock rlock (const_cast<Playlist*> (this));
+
+
+ if (dir > 0) {
+
+ RegionList::iterator next;
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i) == region) {
+ next = i;
+ ++next;
+
+ if (next != regions.end()) {
+
+ if ((*next)->locked()) {
+ break;
+ }
+
+ if ((*next)->position() != region->last_frame() + 1) {
+ /* they didn't used to touch, so after shuffle,
+ just have them swap positions.
+ */
+ new_pos = (*next)->position();
+ } else {
+ /* they used to touch, so after shuffle,
+ make sure they still do. put the earlier
+ region where the later one will end after
+ it is moved.
+ */
+ new_pos = region->position() + (*next)->length();
+ }
+
+ (*next)->set_position (region->position(), this);
+ region->set_position (new_pos, this);
+
+ /* avoid a full sort */
+
+ regions.erase (i); // removes the region from the list */
+ next++;
+ regions.insert (next, region); // adds it back after next
+
+ moved = true;
+ }
+ break;
+ }
+ }
+ } else {
+
+ RegionList::iterator prev = regions.end();
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); prev = i, ++i) {
+ if ((*i) == region) {
+
+ if (prev != regions.end()) {
+
+ if ((*prev)->locked()) {
+ break;
+ }
+
+ if (region->position() != (*prev)->last_frame() + 1) {
+ /* they didn't used to touch, so after shuffle,
+ just have them swap positions.
+ */
+ new_pos = region->position();
+ } else {
+ /* they used to touch, so after shuffle,
+ make sure they still do. put the earlier
+ one where the later one will end after
+ */
+ new_pos = (*prev)->position() + region->length();
+ }
+
+ region->set_position ((*prev)->position(), this);
+ (*prev)->set_position (new_pos, this);
+
+ /* avoid a full sort */
+
+ regions.erase (i); // remove region
+ regions.insert (prev, region); // insert region before prev
+
+ moved = true;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ _shuffling = false;
+
+ if (moved) {
+
+ relayer ();
+ check_dependents (region, false);
+
+ notify_modified();
+ }
+
+}
+
+bool
+Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+
+ if (regions.size() > 1) {
+ return true;
+ }
+
+ return false;
+}