#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"
}
};
-Playlist::Playlist (Session& sess, string nom, bool hide)
- : _session (sess)
+
+Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
+ : SessionObject(sess, nom)
+ , _type(type)
{
init (hide);
+ first_set_state = false;
_name = nom;
}
-Playlist::Playlist (Session& sess, const XMLNode& node, bool hide)
- : _session (sess)
+Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
+ : SessionObject(sess, "unnamed playlist")
+ , _type(type)
{
+ const XMLProperty* prop = node.property("type");
+ assert(!prop || DataType(prop->value()) == _type);
+
init (hide);
_name = "unnamed"; /* reset by set_state */
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
- : _name (namestr), _session (other->_session), _orig_diskstream_id(other->_orig_diskstream_id)
+ : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
init (hide);
_edit_mode = other->_edit_mode;
in_set_state = 0;
+ first_set_state = false;
in_flush = false;
in_partition = false;
subcnt = 0;
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
- : _name (str), _session (other->_session), _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()));
}
in_set_state--;
+ first_set_state = false;
/* this constructor does NOT notify others (session) */
}
g_atomic_int_set (&ignore_state_changes, 0);
pending_modified = false;
pending_length = false;
+ first_set_state = true;
_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 */
}
/***********************************************************************
}
}
-
void
Playlist::notify_modified ()
{
/* 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 */
}
}
+void
+Playlist::notify_region_moved (boost::shared_ptr<Region> r)
+{
+ Evoral::RangeMove const move (r->last_position (), r->length (), r->position ());
+
+ if (holding_state ()) {
+
+ pending_range_moves.push_back (move);
+
+ } else {
+
+ Evoral::RangeMoveList m;
+ m.push_back (move);
+ RangesMoved (m);
+
+ }
+
+}
+
void
Playlist::notify_region_added (boost::shared_ptr<Region> r)
{
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) {
check_dependents (*s, false);
}
+ if (!pending_range_moves.empty ()) {
+ RangesMoved (pending_range_moves);
+ }
+
pending_adds.clear ();
pending_removes.clear ();
pending_bounds.clear ();
+ pending_range_moves.clear ();
in_flush = false;
}
Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
{
RegionLock rlock (this);
-
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>());
}
void
}
}
-void
+bool
Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position)
{
+ if (region->data_type() != _type)
+ return false;
+
RegionSortByPosition cmp;
nframes_t old_length = 0;
old_length = _get_maximum_extent();
}
- if (!in_set_state) {
+ if (!first_set_state) {
boost::shared_ptr<Playlist> foo (shared_from_this());
region->set_playlist (boost::weak_ptr<Playlist>(foo));
- }
+ }
region->set_position (position, this);
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 ();
}
}
- region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy),
- boost::weak_ptr<Region> (region)));
+ region_state_changed_connections.push_back (
+ region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy),
+ boost::weak_ptr<Region> (region)))
+ );
+
+ return true;
}
void
{
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;
old_length = _get_maximum_extent();
}
+ if (!in_set_state) {
+ /* unset playlist */
+ region->set_playlist (boost::weak_ptr<Playlist>());
+ }
+
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;
}
void
Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
{
- RegionLock rlock (this);
- boost::shared_ptr<Region> region;
- boost::shared_ptr<Region> current;
- string new_name;
- RegionList::iterator tmp;
- OverlapType overlap;
- nframes_t pos1, pos2, pos3, pos4;
RegionList new_regions;
- in_partition = true;
-
- /* need to work from a copy, because otherwise the regions we add during the process
- get operated on as well.
- */
-
- RegionList copy = regions;
-
- for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+ {
+ RegionLock rlock (this);
+ boost::shared_ptr<Region> region;
+ boost::shared_ptr<Region> current;
+ string new_name;
+ RegionList::iterator tmp;
+ OverlapType overlap;
+ nframes_t pos1, pos2, pos3, pos4;
- tmp = i;
- ++tmp;
-
- current = *i;
+ in_partition = true;
- if (current->first_frame() == start && current->last_frame() == end) {
- if (cutting) {
- remove_region_internal (current);
- }
- continue;
- }
+ /* need to work from a copy, because otherwise the regions we add during the process
+ get operated on as well.
+ */
- if ((overlap = current->coverage (start, end)) == OverlapNone) {
- continue;
- }
+ RegionList copy = regions;
- pos1 = current->position();
- pos2 = start;
- pos3 = end;
- pos4 = current->last_frame();
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+
+ tmp = i;
+ ++tmp;
+
+ current = *i;
- if (overlap == OverlapInternal) {
+ if (current->first_frame() >= start && current->last_frame() < end) {
+ if (cutting) {
+ remove_region_internal (current);
+ }
+ continue;
+ }
- /* split: we need 3 new regions, the front, middle and end.
- cut: we need 2 regions, the front and end.
+ /* coverage will return OverlapStart if the start coincides
+ with the end point. we do not partition such a region,
+ so catch this special case.
*/
+
+ if (current->first_frame() >= end) {
+ continue;
+ }
+
+ if ((overlap = current->coverage (start, end)) == OverlapNone) {
+ continue;
+ }
+
+ pos1 = current->position();
+ pos2 = start;
+ pos3 = end;
+ 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.
+ */
+
+ /*
start end
---------------*************************------------
P1 P2 P3 P4
CUT
---------------*****----------------====------------
- */
+ */
- if (!cutting) {
+ if (!cutting) {
- /* "middle" ++++++ */
+ /* "middle" ++++++ */
+
+ _session.region_name (new_name, current->name(), false);
+ region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
+ regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
+ /* "end" ====== */
+
_session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
- add_region_internal (region, start);
+ 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);
- }
-
- /* "end" ====== */
-
- _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);
-
- /* "front" ***** */
- current->freeze ();
- thawlist.push_back (current);
- current->trim_end (pos2, this);
-
- } else if (overlap == OverlapEnd) {
-
- /*
+ /* "front" ***** */
+
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_end (pos2, this);
+
+ } else if (overlap == OverlapEnd) {
+
+ /*
start end
---------------*************************------------
P1 P2 P4 P3
---------------**************+++++++++++------------
CUT:
---------------**************-----------------------
-
- */
-
- if (!cutting) {
+ */
- /* 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);
+ }
- _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);
- }
-
- /* front ****** */
-
- 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
- */
+ /* front ****** */
+
+ 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
+ */
+
+ /*
start end
---------------*************************------------
P2 P1 P3 P4
CUT:
-------------------*********************------------
- */
+ */
- if (!cutting) {
+ 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);
- }
-
- /* end */
-
- current->freeze ();
- thawlist.push_back (current);
- current->trim_front (pos3, this);
-
- } else if (overlap == OverlapExternal) {
-
- /* split: no split required.
- cut: remove the region.
- */
+ /* 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);
+ }
+
+ /* end */
+
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_front (pos3, this);
- /*
+ } else if (overlap == OverlapExternal) {
+
+ /* split: no split required.
+ cut: remove the region.
+ */
+
+ /*
start end
---------------*************************------------
P2 P1 P3 P4
CUT:
----------------------------------------------------
- */
-
- if (cutting) {
- remove_region_internal (current);
+ */
+
+ if (cutting) {
+ remove_region_internal (current);
+ }
+ new_regions.push_back (current);
}
- new_regions.push_back (current);
}
+
+ in_partition = false;
}
- in_partition = false;
-
for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) {
check_dependents (*i, false);
}
}
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? */
}
}
+void
+Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bool ignore_music_glue)
+{
+ RegionLock rlock (this);
+ RegionList copy (regions);
+ RegionList fixup;
+
+ for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
+
+ if ((*r)->last_frame() < at) {
+ /* too early */
+ continue;
+ }
+
+ if (at > (*r)->first_frame() && at < (*r)->last_frame()) {
+ /* intersected region */
+ if (!move_intersected) {
+ continue;
+ }
+ }
+
+ /* do not move regions glued to music time - that
+ has to be done separately.
+ */
+
+ if (!ignore_music_glue && (*r)->positional_lock_style() != Region::AudioTime) {
+ fixup.push_back (*r);
+ continue;
+ }
+
+ (*r)->set_position ((*r)->position() + distance, this);
+ }
+
+ for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) {
+ (*r)->recompute_position_from_lock_style ();
+ }
+}
+
+void
+Playlist::split (nframes64_t at)
+{
+ RegionLock rlock (this);
+ RegionList copy (regions);
+
+ /* use a copy since this operation can modify the region list
+ */
+
+ for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
+ _split_region (*r, at);
+ }
+}
+
void
Playlist::split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
{
RegionLock rl (this);
+ _split_region (region, playlist_position);
+}
+void
+Playlist::_split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
+{
if (!region->covers (playlist_position)) {
return;
}
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);
return false;
}
- {
- if (what_changed & BoundsChanged) {
- region_bounds_changed (what_changed, region);
- save = !(_splicing || _nudging);
- }
+ if (what_changed & BoundsChanged) {
+ region_bounds_changed (what_changed, region);
+ save = !(_splicing || _nudging);
+ }
- if ((what_changed & Region::MuteChanged) &&
- !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
- check_dependents (region, false);
- }
+ if ((what_changed & our_interests) &&
+ !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ check_dependents (region, false);
+ }
+
+ if (what_changed & Change (ARDOUR::PositionChanged)) {
+ notify_region_moved (region);
+ }
- if (what_changed & our_interests) {
- save = true;
- }
+ if (what_changed & our_interests) {
+ save = true;
}
return save;
}
+void
+Playlist::drop_regions ()
+{
+ RegionLock rl (this);
+ regions.clear ();
+ all_regions.clear ();
+}
+
void
Playlist::clear (bool with_signals)
{
{
RegionLock rl (this);
+
+ for (
+ std::list<sigc::connection>::iterator i = region_state_changed_connections.begin ();
+ i != region_state_changed_connections.end ();
+ ++i
+ ) {
+
+ i->disconnect ();
+
+ }
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
pending_removes.insert (*i);
}
}
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 rlist;
}
+nframes64_t
+Playlist::find_next_transient (nframes64_t from, int dir)
+{
+ RegionLock rlock (this);
+ AnalysisFeatureList points;
+ AnalysisFeatureList these_points;
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if (dir > 0) {
+ if ((*i)->last_frame() < from) {
+ continue;
+ }
+ } else {
+ if ((*i)->first_frame() > from) {
+ continue;
+ }
+ }
+
+ (*i)->get_transients (these_points);
+
+ /* add first frame, just, err, because */
+
+ these_points.push_back ((*i)->first_frame());
+
+ points.insert (points.end(), these_points.begin(), these_points.end());
+ these_points.clear ();
+ }
+
+ if (points.empty()) {
+ return -1;
+ }
+
+ TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0);
+ bool reached = false;
+
+ if (dir > 0) {
+ for (AnalysisFeatureList::iterator x = points.begin(); x != points.end(); ++x) {
+ if ((*x) >= from) {
+ reached = true;
+ }
+
+ if (reached && (*x) > from) {
+ return *x;
+ }
+ }
+ } else {
+ for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) {
+ if ((*x) <= from) {
+ reached = true;
+ }
+
+ if (reached && (*x) < from) {
+ return *x;
+ }
+ }
+ }
+
+ return -1;
+}
boost::shared_ptr<Region>
Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir)
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;
+}
+
/***********************************************************************/
}
in_set_state--;
-
+ first_set_state = false;
return 0;
}
char buf[64];
node->add_property (X_("name"), _name);
+ node->add_property (X_("type"), _type.to_string());
_orig_diskstream_id.print (buf, sizeof (buf));
node->add_property (X_("orig_diskstream_id"), buf);
return _get_maximum_extent ();
}
-nframes_t
+ARDOUR::nframes_t
Playlist::_get_maximum_extent () const
{
RegionList::const_iterator i;
string newname = name;
do {
- newname = Playlist::bump_name_once (newname);
+ newname = bump_name_once (newname);
} while (session.playlist_by_name (newname)!=NULL);
return newname;
}
-string
-Playlist::bump_name_once (string name)
-{
- string::size_type period;
- string newname;
-
- if ((period = name.find_last_of ('.')) == string::npos) {
- newname = name;
- newname += ".1";
- } else {
- char buf[32];
- int version;
-
- sscanf (name.substr (period+1).c_str(), "%d", &version);
- snprintf (buf, sizeof(buf), "%d", version+1);
-
- newname = name.substr (0, period+1);
- newname += buf;
- }
-
- return newname;
-}
layer_t
Playlist::top_layer() const
void
Playlist::relayer ()
{
- RegionList::iterator i;
- uint32_t layer = 0;
-
/* don't send multiple Modified notifications
when multiple regions are relayered.
*/
-
+
freeze ();
- if (Config->get_layer_model() == MoveAddHigher ||
- Config->get_layer_model() == AddHigher) {
+ /* build up a new list of regions on each layer */
- RegionSortByLastLayerOp cmp;
- RegionList copy = regions;
+ std::vector<RegionList> layers;
+ /* 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);
+ }
+
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
- for (i = copy.begin(); i != copy.end(); ++i) {
- (*i)->set_layer (layer++);
+ /* 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)) {
+ break;
+ }
+ k++;
+ }
+
+ if (k != layers[j - 1].end()) {
+ /* no overlap, so we can use this layer */
+ break;
+ }
+
+ j--;
}
- } else {
-
- /* Session::LaterHigher model */
+ if (j == layers.size()) {
+ /* we need a new layer for this region */
+ layers.push_back (RegionList ());
+ }
- for (i = regions.begin(); i != regions.end(); ++i) {
- (*i)->set_layer (layer++);
+ 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);
}
}
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;
+}
+
+void
+Playlist::update_after_tempo_map_change ()
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+ RegionList copy (regions);
+
+ freeze ();
+
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+ (*i)->update_position_after_tempo_map_change ();
+ }
+
+ thaw ();
+}
projects / ardour.git / blobdiff