#include "ardour/session_playlists.h"
#include "ardour/source_factory.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
, _type(type)
{
#ifndef NDEBUG
- const XMLProperty* prop = node.property("type");
+ XMLProperty const * prop = node.property("type");
assert(!prop || DataType(prop->value()) == _type);
#endif
pending_contents_change = false;
RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
ContentsChanged (); /* EMIT SIGNAL */
-
+
}
}
remove_dependents (*s);
RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
}
-
+
for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
crossfade_ranges.push_back ((*s)->range ());
/* don't emit RegionAdded signal until relayering is done,
pending_layering = true;
ContentsChanged (); /* EMIT SIGNAL */
}
-
+
for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
(*s)->clear_changes ();
RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
}
-
+
if ((regions_changed && !in_set_state) || pending_layering) {
relayer ();
}
-
+
coalesce_and_check_crossfades (crossfade_ranges);
-
+
if (!pending_range_moves.empty ()) {
/* We don't need to check crossfades for these as pending_bounds has
already covered it.
*/
RangesMoved (pending_range_moves, from_undo);
}
-
+
if (!pending_region_extensions.empty ()) {
RegionsExtended (pending_region_extensions);
}
pending_range_moves.clear ();
pending_region_extensions.clear ();
pending_contents_change = false;
+ pending_layering = false;
}
/*************************************************************
/** Note: this calls set_layer (..., DBL_MAX) so it will reset the layering index of region */
void
- Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition)
+ Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition, const int32_t sub_num)
{
RegionWriteLock rlock (this);
times = fabs (times);
}
if (itimes >= 1) {
- add_region_internal (region, pos);
+ add_region_internal (region, pos, sub_num);
set_layer (region, DBL_MAX);
pos += region->length();
--itimes;
*/
for (int i = 0; i < itimes; ++i) {
- boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
- add_region_internal (copy, pos);
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true, sub_num);
+ add_region_internal (copy, pos, sub_num);
set_layer (copy, DBL_MAX);
pos += region->length();
}
plist.add (Properties::layer, region->layer());
boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
- add_region_internal (sub, pos);
+ add_region_internal (sub, pos, sub_num);
set_layer (sub, DBL_MAX);
}
}
}
bool
- Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position)
+ Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position, const int32_t sub_num)
{
if (region->data_type() != _type) {
return false;
region->set_playlist (boost::weak_ptr<Playlist>(foo));
}
- region->set_position (position);
+ region->set_position (position, sub_num);
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
all_regions.insert (region);
chopped.
*/
- ret->paste (pl, (*i).start - start, 1.0f);
+ ret->paste (pl, (*i).start - start, 1.0f, 0);
}
}
}
int
- Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times)
+ Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times, const int32_t sub_num)
{
times = fabs (times);
while (itimes--) {
for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
-
+
/* put these new regions on top of all existing ones, but preserve
the ordering they had in the original playlist.
*/
-
- add_region_internal (copy_of_region, (*i)->position() + pos);
+
+ add_region_internal (copy_of_region, (*i)->position() + pos, sub_num);
set_layer (copy_of_region, copy_of_region->layer() + top);
}
pos += shift;
void
Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
+ {
+ duplicate(region, position, region->length(), times);
+ }
+
+/** @param gap from the beginning of the region to the next beginning */
+ void
+ Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, float times)
{
times = fabs (times);
RegionWriteLock rl (this);
int itimes = (int) floor (times);
- framepos_t pos = position + 1;
while (itimes--) {
boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
- add_region_internal (copy, pos);
+ add_region_internal (copy, position);
set_layer (copy, DBL_MAX);
- pos += region->length();
+ position += gap;
}
if (floor (times) != times) {
plist.add (Properties::name, name);
boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
- add_region_internal (sub, pos);
+ add_region_internal (sub, position);
set_layer (sub, DBL_MAX);
}
}
}
+/** @param gap from the beginning of the region to the next beginning */
+/** @param end the first frame that does _not_ contain a duplicated frame */
+void
+Playlist::duplicate_until (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, framepos_t end)
+{
+ RegionWriteLock rl (this);
+
+ while (position + region->length() - 1 < end) {
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+ add_region_internal (copy, position);
+ set_layer (copy, DBL_MAX);
+ position += gap;
+ }
+
+ if (position < end) {
+ framecnt_t length = min (region->length(), end - position);
+ string name;
+ RegionFactory::region_name (name, region->name(), false);
+
+ {
+ PropertyList plist;
+
+ plist.add (Properties::start, region->start());
+ plist.add (Properties::length, length);
+ plist.add (Properties::name, name);
+
+ boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
+ add_region_internal (sub, position);
+ set_layer (sub, DBL_MAX);
+ }
+ }
+}
+
+void
+Playlist::duplicate_range (AudioRange& range, float times)
+{
+ boost::shared_ptr<Playlist> pl = copy (range.start, range.length(), true);
+ framecnt_t offset = range.end - range.start;
+ paste (pl, range.start + offset, times, 0);
+}
+
+void
+Playlist::duplicate_ranges (std::list<AudioRange>& ranges, float /* times */)
+{
+ if (ranges.empty()) {
+ return;
+ }
+
+ framepos_t min_pos = max_framepos;
+ framepos_t max_pos = 0;
+
+ for (std::list<AudioRange>::const_iterator i = ranges.begin();
+ i != ranges.end();
+ ++i) {
+ min_pos = min (min_pos, (*i).start);
+ max_pos = max (max_pos, (*i).end);
+ }
+
+ framecnt_t offset = max_pos - min_pos;
+
+ for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ boost::shared_ptr<Playlist> pl = copy ((*i).start, (*i).length(), true);
+ paste (pl, (*i).start + offset, 1.0f, 0); // times ??
+ }
+}
+
void
Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
{
/* XXX: may not be necessary; Region::post_set should do this, I think */
for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) {
- (*r)->recompute_position_from_lock_style ();
+ (*r)->recompute_position_from_lock_style (0);
}
}
void
- Playlist::split (framepos_t at)
+ Playlist::split (framepos_t at, const int32_t sub_num)
{
RegionWriteLock rlock (this);
RegionList copy (regions.rlist());
*/
for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
- _split_region (*r, at);
+ _split_region (*r, at, sub_num);
}
}
void
- Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position, const int32_t sub_num)
{
RegionWriteLock rl (this);
- _split_region (region, playlist_position);
+ _split_region (region, playlist_position, sub_num);
}
void
- Playlist::_split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::_split_region (boost::shared_ptr<Region> region, framepos_t playlist_position, const int32_t sub_num)
{
if (!region->covers (playlist_position)) {
return;
{
PropertyList plist;
- plist.add (Properties::position, region->position ());
plist.add (Properties::length, before);
plist.add (Properties::name, before_name);
plist.add (Properties::left_of_split, true);
since it supplies that offset to the Region constructor, which
is necessary to get audio region gain envelopes right.
*/
- left = RegionFactory::create (region, 0, plist);
+ left = RegionFactory::create (region, 0, plist, true, sub_num);
}
RegionFactory::region_name (after_name, region->name(), false);
{
PropertyList plist;
- plist.add (Properties::position, region->position() + before);
plist.add (Properties::length, after);
plist.add (Properties::name, after_name);
plist.add (Properties::right_of_split, true);
plist.add (Properties::layer, region->layer ());
/* same note as above */
- right = RegionFactory::create (region, before, plist);
+ right = RegionFactory::create (region, before, plist, true, sub_num);
}
add_region_internal (left, region->position());
if (_edit_mode == Splice) {
splice_locked (at, distance, exclude);
- }
+ }
}
void
new_pos = 0;
} else if (new_pos >= limit ) {
new_pos = limit;
- }
-
+ }
+
(*i)->set_position (new_pos);
}
}
save = true;
}
- mark_session_dirty ();
-
+ mark_session_dirty ();
+
return save;
}
}
- /***********************************************************************
+ /* *********************************************************************
FINDING THINGS
**********************************************************************/
+boost::shared_ptr<RegionList>
+Playlist::region_list()
+{
+ RegionReadLock rlock (this);
+ boost::shared_ptr<RegionList> rlist (new RegionList (regions.rlist ()));
+ return rlist;
+}
+
+void
+Playlist::deep_sources (std::set<boost::shared_ptr<Source> >& sources) const
+{
+ RegionReadLock rlock (const_cast<Playlist*>(this));
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ (*i)->deep_sources (sources);
+ }
+}
+
boost::shared_ptr<RegionList>
Playlist::regions_at (framepos_t frame)
{
for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
RegionList::iterator tmp = i;
+
++tmp;
if ((*i)->muted()) {
Playlist::find_regions_at (framepos_t frame)
{
/* Caller must hold lock */
-
+
boost::shared_ptr<RegionList> rlist (new RegionList);
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->covers (frame)) {
rlist->push_back (*i);
}
}
-
+
return rlist;
}
Playlist::regions_touched_locked (framepos_t start, framepos_t end)
{
boost::shared_ptr<RegionList> rlist (new RegionList);
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->coverage (start, end) != Evoral::OverlapNone) {
rlist->push_back (*i);
}
}
-
+
return rlist;
}
RegionReadLock 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;
}
}
-
+
(*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) {
+ for (AnalysisFeatureList::const_iterator x = points.begin(); x != points.end(); ++x) {
if ((*x) >= from) {
reached = true;
}
-
+
if (reached && (*x) > from) {
return *x;
}
if ((*x) <= from) {
reached = true;
}
-
+
if (reached && (*x) < from) {
return *x;
}
}
}
-
+
return -1;
}
RegionReadLock rlock (this);
boost::shared_ptr<Region> ret;
framepos_t closest = max_framepos;
-
+
bool end_iter = false;
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-
+
if(end_iter) break;
-
+
frameoffset_t distance;
boost::shared_ptr<Region> r = (*i);
framepos_t pos = 0;
-
+
switch (point) {
case Start:
pos = r->first_frame ();
pos = r->sync_position ();
break;
}
-
+
switch (dir) {
case 1: /* forwards */
-
+
if (pos > frame) {
if ((distance = pos - frame) < closest) {
closest = distance;
end_iter = true;
}
}
-
+
break;
-
+
default: /* backwards */
-
+
if (pos < frame) {
if ((distance = frame - pos) < closest) {
closest = distance;
} else {
end_iter = true;
}
-
+
break;
}
}
-
+
return ret;
}
boost::shared_ptr<Region> r = (*i);
frameoffset_t distance;
+ const framepos_t first_frame = r->first_frame();
+ const framepos_t last_frame = r->last_frame();
- if (r->first_frame() > frame) {
+ if (first_frame > frame) {
- distance = r->first_frame() - frame;
+ distance = first_frame - frame;
if (distance < closest) {
- ret = r->first_frame();
+ ret = first_frame;
closest = distance;
}
}
- if (r->last_frame () > frame) {
+ if (last_frame > frame) {
- distance = r->last_frame () - frame;
+ distance = last_frame - frame;
if (distance < closest) {
- ret = r->last_frame ();
+ ret = last_frame;
closest = distance;
}
}
boost::shared_ptr<Region> r = (*i);
frameoffset_t distance;
+ const framepos_t first_frame = r->first_frame();
+ const framepos_t last_frame = r->last_frame();
- if (r->last_frame() < frame) {
+ if (last_frame < frame) {
- distance = frame - r->last_frame();
+ distance = frame - last_frame;
if (distance < closest) {
- ret = r->last_frame();
+ ret = last_frame;
closest = distance;
}
}
- if (r->first_frame() < frame) {
+ if (first_frame < frame) {
- distance = frame - r->first_frame();
+ distance = frame - first_frame;
if (distance < closest) {
- ret = r->first_frame();
+ ret = first_frame;
closest = distance;
}
}
XMLNodeConstIterator niter;
XMLPropertyList plist;
XMLPropertyConstIterator piter;
- XMLProperty *prop;
+ XMLProperty const * prop;
boost::shared_ptr<Region> region;
string region_name;
bool seen_region_nodes = false;
RegionWriteLock rlock (this);
add_region_internal (region, region->position());
}
-
+
region->resume_property_changes ();
}
if (seen_region_nodes && regions.empty()) {
ret = -1;
}
-
+
thaw ();
notify_contents_changed ();
}
++i;
}
-
+
copy.insert (i, region);
setup_layering_indices (copy);
}
bool
-Playlist::uses_source (boost::shared_ptr<const Source> src) const
+Playlist::uses_source (boost::shared_ptr<const Source> src, bool shallow) const
{
RegionReadLock rlock (const_cast<Playlist*> (this));
for (set<boost::shared_ptr<Region> >::const_iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
- if ((*r)->uses_source (src)) {
+ /* Note: passing the second argument as false can cause at best
+ incredibly deep and time-consuming recursion, and at worst
+ cycles if the user has managed to create cycles of reference
+ between compound regions. We generally only this during
+ cleanup, and @param shallow is passed as true.
+ */
+ if ((*r)->uses_source (src, shallow)) {
return true;
}
}
return false;
}
+
boost::shared_ptr<Region>
Playlist::find_region (const ID& id) const
{
for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
(*i)->update_after_tempo_map_change ();
}
-
+ /* possibly causes a contents changed notification (flush_notifications()) */
thaw ();
}
void
Playlist::foreach_region (boost::function<void(boost::shared_ptr<Region>)> s)
{
- RegionWriteLock rl (this, false);
+ RegionReadLock rl (this);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
s (*i);
}
return (i != regions.end());
}
-/** Remove any region that uses a given source */
-void
-Playlist::remove_region_by_source (boost::shared_ptr<Source> s)
-{
- RegionWriteLock rl (this);
-
- RegionList::iterator i = regions.begin();
- while (i != regions.end()) {
- RegionList::iterator j = i;
- ++j;
-
- if ((*i)->uses_source (s)) {
- remove_region_internal (*i);
- }
-
- i = j;
- }
-}
-
/** Look from a session frame time and find the start time of the next region
* which is on the top layer of this playlist.
* @param t Time to look from.
// (2) get all the original regions
- const RegionList& rl (pl->region_list().rlist());
+ const RegionList& rl (pl->region_list_property().rlist());
RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
frameoffset_t move_offset = 0;
}
/* check to see how the original region (in the
- * playlist before compounding occured) overlaps
+ * playlist before compounding occurred) overlaps
* with the new state of the compound region.
*/