, _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);
}
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);
set_layer (copy_of_region, copy_of_region->layer() + top);
}
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);
+}
+
+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); // times ??
+ }
+}
+
void
Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
{
{
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);
{
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);
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);
}
}
}
mark_session_dirty ();
-
+
return save;
}
}
- /***********************************************************************
+ /* *********************************************************************
FINDING THINGS
**********************************************************************/
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);
}
thaw ();
+ notify_contents_changed();
}
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);
}
}
/* 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.
*/