#include <stdint.h>
#include <set>
-#include <fstream>
#include <algorithm>
-#include <unistd.h>
-#include <cerrno>
#include <string>
-#include <climits>
#include <boost/lexical_cast.hpp>
#include "pbd/convert.h"
-#include "pbd/failed_constructor.h"
#include "pbd/stateful_diff_command.h"
#include "pbd/xml++.h"
using namespace PBD;
namespace ARDOUR {
-namespace Properties {
-PBD::PropertyDescriptor<bool> regions;
-}
+ namespace Properties {
+ PBD::PropertyDescriptor<bool> regions;
+ }
}
struct ShowMeTheList {
in_set_state--;
_splicing = other->_splicing;
+ _rippling = other->_rippling;
_nudging = other->_nudging;
_edit_mode = other->_edit_mode;
, _type(other->_type)
, _orig_track_id (other->_orig_track_id)
{
- RegionLock rlock2 (const_cast<Playlist*> (other.get()));
+ RegionReadLock rlock2 (const_cast<Playlist*> (other.get()));
framepos_t end = start + cnt - 1;
plist.add (Properties::layer, region->layer());
plist.add (Properties::layering_index, region->layering_index());
- new_region = RegionFactory::RegionFactory::create (region, plist);
+ new_region = RegionFactory::create (region, plist);
add_region_internal (new_region, position);
}
+ //keep track of any dead space at end (for pasting into Ripple or Splice mode)
+ //at the end of construction, any length of cnt beyond the extents of the regions is end_space
+ _end_space = cnt - (get_extent().second - get_extent().first);
+
in_set_state--;
first_set_state = false;
}
void
Playlist::copy_regions (RegionList& newlist) const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionReadLock rlock (const_cast<Playlist *> (this));
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- newlist.push_back (RegionFactory::RegionFactory::create (*i, true));
+ newlist.push_back (RegionFactory::create (*i, true));
}
}
_refcnt = 0;
_hidden = hide;
_splicing = false;
+ _rippling = false;
_shuffling = false;
_nudging = false;
in_set_state = 0;
in_partition = false;
subcnt = 0;
_frozen = false;
+ _capture_insertion_underway = false;
_combine_ops = 0;
+ _end_space = 0;
_session.history().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this));
_session.history().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this));
DEBUG_TRACE (DEBUG::Destruction, string_compose ("Playlist %1 destructor\n", _name));
{
- RegionLock rl (this);
+ RegionReadLock rl (this);
for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
(*i)->set_playlist (boost::shared_ptr<Playlist>());
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,
*/
}
- if (((regions_changed || pending_contents_change) && !in_set_state) || pending_layering) {
- relayer ();
+ /* notify about contents/region changes first so that layering changes
+ * in a UI will take place on the new contents.
+ */
+
+ if (regions_changed || pending_contents_change) {
+ pending_layering = true;
+ ContentsChanged (); /* EMIT SIGNAL */
}
- if (regions_changed || pending_contents_change) {
- pending_contents_change = false;
- ContentsChanged (); /* EMIT SIGNAL */
- }
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ (*s)->clear_changes ();
+ RegionAdded (boost::weak_ptr<Region> (*s)); /* 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);
+ 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_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);
- }
+ if (!pending_region_extensions.empty ()) {
+ RegionsExtended (pending_region_extensions);
+ }
- clear_pending ();
+ clear_pending ();
- in_flush = false;
- }
+ in_flush = false;
+}
void
Playlist::clear_pending ()
void
Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition)
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
times = fabs (times);
int itimes = (int) floor (times);
}
}
- possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
+ possibly_splice_unlocked (position, (pos + length) - position, region);
}
void
Playlist::set_region_ownership ()
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
RegionList::iterator i;
boost::weak_ptr<Playlist> pl (shared_from_this());
notify_region_added (region);
- if (!holding_state ()) {
- check_crossfades (region->range ());
- }
-
region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
return true;
void
Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos)
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
bool old_sp = _splicing;
_splicing = true;
void
Playlist::remove_region (boost::shared_ptr<Region> region)
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
remove_region_internal (region);
}
}
}
+ void
+ Playlist::get_source_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+ {
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ if ((*i) && (*i)->any_source_equivalent (other)) {
+ results.push_back (*i);
+ }
+ }
+ }
+
void
Playlist::partition (framepos_t start, framepos_t end, bool cut)
{
RegionList new_regions;
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> current;
in_partition = false;
}
- check_crossfades (Evoral::Range<framepos_t> (start, end));
+ //keep track of any dead space at end (for pasting into Ripple or Splice mode)
+ framepos_t wanted_length = end-start;
+ _end_space = wanted_length - get_extent().second-get_extent().first;
}
boost::shared_ptr<Playlist>
new_name += '.';
new_name += buf;
- cnt = min (_get_extent().second - start, cnt);
+ // cnt = min (_get_extent().second - start, cnt); (We need the full range length when copy/pasting in Ripple. Why was this limit here? It's not in CUT... )
+
return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
}
times = fabs (times);
{
- RegionLock rl1 (this);
- RegionLock rl2 (other.get());
+ RegionReadLock rl2 (other.get());
int itimes = (int) floor (times);
framepos_t pos = position;
framecnt_t const shift = other->_get_extent().second;
layer_t top = top_layer ();
- 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);
+ {
+ RegionWriteLock rl1 (this);
+ 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.
- */
+ /* 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);
+ add_region_internal (copy_of_region, (*i)->position() + pos);
+ set_layer (copy_of_region, copy_of_region->layer() + top);
+ }
+ pos += shift;
}
- 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);
- RegionLock rl (this);
+ 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);
}
}
void
Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
RegionList copy (regions.rlist());
RegionList fixup;
void
Playlist::split (framepos_t at)
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
RegionList copy (regions.rlist());
/* use a copy since this operation can modify the region list
void
Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
_split_region (region, playlist_position);
}
Playlist::splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
{
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
core_splice (at, distance, exclude);
}
}
_splicing = false;
notify_contents_changed ();
- }
+}
- void
- Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
- {
- if (in_set_state || _splicing || _nudging || _shuffling) {
+void
+Playlist::ripple_locked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+ {
+ RegionWriteLock rl (this);
+ core_ripple (at, distance, exclude);
+ }
+}
+
+void
+Playlist::ripple_unlocked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+ core_ripple (at, distance, exclude);
+}
+
+void
+Playlist::core_ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+ if (distance == 0) {
+ return;
+ }
+
+ _rippling = true;
+ RegionListProperty copy = regions;
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+ assert (i != copy.end());
+
+ if (exclude) {
+ if (std::find(exclude->begin(), exclude->end(), (*i)) != exclude->end()) {
+ continue;
+ }
+ }
+
+ if ((*i)->position() >= at) {
+ framepos_t new_pos = (*i)->position() + distance;
+ framepos_t limit = max_framepos - (*i)->length();
+ if (new_pos < 0) {
+ new_pos = 0;
+ } else if (new_pos >= limit ) {
+ new_pos = limit;
+ }
+
+ (*i)->set_position (new_pos);
+ }
+ }
+
+ _rippling = false;
+ notify_contents_changed ();
+}
+
+
+void
+Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
+{
+ if (in_set_state || _splicing || _rippling || _nudging || _shuffling) {
return;
}
save = !(_splicing || _nudging);
}
- if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) {
- check_crossfades (region->range ());
- }
-
if (what_changed.contains (Properties::position) && !what_changed.contains (Properties::length)) {
notify_region_moved (region);
} else if (!what_changed.contains (Properties::position) && what_changed.contains (Properties::length)) {
save = true;
}
+ mark_session_dirty ();
+
return save;
}
void
Playlist::drop_regions ()
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
regions.clear ();
all_regions.clear ();
}
void
Playlist::sync_all_regions_with_regions ()
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
all_regions.clear ();
Playlist::clear (bool with_signals)
{
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
region_state_changed_connections.drop_connections ();
boost::shared_ptr<RegionList>
Playlist::regions_at (framepos_t frame)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
return find_regions_at (frame);
}
uint32_t
Playlist::count_regions_at (framepos_t frame) const
{
- RegionLock rlock (const_cast<Playlist*>(this));
+ RegionReadLock rlock (const_cast<Playlist*>(this));
uint32_t cnt = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
Playlist::top_region_at (framepos_t frame)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist = find_regions_at (frame);
boost::shared_ptr<Region> region;
Playlist::top_unmuted_region_at (framepos_t frame)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist = find_regions_at (frame);
for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
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;
}
boost::shared_ptr<RegionList>
Playlist::regions_with_start_within (Evoral::Range<framepos_t> range)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist (new RegionList);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
boost::shared_ptr<RegionList>
Playlist::regions_with_end_within (Evoral::Range<framepos_t> range)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist (new RegionList);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
boost::shared_ptr<RegionList>
Playlist::regions_touched (framepos_t start, framepos_t end)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
+ return regions_touched_locked (start, end);
+}
+
+boost::shared_ptr<RegionList>
+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;
}
- framepos_t
- Playlist::find_next_transient (framepos_t from, int dir)
- {
- RegionLock rlock (this);
- AnalysisFeatureList points;
- AnalysisFeatureList these_points;
+framepos_t
+Playlist::find_next_transient (framepos_t from, int dir)
+{
+ 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;
- }
- } else {
- if ((*i)->first_frame() > from) {
- continue;
- }
- }
+ 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);
+ (*i)->get_transients (these_points);
- /* add first frame, just, err, because */
+ /* add first frame, just, err, because */
- these_points.push_back ((*i)->first_frame());
+ these_points.push_back ((*i)->first_frame());
- points.insert (points.end(), these_points.begin(), these_points.end());
- these_points.clear ();
- }
+ points.insert (points.end(), these_points.begin(), these_points.end());
+ these_points.clear ();
+ }
- if (points.empty()) {
- return -1;
- }
+ if (points.empty()) {
+ return -1;
+ }
- TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0);
- bool reached = false;
+ 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 (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;
+ }
+ }
+ } else {
+ for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) {
+ if ((*x) <= from) {
+ reached = true;
+ }
- if (reached && (*x) < from) {
- return *x;
- }
- }
- }
+ if (reached && (*x) < from) {
+ return *x;
+ }
+ }
+ }
- return -1;
- }
+ return -1;
+}
- boost::shared_ptr<Region>
- Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
- {
- RegionLock rlock (this);
- boost::shared_ptr<Region> ret;
- framepos_t closest = max_framepos;
+boost::shared_ptr<Region>
+Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
+{
+ RegionReadLock rlock (this);
+ boost::shared_ptr<Region> ret;
+ framepos_t closest = max_framepos;
- bool end_iter = false;
+ bool end_iter = false;
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if(end_iter) break;
+ if(end_iter) break;
- frameoffset_t distance;
- boost::shared_ptr<Region> r = (*i);
- framepos_t pos = 0;
+ frameoffset_t distance;
+ boost::shared_ptr<Region> r = (*i);
+ framepos_t pos = 0;
- switch (point) {
- case Start:
- pos = r->first_frame ();
- break;
- case End:
- pos = r->last_frame ();
- break;
- case SyncPoint:
- pos = r->sync_position ();
- break;
- }
+ switch (point) {
+ case Start:
+ pos = r->first_frame ();
+ break;
+ case End:
+ pos = r->last_frame ();
+ break;
+ case SyncPoint:
+ pos = r->sync_position ();
+ break;
+ }
- switch (dir) {
- case 1: /* forwards */
+ switch (dir) {
+ case 1: /* forwards */
- if (pos > frame) {
- if ((distance = pos - frame) < closest) {
- closest = distance;
- ret = r;
- end_iter = true;
- }
- }
+ if (pos > frame) {
+ if ((distance = pos - frame) < closest) {
+ closest = distance;
+ ret = r;
+ end_iter = true;
+ }
+ }
- break;
+ break;
- default: /* backwards */
+ default: /* backwards */
- if (pos < frame) {
- if ((distance = frame - pos) < closest) {
- closest = distance;
- ret = r;
- }
- }
- else {
- end_iter = true;
- }
+ if (pos < frame) {
+ if ((distance = frame - pos) < closest) {
+ closest = distance;
+ ret = r;
+ }
+ } else {
+ end_iter = true;
+ }
- break;
- }
- }
+ break;
+ }
+ }
- return ret;
- }
+ return ret;
+}
framepos_t
Playlist::find_next_region_boundary (framepos_t frame, int dir)
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
framepos_t closest = max_framepos;
framepos_t ret = -1;
void
Playlist::rdiff (vector<Command*>& cmds) const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionReadLock rlock (const_cast<Playlist *> (this));
Stateful::rdiff (cmds);
}
void
Playlist::clear_owned_changes ()
{
- RegionLock rlock (this);
+ RegionReadLock rlock (this);
Stateful::clear_owned_changes ();
}
freeze ();
/* add the added regions */
- for (RegionListProperty::ChangeContainer::iterator i = change.added.begin(); i != change.added.end(); ++i) {
+ for (RegionListProperty::ChangeContainer::const_iterator i = change.added.begin(); i != change.added.end(); ++i) {
add_region_internal ((*i), (*i)->position());
}
/* remove the removed regions */
- for (RegionListProperty::ChangeContainer::iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
+ for (RegionListProperty::ChangeContainer::const_iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
remove_region (*i);
}
}
{
- RegionLock rlock (this);
+ RegionWriteLock rlock (this);
add_region_internal (region, region->position());
}
-
+
region->resume_property_changes ();
}
if (seen_region_nodes && regions.empty()) {
ret = -1;
- } else {
-
- /* update dependents, which was not done during add_region_internal
- due to in_set_state being true
- */
-
- for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) {
- check_crossfades ((*r)->range ());
- }
}
-
+
thaw ();
notify_contents_changed ();
node->add_property (X_("frozen"), _frozen ? "yes" : "no");
if (full_state) {
- RegionLock rlock (this, false);
+ RegionReadLock rlock (this);
snprintf (buf, sizeof (buf), "%u", _combine_ops);
node->add_property ("combine-ops", buf);
bool
Playlist::empty() const
{
- RegionLock rlock (const_cast<Playlist *>(this), false);
+ RegionReadLock rlock (const_cast<Playlist *>(this));
return regions.empty();
}
uint32_t
Playlist::n_regions() const
{
- RegionLock rlock (const_cast<Playlist *>(this), false);
+ RegionReadLock rlock (const_cast<Playlist *>(this));
return regions.size();
}
+/** @return true if the all_regions list is empty, ie this playlist
+ * has never had a region added to it.
+ */
+bool
+Playlist::all_regions_empty() const
+{
+ RegionReadLock rl (const_cast<Playlist *> (this));
+ return all_regions.empty();
+}
+
pair<framepos_t, framepos_t>
Playlist::get_extent () const
{
- RegionLock rlock (const_cast<Playlist *>(this), false);
+ RegionReadLock rlock (const_cast<Playlist *>(this));
return _get_extent ();
}
+pair<framepos_t, framepos_t>
+Playlist::get_extent_with_endspace () const
+{
+ pair<framepos_t, framepos_t> l = get_extent();
+ l.second += _end_space;
+ return l;
+}
+
pair<framepos_t, framepos_t>
Playlist::_get_extent () const
{
layer_t
Playlist::top_layer() const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionReadLock rlock (const_cast<Playlist *> (this));
layer_t top = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
void
Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
{
- /* Remove the layer we are setting from our region list, and sort it */
+ /* Remove the layer we are setting from our region list, and sort it
+ * using the layer indeces.
+ */
+
RegionList copy = regions.rlist();
copy.remove (region);
copy.sort (RelayerSort ());
}
++i;
}
-
+
copy.insert (i, region);
setup_layering_indices (copy);
Playlist::setup_layering_indices (RegionList const & regions)
{
uint64_t j = 0;
- list<Evoral::Range<framepos_t> > xf;
for (RegionList::const_iterator k = regions.begin(); k != regions.end(); ++k) {
(*k)->set_layering_index (j++);
-
- Evoral::Range<framepos_t> r ((*k)->first_frame(), (*k)->last_frame());
- xf.push_back (r);
}
-
- /* now recheck the entire playlist for crossfades */
-
- coalesce_and_check_crossfades (xf);
}
+struct LaterHigherSort {
+ bool operator () (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
+ return a->position() < b->position();
+ }
+};
+
/** Take the layering indices of each of our regions, compute the layers
* that they should be on, and write the layers back to the regions.
*/
vector<vector<RegionList> > layers;
layers.push_back (vector<RegionList> (divisions));
- /* Sort our regions into layering index order */
+ /* Sort our regions into layering index order (for manual layering) or position order (for later is higher)*/
RegionList copy = regions.rlist();
- copy.sort (RelayerSort ());
+ switch (Config->get_layer_model()) {
+ case LaterHigher:
+ copy.sort (LaterHigherSort ());
+ break;
+ case Manual:
+ copy.sort (RelayerSort ());
+ break;
+ }
DEBUG_TRACE (DEBUG::Layering, "relayer() using:\n");
for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
notify_layering_changed ();
/* This relayer() may have been called as a result of a region removal, in which
- case we need to setup layering indices so account for the one that has just
+ case we need to setup layering indices to account for the one that has just
gone away.
*/
setup_layering_indices (copy);
_nudging = true;
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionWriteLock rlock (const_cast<Playlist *> (this));
for (i = regions.begin(); i != regions.end(); ++i) {
bool
Playlist::uses_source (boost::shared_ptr<const Source> src) const
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionReadLock rlock (const_cast<Playlist*> (this));
- for (set<boost::shared_ptr<Region> >::iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
+ for (set<boost::shared_ptr<Region> >::const_iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
if ((*r)->uses_source (src)) {
return true;
}
boost::shared_ptr<Region>
Playlist::find_region (const ID& id) const
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionReadLock rlock (const_cast<Playlist*> (this));
/* searches all regions currently in use by the playlist */
uint32_t
Playlist::region_use_count (boost::shared_ptr<Region> r) const
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionReadLock rlock (const_cast<Playlist*> (this));
uint32_t cnt = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
}
}
+ RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
+ for (RegionFactory::CompoundAssociations::iterator it = cassocs.begin(); it != cassocs.end(); ++it) {
+ /* check if region is used in a compound */
+ if (it->second == r) {
+ /* region is referenced as 'original' of a compound */
+ ++cnt;
+ break;
+ }
+ if (r->whole_file() && r->max_source_level() > 0) {
+ /* region itself ia a compound.
+ * the compound regions are not referenced -> check regions inside compound
+ */
+ const SourceList& sl = r->sources();
+ for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+ boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource>(*s);
+ if (!ps) continue;
+ if (ps->playlist()->region_use_count(it->first)) {
+ // break out of both loops
+ return ++cnt;
+ }
+ }
+ }
+ }
return cnt;
}
{
/* searches all regions ever added to this playlist */
- for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+ for (set<boost::shared_ptr<Region> >::const_iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
if ((*i)->id() == id) {
return *i;
}
_shuffling = true;
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionWriteLock rlock (const_cast<Playlist*> (this));
if (dir > 0) {
bool
Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionReadLock rlock (const_cast<Playlist*> (this));
if (regions.size() > 1) {
return true;
return false;
}
+void
+Playlist::ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+ ripple_locked (at, distance, exclude);
+}
+
void
Playlist::update_after_tempo_map_change ()
{
- RegionLock rlock (const_cast<Playlist*> (this));
+ RegionWriteLock rlock (const_cast<Playlist*> (this));
RegionList copy (regions.rlist());
freeze ();
void
Playlist::foreach_region (boost::function<void(boost::shared_ptr<Region>)> s)
{
- RegionLock rl (this, false);
+ RegionReadLock rl (this);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
s (*i);
}
bool
Playlist::has_region_at (framepos_t const p) const
{
- RegionLock (const_cast<Playlist *> (this));
+ RegionReadLock (const_cast<Playlist *> (this));
RegionList::const_iterator i = regions.begin ();
while (i != regions.end() && !(*i)->covers (p)) {
void
Playlist::remove_region_by_source (boost::shared_ptr<Source> s)
{
- RegionLock rl (this);
+ RegionWriteLock rl (this);
RegionList::iterator i = regions.begin();
while (i != regions.end()) {
framepos_t
Playlist::find_next_top_layer_position (framepos_t t) const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionReadLock rlock (const_cast<Playlist *> (this));
layer_t const top = top_layer ();
pl->in_partition = true;
- for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+ /* sort by position then layer.
+ * route_time_axis passes 'selected_regions' - which is not sorted.
+ * here we need the top-most first, then every layer's region sorted by position.
+ */
+ RegionList sorted(r);
+ sorted.sort(RegionSortByLayerAndPosition());
+
+ for (RegionList::const_iterator i = sorted.begin(); i != sorted.end(); ++i) {
/* copy the region */
/* make position relative to zero */
pl->add_region (copied_region, original_region->position() - earliest_position);
+ copied_region->set_layer (original_region->layer ());
/* use the maximum number of channels for any region */
}
boost::shared_ptr<Region> original (ca->second);
+ cassocs.erase(ca);
bool modified_region;
if (i == rl.begin()) {
for (vector<boost::shared_ptr<Region> >::iterator i = originals.begin(); i != originals.end(); ++i) {
add_region ((*i), (*i)->position());
+ set_layer((*i), (*i)->layer());
+ if (!RegionFactory::region_by_id((*i)->id())) {
+ RegionFactory::map_add(*i);
+ }
}
in_partition = false;
thaw ();
}
+void
+Playlist::fade_range (list<AudioRange>& ranges)
+{
+ for (list<AudioRange>::iterator r = ranges.begin(); r != ranges.end(); ++r) {
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ (*i)->fade_range ((*r).start, (*r).end);
+ }
+ }
+}
+
uint32_t
Playlist::max_source_level () const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionReadLock rlock (const_cast<Playlist *> (this));
uint32_t lvl = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
_orig_track_id = id;
}
+/** Take a list of ranges, coalesce any that can be coalesced, then call
+ * check_crossfades for each one.
+ */
void
Playlist::coalesce_and_check_crossfades (list<Evoral::Range<framepos_t> > ranges)
{
continue;
}
+ // XXX i->from can be > i->to - is this right? coverage() will return OverlapNone in this case
if (Evoral::coverage (i->from, i->to, j->from, j->to) != Evoral::OverlapNone) {
i->from = min (i->from, j->from);
i->to = max (i->to, j->to);
}
}
}
+}
- for (list<Evoral::Range<framepos_t> >::iterator i = ranges.begin(); i != ranges.end(); ++i) {
- check_crossfades (*i);
- }
+void
+Playlist::set_capture_insertion_in_progress (bool yn)
+{
+ _capture_insertion_underway = yn;
}