#include <algorithm>
#include <string>
-#include <boost/lexical_cast.hpp>
-
-#include "pbd/convert.h"
+#include "pbd/types_convert.h"
#include "pbd/stateful_diff_command.h"
+#include "pbd/strsplit.h"
#include "pbd/xml++.h"
#include "ardour/debug.h"
+#include "ardour/midi_region.h"
#include "ardour/playlist.h"
-#include "ardour/session.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/playlist_source.h"
#include "ardour/region.h"
#include "ardour/region_factory.h"
#include "ardour/region_sorters.h"
-#include "ardour/playlist_factory.h"
-#include "ardour/playlist_source.h"
-#include "ardour/transient_detector.h"
+#include "ardour/session.h"
#include "ardour/session_playlists.h"
#include "ardour/source_factory.h"
+#include "ardour/tempo.h"
+#include "ardour/transient_detector.h"
+#include "ardour/types_convert.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
code, so we can just store ID here.
*/
- node.add_property ("id", region->id().to_s ());
+ node.set_property ("id", region->id());
}
boost::shared_ptr<Region>
RegionListProperty::get_content_from_xml (XMLNode const & node) const
{
- XMLProperty const * prop = node.property ("id");
- assert (prop);
-
- PBD::ID id (prop->value ());
+ PBD::ID id;
+ if (!node.get_property ("id", id)) {
+ assert (false);
+ }
boost::shared_ptr<Region> ret = _playlist.region_by_id (id);
, _type(type)
{
#ifndef NDEBUG
- const XMLProperty* prop = node.property("type");
+ XMLProperty const * prop = node.property("type");
assert(!prop || DataType(prop->value()) == _type);
#endif
, regions (*this)
, _type(other->_type)
, _orig_track_id (other->_orig_track_id)
+ , _shared_with_ids (other->_shared_with_ids)
{
init (hide);
in_set_state--;
_splicing = other->_splicing;
+ _rippling = other->_rippling;
_nudging = other->_nudging;
_edit_mode = other->_edit_mode;
_frozen = other->_frozen;
}
-Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, framecnt_t cnt, string str, bool hide)
+Playlist::Playlist (boost::shared_ptr<const Playlist> other, samplepos_t start, samplecnt_t cnt, string str, bool hide)
: SessionObject(other->_session, str)
, regions (*this)
, _type(other->_type)
, _orig_track_id (other->_orig_track_id)
+ , _shared_with_ids (other->_shared_with_ids)
{
RegionReadLock rlock2 (const_cast<Playlist*> (other.get()));
- framepos_t end = start + cnt - 1;
+ samplepos_t end = start + cnt - 1;
init (hide);
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> new_region;
- frameoffset_t offset = 0;
- framepos_t position = 0;
- framecnt_t len = 0;
+ sampleoffset_t offset = 0;
+ samplepos_t position = 0;
+ samplecnt_t len = 0;
string new_name;
Evoral::OverlapType overlap;
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;
}
RegionReadLock rlock (const_cast<Playlist *> (this));
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- newlist.push_back (RegionFactory::create (*i, true));
+ newlist.push_back (RegionFactory::create (*i, true, true));
}
}
_refcnt = 0;
_hidden = hide;
_splicing = false;
+ _rippling = false;
_shuffling = false;
_nudging = false;
in_set_state = 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));
} else {
string t = _name.val().substr(dot_position + 1);
- try {
- _sort_id = boost::lexical_cast<int>(t);
- }
-
- catch (boost::bad_lexical_cast e) {
+ if (!string_to_uint32 (t, _sort_id)) {
_sort_id = 0;
}
}
void
Playlist::notify_region_moved (boost::shared_ptr<Region> r)
{
- Evoral::RangeMove<framepos_t> const move (r->last_position (), r->length (), r->position ());
+ Evoral::RangeMove<samplepos_t> const move (r->last_position (), r->length (), r->position ());
if (holding_state ()) {
} else {
- list< Evoral::RangeMove<framepos_t> > m;
+ list< Evoral::RangeMove<samplepos_t> > m;
m.push_back (move);
RangesMoved (m, false);
}
return;
}
- Evoral::Range<framepos_t> const extra (r->position(), r->last_position());
+ Evoral::Range<samplepos_t> const extra (r->position(), r->last_position());
if (holding_state ()) {
} else {
- list<Evoral::Range<framepos_t> > r;
+ list<Evoral::Range<samplepos_t> > r;
r.push_back (extra);
RegionsExtended (r);
/* trimmed shorter */
}
- Evoral::Range<framepos_t> const extra (r->position() + r->last_length(), r->position() + r->length());
+ Evoral::Range<samplepos_t> const extra (r->position() + r->last_length(), r->position() + r->length());
if (holding_state ()) {
} else {
- list<Evoral::Range<framepos_t> > r;
+ list<Evoral::Range<samplepos_t> > r;
r.push_back (extra);
RegionsExtended (r);
}
pending_contents_change = false;
RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
ContentsChanged (); /* EMIT SIGNAL */
+
}
}
// RegionSortByLayer cmp;
// pending_bounds.sort (cmp);
- list<Evoral::Range<framepos_t> > crossfade_ranges;
+ list<Evoral::Range<samplepos_t> > crossfade_ranges;
for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
crossfade_ranges.push_back ((*r)->last_range ());
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 ()
- {
- pending_adds.clear ();
- pending_removes.clear ();
- pending_bounds.clear ();
- pending_range_moves.clear ();
- pending_region_extensions.clear ();
- pending_contents_change = false;
- }
+void
+Playlist::clear_pending ()
+{
+ pending_adds.clear ();
+ pending_removes.clear ();
+ pending_bounds.clear ();
+ pending_range_moves.clear ();
+ pending_region_extensions.clear ();
+ pending_contents_change = false;
+ pending_layering = false;
+}
- /*************************************************************
+/*************************************************************
PLAYLIST OPERATIONS
- *************************************************************/
+*************************************************************/
/** 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)
- {
- RegionWriteLock rlock (this);
- times = fabs (times);
+void
+Playlist::add_region (boost::shared_ptr<Region> region, samplepos_t position, float times, bool auto_partition, int32_t sub_num, double quarter_note, bool for_music)
+{
+ RegionWriteLock rlock (this);
+ times = fabs (times);
- int itimes = (int) floor (times);
+ int itimes = (int) floor (times);
- framepos_t pos = position;
+ samplepos_t pos = position;
- if (times == 1 && auto_partition){
- partition(pos - 1, (pos + region->length()), true);
- }
+ if (times == 1 && auto_partition){
+ RegionList thawlist;
+ partition_internal (pos - 1, (pos + region->length()), true, thawlist);
+ for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+ (*i)->resume_property_changes ();
+ _session.add_command (new StatefulDiffCommand (*i));
+ }
+ }
- if (itimes >= 1) {
- add_region_internal (region, pos);
- set_layer (region, DBL_MAX);
- pos += region->length();
- --itimes;
- }
+ if (itimes >= 1) {
+ add_region_internal (region, pos, sub_num, quarter_note, for_music);
+ set_layer (region, DBL_MAX);
+ pos += region->length();
+ --itimes;
+ }
+ /* note that itimes can be zero if we being asked to just
+ insert a single fraction of the region.
+ */
- /* note that itimes can be zero if we being asked to just
- insert a single fraction of the region.
- */
+ for (int i = 0; i < itimes; ++i) {
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+ add_region_internal (copy, pos, sub_num);
+ set_layer (copy, DBL_MAX);
+ pos += region->length();
+ }
- for (int i = 0; i < itimes; ++i) {
- boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
- add_region_internal (copy, pos);
- set_layer (copy, DBL_MAX);
- pos += region->length();
- }
+ samplecnt_t length = 0;
- framecnt_t length = 0;
+ if (floor (times) != times) {
+ length = (samplecnt_t) floor (region->length() * (times - floor (times)));
+ string name;
+ RegionFactory::region_name (name, region->name(), false);
- if (floor (times) != times) {
- length = (framecnt_t) floor (region->length() * (times - floor (times)));
- string name;
- RegionFactory::region_name (name, region->name(), false);
+ {
+ PropertyList plist;
- {
- PropertyList plist;
+ plist.add (Properties::start, region->start());
+ plist.add (Properties::length, length);
+ plist.add (Properties::name, name);
+ plist.add (Properties::layer, region->layer());
- plist.add (Properties::start, region->start());
- plist.add (Properties::length, length);
- plist.add (Properties::name, name);
- plist.add (Properties::layer, region->layer());
+ boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
+ add_region_internal (sub, pos, sub_num);
+ set_layer (sub, DBL_MAX);
+ }
+ }
- boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
- add_region_internal (sub, pos);
- set_layer (sub, DBL_MAX);
- }
- }
+ possibly_splice_unlocked (position, (pos + length) - position, region);
+}
- possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
- }
+void
+Playlist::set_region_ownership ()
+{
+ RegionWriteLock rl (this);
+ RegionList::iterator i;
+ boost::weak_ptr<Playlist> pl (shared_from_this());
- void
- Playlist::set_region_ownership ()
- {
- RegionWriteLock rl (this);
- RegionList::iterator i;
- boost::weak_ptr<Playlist> pl (shared_from_this());
+ for (i = regions.begin(); i != regions.end(); ++i) {
+ (*i)->set_playlist (pl);
+ }
+}
- for (i = regions.begin(); i != regions.end(); ++i) {
- (*i)->set_playlist (pl);
- }
- }
+bool
+Playlist::add_region_internal (boost::shared_ptr<Region> region, samplepos_t position, int32_t sub_num, double quarter_note, bool for_music)
+{
+ if (region->data_type() != _type) {
+ return false;
+ }
- bool
- Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position)
- {
- if (region->data_type() != _type) {
- return false;
- }
+ RegionSortByPosition cmp;
- RegionSortByPosition cmp;
+ if (!first_set_state) {
+ boost::shared_ptr<Playlist> foo (shared_from_this());
+ region->set_playlist (boost::weak_ptr<Playlist>(foo));
+ }
+ if (for_music) {
+ region->set_position_music (quarter_note);
+ } else {
+ region->set_position (position, sub_num);
+ }
- if (!first_set_state) {
- boost::shared_ptr<Playlist> foo (shared_from_this());
- region->set_playlist (boost::weak_ptr<Playlist>(foo));
- }
+ regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
+ all_regions.insert (region);
- region->set_position (position);
+ possibly_splice_unlocked (position, region->length(), region);
- regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
- all_regions.insert (region);
+ if (!holding_state ()) {
+ /* layers get assigned from XML state, and are not reset during undo/redo */
+ relayer ();
+ }
- possibly_splice_unlocked (position, region->length(), region);
+ /* we need to notify the existence of new region before checking dependents. Ick. */
- if (!holding_state ()) {
- /* layers get assigned from XML state, and are not reset during undo/redo */
- relayer ();
- }
+ notify_region_added (region);
- /* we need to notify the existence of new region before checking dependents. Ick. */
+ region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+ region->DropReferences.connect_same_thread (region_drop_references_connections, boost::bind (&Playlist::region_going_away, this, boost::weak_ptr<Region> (region)));
- notify_region_added (region);
+ return true;
+}
- region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+void
+Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, samplepos_t pos)
+{
+ RegionWriteLock rlock (this);
- return true;
- }
+ bool old_sp = _splicing;
+ _splicing = true;
- void
- Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos)
- {
- RegionWriteLock rlock (this);
+ remove_region_internal (old);
+ add_region_internal (newr, pos);
+ set_layer (newr, old->layer ());
- bool old_sp = _splicing;
- _splicing = true;
+ _splicing = old_sp;
- remove_region_internal (old);
- add_region_internal (newr, pos);
- set_layer (newr, old->layer ());
+ possibly_splice_unlocked (pos, old->length() - newr->length());
+}
- _splicing = old_sp;
+void
+Playlist::remove_region (boost::shared_ptr<Region> region)
+{
+ RegionWriteLock rlock (this);
+ remove_region_internal (region);
+}
- possibly_splice_unlocked (pos, old->length() - newr->length());
- }
+int
+Playlist::remove_region_internal (boost::shared_ptr<Region> region)
+{
+ RegionList::iterator i;
- void
- Playlist::remove_region (boost::shared_ptr<Region> region)
- {
- RegionWriteLock rlock (this);
- remove_region_internal (region);
- }
+ if (!in_set_state) {
+ /* unset playlist */
+ region->set_playlist (boost::weak_ptr<Playlist>());
+ }
- int
- Playlist::remove_region_internal (boost::shared_ptr<Region> region)
- {
- RegionList::iterator i;
+ /* XXX should probably freeze here .... */
- if (!in_set_state) {
- /* unset playlist */
- region->set_playlist (boost::weak_ptr<Playlist>());
- }
+ for (i = regions.begin(); i != regions.end(); ++i) {
+ if (*i == region) {
- /* XXX should probably freeze here .... */
+ samplepos_t pos = (*i)->position();
+ samplecnt_t distance = (*i)->length();
- for (i = regions.begin(); i != regions.end(); ++i) {
- if (*i == region) {
+ regions.erase (i);
- framepos_t pos = (*i)->position();
- framecnt_t distance = (*i)->length();
+ possibly_splice_unlocked (pos, -distance);
- regions.erase (i);
+ if (!holding_state ()) {
+ relayer ();
+ remove_dependents (region);
+ }
- possibly_splice_unlocked (pos, -distance);
+ notify_region_removed (region);
+ break;
+ }
+ }
- if (!holding_state ()) {
- relayer ();
- remove_dependents (region);
- }
+ return -1;
+}
- notify_region_removed (region);
+void
+Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+{
+ switch (Config->get_region_equivalence()) {
+ case Exact:
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->exact_equivalent (other)) {
+ results.push_back (*i);
+ }
+ }
break;
- }
- }
-
- return -1;
- }
-
- void
- Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
- {
- if (Config->get_use_overlap_equivalency()) {
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if ((*i)->overlap_equivalent (other)) {
- results.push_back (*i);
+ case Enclosed:
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->enclosed_equivalent (other)) {
+ results.push_back (*i);
+ }
}
- }
- } else {
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if ((*i)->equivalent (other)) {
- results.push_back (*i);
+ break;
+ case Overlap:
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->overlap_equivalent (other)) {
+ results.push_back (*i);
+ }
}
- }
- }
- }
+ break;
+ }
+}
- void
- Playlist::get_region_list_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
- {
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+void
+Playlist::get_region_list_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)->region_list_equivalent (other)) {
- results.push_back (*i);
- }
- }
- }
+ if ((*i) && (*i)->region_list_equivalent (other)) {
+ results.push_back (*i);
+ }
+ }
+}
- 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) {
+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);
- }
- }
- }
+ if ((*i) && (*i)->any_source_equivalent (other)) {
+ results.push_back (*i);
+ }
+ }
+}
- void
- Playlist::partition (framepos_t start, framepos_t end, bool cut)
- {
- RegionList thawlist;
+void
+Playlist::partition (samplepos_t start, samplepos_t end, bool cut)
+{
+ RegionList thawlist;
+ {
+ RegionWriteLock lock(this);
+ partition_internal (start, end, cut, thawlist);
+ }
- partition_internal (start, end, cut, thawlist);
+ for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+ (*i)->resume_property_changes ();
+ }
+}
- for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
- (*i)->resume_property_changes ();
- }
- }
+/* If a MIDI region is locked to musical-time, Properties::start is ignored
+ * and _start is overwritten using Properties::start_beats in
+ * add_region_internal() -> Region::set_position() -> MidiRegion::set_position_internal()
+ */
+static void maybe_add_start_beats (TempoMap const& tm, PropertyList& plist, boost::shared_ptr<Region> r, samplepos_t start, samplepos_t end)
+{
+ boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(r);
+ if (!mr) {
+ return;
+ }
+ double delta_beats = tm.quarter_notes_between_samples (start, end);
+ plist.add (Properties::start_beats, mr->start_beats () + delta_beats);
+}
/** Go through each region on the playlist and cut them at start and end, removing the section between
* start and end if cutting == true. Regions that lie entirely within start and end are always
* removed.
*/
- void
- Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist)
- {
- RegionList new_regions;
+void
+Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, RegionList& thawlist)
+{
+ RegionList new_regions;
- {
- RegionWriteLock rlock (this);
+ {
+
+ boost::shared_ptr<Region> region;
+ boost::shared_ptr<Region> current;
+ string new_name;
+ RegionList::iterator tmp;
+ Evoral::OverlapType overlap;
+ samplepos_t pos1, pos2, pos3, pos4;
- boost::shared_ptr<Region> region;
- boost::shared_ptr<Region> current;
- string new_name;
- RegionList::iterator tmp;
- Evoral::OverlapType overlap;
- framepos_t pos1, pos2, pos3, pos4;
+ in_partition = true;
- in_partition = true;
+ /* need to work from a copy, because otherwise the regions we add during the process
+ get operated on as well.
+ */
- /* need to work from a copy, because otherwise the regions we add during the process
- get operated on as well.
- */
+ RegionList copy = regions.rlist();
- RegionList copy = regions.rlist();
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
- for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+ tmp = i;
+ ++tmp;
- tmp = i;
- ++tmp;
+ current = *i;
- current = *i;
+ if (current->first_sample() >= start && current->last_sample() < end) {
- if (current->first_frame() >= start && current->last_frame() < end) {
+ if (cutting) {
+ remove_region_internal (current);
+ }
- if (cutting) {
- remove_region_internal (current);
- }
+ continue;
+ }
- continue;
- }
+ /* coverage will return OverlapStart if the start coincides
+ with the end point. we do not partition such a region,
+ so catch this special case.
+ */
- /* 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_sample() >= end) {
+ continue;
+ }
- if (current->first_frame() >= end) {
- continue;
- }
+ if ((overlap = current->coverage (start, end)) == Evoral::OverlapNone) {
+ continue;
+ }
- if ((overlap = current->coverage (start, end)) == Evoral::OverlapNone) {
- continue;
- }
+ pos1 = current->position();
+ pos2 = start;
+ pos3 = end;
+ pos4 = current->last_sample();
+
+ if (overlap == Evoral::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
+ SPLIT:
+ ---------------*****++++++++++++++++====------------
+ CUT
+ ---------------*****----------------====------------
+
+ */
+
+ if (!cutting) {
+ /* "middle" ++++++ */
+
+ RegionFactory::region_name (new_name, current->name(), false);
+
+ PropertyList plist;
+
+ plist.add (Properties::start, current->start() + (pos2 - pos1));
+ plist.add (Properties::length, pos3 - pos2);
+ plist.add (Properties::name, new_name);
+ plist.add (Properties::layer, current->layer ());
+ plist.add (Properties::layering_index, current->layering_index ());
+ plist.add (Properties::automatic, true);
+ plist.add (Properties::left_of_split, true);
+ plist.add (Properties::right_of_split, true);
+ maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos2 - pos1));
+
+ /* see note in :_split_region()
+ * for MusicSample is needed to offset region-gain
+ */
+ region = RegionFactory::create (current, MusicSample (pos2 - pos1, 0), plist);
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
- pos1 = current->position();
- pos2 = start;
- pos3 = end;
- pos4 = current->last_frame();
-
- if (overlap == Evoral::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
- SPLIT:
- ---------------*****++++++++++++++++====------------
- CUT
- ---------------*****----------------====------------
-
- */
-
- if (!cutting) {
- /* "middle" ++++++ */
-
- RegionFactory::region_name (new_name, current->name(), false);
-
- PropertyList plist;
-
- plist.add (Properties::start, current->start() + (pos2 - pos1));
- plist.add (Properties::length, pos3 - pos2);
- plist.add (Properties::name, new_name);
- plist.add (Properties::layer, current->layer ());
- plist.add (Properties::layering_index, current->layering_index ());
- plist.add (Properties::automatic, true);
- plist.add (Properties::left_of_split, true);
- plist.add (Properties::right_of_split, true);
-
- region = RegionFactory::create (current, plist);
- add_region_internal (region, start);
- new_regions.push_back (region);
- }
+ /* "end" ====== */
- /* "end" ====== */
+ RegionFactory::region_name (new_name, current->name(), false);
- RegionFactory::region_name (new_name, current->name(), false);
+ PropertyList plist;
- PropertyList plist;
+ plist.add (Properties::start, current->start() + (pos3 - pos1));
+ plist.add (Properties::length, pos4 - pos3);
+ plist.add (Properties::name, new_name);
+ plist.add (Properties::layer, current->layer ());
+ plist.add (Properties::layering_index, current->layering_index ());
+ plist.add (Properties::automatic, true);
+ plist.add (Properties::right_of_split, true);
+ maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos3 - pos1));
- plist.add (Properties::start, current->start() + (pos3 - pos1));
- plist.add (Properties::length, pos4 - pos3);
- plist.add (Properties::name, new_name);
- plist.add (Properties::layer, current->layer ());
- plist.add (Properties::layering_index, current->layering_index ());
- plist.add (Properties::automatic, true);
- plist.add (Properties::right_of_split, true);
+ region = RegionFactory::create (current, MusicSample (pos3 - pos1, 0), plist);
- region = RegionFactory::create (current, plist);
+ add_region_internal (region, end);
+ new_regions.push_back (region);
- add_region_internal (region, end);
- new_regions.push_back (region);
+ /* "front" ***** */
- /* "front" ***** */
+ current->clear_changes ();
+ current->suspend_property_changes ();
+ thawlist.push_back (current);
+ current->cut_end (pos2 - 1);
- current->suspend_property_changes ();
- thawlist.push_back (current);
- current->cut_end (pos2 - 1);
+ } else if (overlap == Evoral::OverlapEnd) {
- } else if (overlap == Evoral::OverlapEnd) {
+ /*
+ start end
+ ---------------*************************------------
+ P1 P2 P4 P3
+ SPLIT:
+ ---------------**************+++++++++++------------
+ CUT:
+ ---------------**************-----------------------
+ */
- /*
- start end
- ---------------*************************------------
- P1 P2 P4 P3
- SPLIT:
- ---------------**************+++++++++++------------
- CUT:
- ---------------**************-----------------------
- */
+ if (!cutting) {
- if (!cutting) {
+ /* end +++++ */
- /* end +++++ */
+ RegionFactory::region_name (new_name, current->name(), false);
- RegionFactory::region_name (new_name, current->name(), false);
+ PropertyList plist;
- PropertyList plist;
+ plist.add (Properties::start, current->start() + (pos2 - pos1));
+ plist.add (Properties::length, pos4 - pos2);
+ plist.add (Properties::name, new_name);
+ plist.add (Properties::layer, current->layer ());
+ plist.add (Properties::layering_index, current->layering_index ());
+ plist.add (Properties::automatic, true);
+ plist.add (Properties::left_of_split, true);
+ maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos2 - pos1));
- plist.add (Properties::start, current->start() + (pos2 - pos1));
- plist.add (Properties::length, pos4 - pos2);
- plist.add (Properties::name, new_name);
- plist.add (Properties::layer, current->layer ());
- plist.add (Properties::layering_index, current->layering_index ());
- plist.add (Properties::automatic, true);
- plist.add (Properties::left_of_split, true);
+ region = RegionFactory::create (current, MusicSample(pos2 - pos1, 0), plist);
- region = RegionFactory::create (current, plist);
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
- add_region_internal (region, start);
- new_regions.push_back (region);
- }
+ /* front ****** */
- /* front ****** */
+ current->clear_changes ();
+ current->suspend_property_changes ();
+ thawlist.push_back (current);
+ current->cut_end (pos2 - 1);
- current->suspend_property_changes ();
- thawlist.push_back (current);
- current->cut_end (pos2 - 1);
+ } else if (overlap == Evoral::OverlapStart) {
- } else if (overlap == Evoral::OverlapStart) {
+ /* split: we need 2 regions: the front and the end.
+ cut: just trim current to skip the cut area
+ */
- /* 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
- /*
- start end
- ---------------*************************------------
- P2 P1 P3 P4
+ SPLIT:
+ ---------------****+++++++++++++++++++++------------
+ CUT:
+ -------------------*********************------------
- SPLIT:
- ---------------****+++++++++++++++++++++------------
- CUT:
- -------------------*********************------------
+ */
- */
+ if (!cutting) {
+ /* front **** */
+ RegionFactory::region_name (new_name, current->name(), false);
- if (!cutting) {
- /* front **** */
- RegionFactory::region_name (new_name, current->name(), false);
+ PropertyList plist;
- PropertyList plist;
+ plist.add (Properties::start, current->start());
+ plist.add (Properties::length, pos3 - pos1);
+ plist.add (Properties::name, new_name);
+ plist.add (Properties::layer, current->layer ());
+ plist.add (Properties::layering_index, current->layering_index ());
+ plist.add (Properties::automatic, true);
+ plist.add (Properties::right_of_split, true);
+ maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start());
- plist.add (Properties::start, current->start());
- plist.add (Properties::length, pos3 - pos1);
- plist.add (Properties::name, new_name);
- plist.add (Properties::layer, current->layer ());
- plist.add (Properties::layering_index, current->layering_index ());
- plist.add (Properties::automatic, true);
- plist.add (Properties::right_of_split, true);
+ region = RegionFactory::create (current, plist);
- region = RegionFactory::create (current, plist);
+ add_region_internal (region, pos1);
+ new_regions.push_back (region);
+ }
- add_region_internal (region, pos1);
- new_regions.push_back (region);
- }
+ /* end */
- /* end */
+ current->clear_changes ();
+ current->suspend_property_changes ();
+ thawlist.push_back (current);
+ current->trim_front (pos3);
+ } else if (overlap == Evoral::OverlapExternal) {
- current->suspend_property_changes ();
- thawlist.push_back (current);
- current->trim_front (pos3);
- } else if (overlap == Evoral::OverlapExternal) {
+ /* split: no split required.
+ cut: remove the region.
+ */
- /* split: no split required.
- cut: remove the region.
- */
+ /*
+ start end
+ ---------------*************************------------
+ P2 P1 P3 P4
- /*
- start end
- ---------------*************************------------
- P2 P1 P3 P4
+ SPLIT:
+ ---------------*************************------------
+ CUT:
+ ----------------------------------------------------
- SPLIT:
- ---------------*************************------------
- 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;
- }
- }
+ //keep track of any dead space at end (for pasting into Ripple or Splice mode)
+ samplepos_t wanted_length = end-start;
+ _end_space = wanted_length - _get_extent().second - _get_extent().first;
+}
-
boost::shared_ptr<Playlist>
-
Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t, framecnt_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
- {
-
boost::shared_ptr<Playlist> ret;
-
boost::shared_ptr<Playlist> pl;
- framepos_t start;
+boost::shared_ptr<Playlist>
+
Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(samplepos_t, samplecnt_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
+{
+ boost::shared_ptr<Playlist> ret;
+ boost::shared_ptr<Playlist> pl;
+ samplepos_t start;
- if (ranges.empty()) {
-
return boost::shared_ptr<Playlist>();
- }
+ if (ranges.empty()) {
+ return boost::shared_ptr<Playlist>();
+ }
- start = ranges.front().start;
+ start = ranges.front().start;
-
for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
- pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
+ pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
- if (i == ranges.begin()) {
- ret = pl;
- } else {
+ if (i == ranges.begin()) {
+ ret = pl;
+ } else {
- /* paste the next section into the nascent playlist,
- offset to reflect the start of the first range we
- chopped.
- */
+ /* paste the next section into the nascent playlist,
+ offset to reflect the start of the first range we
+ chopped.
+ */
+
+ ret->paste (pl, (*i).start - start, 1.0f, 0);
+ }
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<Playlist>
+Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
+{
+ boost::shared_ptr<Playlist> (Playlist::*pmf)(samplepos_t,samplecnt_t,bool) = &Playlist::cut;
+ return cut_copy (pmf, ranges, result_is_hidden);
+}
+
+boost::shared_ptr<Playlist>
+Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
+{
+ boost::shared_ptr<Playlist> (Playlist::*pmf)(samplepos_t,samplecnt_t,bool) = &Playlist::copy;
+ return cut_copy (pmf, ranges, result_is_hidden);
+}
+
+boost::shared_ptr<Playlist>
+Playlist::cut (samplepos_t start, samplecnt_t cnt, bool result_is_hidden)
+{
+ boost::shared_ptr<Playlist> the_copy;
+ RegionList thawlist;
+ char buf[32];
+
+ snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
+ string new_name = _name;
+ new_name += '.';
+ new_name += buf;
+
+ if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
+ return boost::shared_ptr<Playlist>();
+ }
+
+ {
+ RegionWriteLock rlock (this);
+ partition_internal (start, start+cnt-1, true, thawlist);
+ }
+
+ for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+ (*i)->resume_property_changes();
+ }
+
+ return the_copy;
+}
- ret->paste (pl, (*i).start - start, 1.0f);
- }
- }
+boost::shared_ptr<Playlist>
+Playlist::copy (samplepos_t start, samplecnt_t cnt, bool result_is_hidden)
+{
+ char buf[32];
- return ret;
- }
+ snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
+ string new_name = _name;
+ new_name += '.';
+ new_name += buf;
- boost::shared_ptr<Playlist>
- Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
- {
- boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::cut;
- return cut_copy (pmf, ranges, result_is_hidden);
- }
+ // 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... )
- boost::shared_ptr<Playlist>
- Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
- {
- boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::copy;
- return cut_copy (pmf, ranges, result_is_hidden);
- }
+ return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
+}
- boost::shared_ptr<Playlist>
- Playlist::cut (framepos_t start, framecnt_t cnt, bool result_is_hidden)
- {
- boost::shared_ptr<Playlist> the_copy;
- RegionList thawlist;
- char buf[32];
+int
+Playlist::paste (boost::shared_ptr<Playlist> other, samplepos_t position, float times, const int32_t sub_num)
+{
+ times = fabs (times);
- snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
- string new_name = _name;
- new_name += '.';
- new_name += buf;
+ {
+ RegionReadLock rl2 (other.get());
- if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
- return boost::shared_ptr<Playlist>();
- }
+ int itimes = (int) floor (times);
+ samplepos_t pos = position;
+ samplecnt_t const shift = other->_get_extent().second;
+ layer_t top = top_layer ();
- partition_internal (start, start+cnt-1, true, thawlist);
+ {
+ 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);
- for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
- (*i)->resume_property_changes();
- }
+ /* put these new regions on top of all existing ones, but preserve
+ the ordering they had in the original playlist.
+ */
- return the_copy;
- }
+ add_region_internal (copy_of_region, (*i)->position() + pos, sub_num);
+ set_layer (copy_of_region, copy_of_region->layer() + top);
+ }
+ pos += shift;
+ }
+ }
+ }
- boost::shared_ptr<Playlist>
- Playlist::copy (framepos_t start, framecnt_t cnt, bool result_is_hidden)
- {
- char buf[32];
+ return 0;
+}
- snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
- string new_name = _name;
- new_name += '.';
- new_name += buf;
- cnt = min (_get_extent().second - start, cnt);
- return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
- }
+void
+Playlist::duplicate (boost::shared_ptr<Region> region, samplepos_t position, float times)
+{
+ duplicate(region, position, region->length(), times);
+}
- int
- Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times)
- {
- times = fabs (times);
+/** @param gap from the beginning of the region to the next beginning */
+void
+Playlist::duplicate (boost::shared_ptr<Region> region, samplepos_t position, samplecnt_t gap, float times)
+{
+ times = fabs (times);
- {
- RegionReadLock rl2 (other.get());
+ RegionWriteLock rl (this);
+ int itimes = (int) floor (times);
- int itimes = (int) floor (times);
- framepos_t pos = position;
- framecnt_t const shift = other->_get_extent().second;
- layer_t top = top_layer ();
+ while (itimes--) {
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+ add_region_internal (copy, position);
+ set_layer (copy, DBL_MAX);
+ position += gap;
+ }
- {
- 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.
- */
-
- add_region_internal (copy_of_region, (*i)->position() + pos);
- set_layer (copy_of_region, copy_of_region->layer() + top);
- }
- pos += shift;
- }
- }
- }
+ if (floor (times) != times) {
+ samplecnt_t length = (samplecnt_t) floor (region->length() * (times - floor (times)));
+ string name;
+ RegionFactory::region_name (name, region->name(), false);
- return 0;
- }
+ {
+ PropertyList plist;
+ plist.add (Properties::start, region->start());
+ plist.add (Properties::length, length);
+ plist.add (Properties::name, name);
- void
- Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
- {
- times = fabs (times);
+ boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
+ 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 sample that does _not_ contain a duplicated sample */
+void
+Playlist::duplicate_until (boost::shared_ptr<Region> region, samplepos_t position, samplecnt_t gap, samplepos_t end)
+{
RegionWriteLock rl (this);
- int itimes = (int) floor (times);
- framepos_t pos = position + 1;
- while (itimes--) {
+ while (position + region->length() - 1 < end) {
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) {
- framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times)));
+ if (position < end) {
+ samplecnt_t length = min (region->length(), end - position);
string name;
RegionFactory::region_name (name, region->name(), false);
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::duplicate_range (AudioRange& range, float times)
+{
+ boost::shared_ptr<Playlist> pl = copy (range.start, range.length(), true);
+ samplecnt_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;
+ }
+
+ samplepos_t min_pos = max_samplepos;
+ samplepos_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);
+ }
+
+ samplecnt_t offset = max_pos - min_pos;
+
+ int count = 1;
+ int itimes = (int) floor (times);
+ while (itimes--) {
+ 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 * count), 1.0f, 0);
+ }
+ ++count;
+ }
+}
void
- Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
+ Playlist::shift (samplepos_t at, sampleoffset_t distance, bool move_intersected, bool ignore_music_glue)
{
RegionWriteLock rlock (this);
RegionList copy (regions.rlist());
for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
- if ((*r)->last_frame() < at) {
+ if ((*r)->last_sample() < at) {
/* too early */
continue;
}
- if (at > (*r)->first_frame() && at < (*r)->last_frame()) {
+ if (at > (*r)->first_sample() && at < (*r)->last_sample()) {
/* intersected region */
if (!move_intersected) {
continue;
/* 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 (const MusicSample& at)
{
RegionWriteLock rlock (this);
RegionList copy (regions.rlist());
}
void
- Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::split_region (boost::shared_ptr<Region> region, const MusicSample& playlist_position)
{
RegionWriteLock rl (this);
_split_region (region, playlist_position);
}
void
- Playlist::_split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::_split_region (boost::shared_ptr<Region> region, const MusicSample& playlist_position)
{
- if (!region->covers (playlist_position)) {
+ if (!region->covers (playlist_position.sample)) {
return;
}
- if (region->position() == playlist_position ||
- region->last_frame() == playlist_position) {
+ if (region->position() == playlist_position.sample ||
+ region->last_sample() == playlist_position.sample) {
return;
}
boost::shared_ptr<Region> left;
boost::shared_ptr<Region> right;
- frameoffset_t before;
- frameoffset_t after;
+
+ MusicSample before (playlist_position.sample - region->position(), playlist_position.division);
+ MusicSample after (region->length() - before.sample, 0);
string before_name;
string after_name;
bool old_sp = _splicing;
_splicing = true;
- before = playlist_position - region->position();
- after = region->length() - before;
-
RegionFactory::region_name (before_name, region->name(), false);
{
PropertyList plist;
- plist.add (Properties::position, region->position ());
- plist.add (Properties::length, before);
+ plist.add (Properties::length, before.sample);
plist.add (Properties::name, before_name);
plist.add (Properties::left_of_split, true);
plist.add (Properties::layering_index, region->layering_index ());
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, MusicSample (0, 0), plist, true);
}
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::length, after.sample);
plist.add (Properties::name, after_name);
plist.add (Properties::right_of_split, true);
plist.add (Properties::layering_index, region->layering_index ());
plist.add (Properties::layer, region->layer ());
/* same note as above */
- right = RegionFactory::create (region, before, plist);
+ right = RegionFactory::create (region, before, plist, true);
}
- add_region_internal (left, region->position());
- add_region_internal (right, region->position() + before);
+ add_region_internal (left, region->position(), 0);
+ add_region_internal (right, region->position() + before.sample, before.division);
+
remove_region_internal (region);
_splicing = old_sp;
}
+void
+Playlist::AddToSoloSelectedList(const Region* r)
+{
+ _soloSelectedRegions.insert (r);
+}
+
+
+void
+Playlist::RemoveFromSoloSelectedList(const Region* r)
+{
+ _soloSelectedRegions.erase (r);
+}
+
+
+bool
+Playlist::SoloSelectedListIncludes(const Region* r)
+{
+ std::set<const Region*>::iterator i = _soloSelectedRegions.find(r);
+
+ return ( i != _soloSelectedRegions.end() );
+}
+
+bool
+Playlist::SoloSelectedActive()
+{
+ return !_soloSelectedRegions.empty();
+}
+
+
void
- Playlist::possibly_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
+ Playlist::possibly_splice (samplepos_t at, samplecnt_t distance, boost::shared_ptr<Region> exclude)
{
if (_splicing || in_set_state) {
/* don't respond to splicing moves or state setting */
}
void
- Playlist::possibly_splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
+ Playlist::possibly_splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_ptr<Region> exclude)
{
if (_splicing || in_set_state) {
/* don't respond to splicing moves or state setting */
}
void
- Playlist::splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
+ Playlist::splice_locked (samplepos_t at, samplecnt_t distance, boost::shared_ptr<Region> exclude)
{
{
RegionWriteLock rl (this);
}
void
- Playlist::splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
+ Playlist::splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_ptr<Region> exclude)
{
core_splice (at, distance, exclude);
}
void
- Playlist::core_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
+ Playlist::core_splice (samplepos_t at, samplecnt_t distance, boost::shared_ptr<Region> exclude)
{
_splicing = true;
}
if ((*i)->position() >= at) {
- framepos_t new_pos = (*i)->position() + distance;
+ samplepos_t new_pos = (*i)->position() + distance;
if (new_pos < 0) {
new_pos = 0;
- } else if (new_pos >= max_framepos - (*i)->length()) {
- new_pos = max_framepos - (*i)->length();
+ } else if (new_pos >= max_samplepos - (*i)->length()) {
+ new_pos = max_samplepos - (*i)->length();
}
(*i)->set_position (new_pos);
_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 (samplepos_t at, samplecnt_t distance, RegionList *exclude)
+{
+ {
+ RegionWriteLock rl (this);
+ core_ripple (at, distance, exclude);
+ }
+}
+
+void
+Playlist::ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList *exclude)
+{
+ core_ripple (at, distance, exclude);
+}
+
+void
+Playlist::core_ripple (samplepos_t at, samplecnt_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) {
+ samplepos_t new_pos = (*i)->position() + distance;
+ samplepos_t limit = max_samplepos - (*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;
}
if (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) {
- frameoffset_t delta = 0;
+ sampleoffset_t delta = 0;
if (what_changed.contains (Properties::position)) {
delta = region->position() - region->last_position();
} else {
notify_contents_changed ();
relayer ();
- list<Evoral::Range<framepos_t> > xf;
- xf.push_back (Evoral::Range<framepos_t> (region->last_range()));
- xf.push_back (Evoral::Range<framepos_t> (region->range()));
+ list<Evoral::Range<samplepos_t> > xf;
+ xf.push_back (Evoral::Range<samplepos_t> (region->last_range()));
+ xf.push_back (Evoral::Range<samplepos_t> (region->range()));
coalesce_and_check_crossfades (xf);
}
}
save = true;
}
+ mark_session_dirty ();
+
return save;
}
RegionWriteLock rl (this);
region_state_changed_connections.drop_connections ();
+ region_drop_references_connections.drop_connections ();
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
pending_removes.insert (*i);
}
- /***********************************************************************
+ /* *********************************************************************
FINDING THINGS
**********************************************************************/
boost::shared_ptr<RegionList>
-Playlist::regions_at (framepos_t frame)
+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 (samplepos_t sample)
{
RegionReadLock rlock (this);
- return find_regions_at (frame);
+ return find_regions_at (sample);
}
uint32_t
- Playlist::count_regions_at (framepos_t frame) const
+ Playlist::count_regions_at (samplepos_t sample) const
{
RegionReadLock rlock (const_cast<Playlist*>(this));
uint32_t cnt = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- if ((*i)->covers (frame)) {
+ if ((*i)->covers (sample)) {
cnt++;
}
}
}
boost::shared_ptr<Region>
- Playlist::top_region_at (framepos_t frame)
+ Playlist::top_region_at (samplepos_t sample)
{
RegionReadLock rlock (this);
- boost::shared_ptr<RegionList> rlist = find_regions_at (frame);
+ boost::shared_ptr<RegionList> rlist = find_regions_at (sample);
boost::shared_ptr<Region> region;
if (rlist->size()) {
}
boost::shared_ptr<Region>
- Playlist::top_unmuted_region_at (framepos_t frame)
+ Playlist::top_unmuted_region_at (samplepos_t sample)
{
RegionReadLock rlock (this);
- boost::shared_ptr<RegionList> rlist = find_regions_at (frame);
+ boost::shared_ptr<RegionList> rlist = find_regions_at (sample);
for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
RegionList::iterator tmp = i;
+
++tmp;
if ((*i)->muted()) {
}
boost::shared_ptr<RegionList>
-Playlist::find_regions_at (framepos_t frame)
+Playlist::find_regions_at (samplepos_t sample)
{
/* 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)) {
+ if ((*i)->covers (sample)) {
rlist->push_back (*i);
}
}
-
+
return rlist;
}
boost::shared_ptr<RegionList>
-Playlist::regions_with_start_within (Evoral::Range<framepos_t> range)
+Playlist::regions_with_start_within (Evoral::Range<samplepos_t> range)
{
RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist (new RegionList);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if ((*i)->first_frame() >= range.from && (*i)->first_frame() <= range.to) {
+ if ((*i)->first_sample() >= range.from && (*i)->first_sample() <= range.to) {
rlist->push_back (*i);
}
}
}
boost::shared_ptr<RegionList>
-Playlist::regions_with_end_within (Evoral::Range<framepos_t> range)
+Playlist::regions_with_end_within (Evoral::Range<samplepos_t> range)
{
RegionReadLock rlock (this);
boost::shared_ptr<RegionList> rlist (new RegionList);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if ((*i)->last_frame() >= range.from && (*i)->last_frame() <= range.to) {
+ if ((*i)->last_sample() >= range.from && (*i)->last_sample() <= range.to) {
rlist->push_back (*i);
}
}
* @return regions which have some part within this range.
*/
boost::shared_ptr<RegionList>
-Playlist::regions_touched (framepos_t start, framepos_t end)
+Playlist::regions_touched (samplepos_t start, samplepos_t end)
{
RegionReadLock rlock (this);
return regions_touched_locked (start, end);
}
boost::shared_ptr<RegionList>
-Playlist::regions_touched_locked (framepos_t start, framepos_t end)
+Playlist::regions_touched_locked (samplepos_t start, samplepos_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)
+samplepos_t
+Playlist::find_next_transient (samplepos_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) {
+ if ((*i)->last_sample() < from) {
continue;
}
} else {
- if ((*i)->first_frame() > from) {
+ if ((*i)->first_sample() > from) {
continue;
}
}
-
+
(*i)->get_transients (these_points);
-
- /* add first frame, just, err, because */
-
- these_points.push_back ((*i)->first_frame());
-
+
+ /* add first sample, just, err, because */
+
+ these_points.push_back ((*i)->first_sample());
+
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);
+
+ TransientDetector::cleanup_transients (points, _session.sample_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;
}
boost::shared_ptr<Region>
-Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
+Playlist::find_next_region (samplepos_t sample, RegionPoint point, int dir)
{
RegionReadLock rlock (this);
boost::shared_ptr<Region> ret;
- framepos_t closest = max_framepos;
-
+ samplepos_t closest = max_samplepos;
+
bool end_iter = false;
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-
+
if(end_iter) break;
-
- frameoffset_t distance;
+
+ sampleoffset_t distance;
boost::shared_ptr<Region> r = (*i);
- framepos_t pos = 0;
-
+ samplepos_t pos = 0;
+
switch (point) {
case Start:
- pos = r->first_frame ();
+ pos = r->first_sample ();
break;
case End:
- pos = r->last_frame ();
+ pos = r->last_sample ();
break;
case SyncPoint:
pos = r->sync_position ();
break;
}
-
+
switch (dir) {
case 1: /* forwards */
-
- if (pos > frame) {
- if ((distance = pos - frame) < closest) {
+
+ if (pos > sample) {
+ if ((distance = pos - sample) < closest) {
closest = distance;
ret = r;
end_iter = true;
}
}
-
+
break;
-
+
default: /* backwards */
-
- if (pos < frame) {
- if ((distance = frame - pos) < closest) {
+
+ if (pos < sample) {
+ if ((distance = sample - pos) < closest) {
closest = distance;
ret = r;
}
} else {
end_iter = true;
}
-
+
break;
}
}
-
+
return ret;
}
- framepos_t
- Playlist::find_next_region_boundary (framepos_t frame, int dir)
+ samplepos_t
+ Playlist::find_next_region_boundary (samplepos_t sample, int dir)
{
RegionReadLock rlock (this);
- framepos_t closest = max_framepos;
- framepos_t ret = -1;
+ samplepos_t closest = max_samplepos;
+ samplepos_t ret = -1;
if (dir > 0) {
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
boost::shared_ptr<Region> r = (*i);
- frameoffset_t distance;
+ sampleoffset_t distance;
+ const samplepos_t first_sample = r->first_sample();
+ const samplepos_t last_sample = r->last_sample();
- if (r->first_frame() > frame) {
+ if (first_sample > sample) {
- distance = r->first_frame() - frame;
+ distance = first_sample - sample;
if (distance < closest) {
- ret = r->first_frame();
+ ret = first_sample;
closest = distance;
}
}
- if (r->last_frame () > frame) {
+ if (last_sample > sample) {
- distance = r->last_frame () - frame;
+ distance = last_sample - sample;
if (distance < closest) {
- ret = r->last_frame ();
+ ret = last_sample;
closest = distance;
}
}
for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) {
boost::shared_ptr<Region> r = (*i);
- frameoffset_t distance;
+ sampleoffset_t distance;
+ const samplepos_t first_sample = r->first_sample();
+ const samplepos_t last_sample = r->last_sample();
- if (r->last_frame() < frame) {
+ if (last_sample < sample) {
- distance = frame - r->last_frame();
+ distance = sample - last_sample;
if (distance < closest) {
- ret = r->last_frame();
+ ret = last_sample;
closest = distance;
}
}
- if (r->first_frame() < frame) {
+ if (first_sample < sample) {
- distance = frame - r->first_frame();
+ distance = sample - first_sample;
if (distance < closest) {
- ret = r->first_frame();
+ ret = first_sample;
closest = distance;
}
}
XMLNode *child;
XMLNodeList nlist;
XMLNodeConstIterator niter;
- XMLPropertyList plist;
XMLPropertyConstIterator piter;
- XMLProperty *prop;
boost::shared_ptr<Region> region;
string region_name;
bool seen_region_nodes = false;
freeze ();
- plist = node.properties();
-
set_id (node);
- for (piter = plist.begin(); piter != plist.end(); ++piter) {
-
- prop = *piter;
-
- if (prop->name() == X_("name")) {
- _name = prop->value();
- _set_sort_id ();
- } else if (prop->name() == X_("orig-diskstream-id")) {
- /* XXX legacy session: fix up later */
- _orig_track_id = prop->value ();
- } else if (prop->name() == X_("orig-track-id")) {
- _orig_track_id = prop->value ();
- } else if (prop->name() == X_("frozen")) {
- _frozen = string_is_affirmative (prop->value());
- } else if (prop->name() == X_("combine-ops")) {
- _combine_ops = atoi (prop->value());
+ std::string name;
+ if (node.get_property (X_("name"), name)) {
+ _name = name;
+ _set_sort_id ();
+ }
+
+ /* XXX legacy session: fix up later */
+ node.get_property (X_("orig-diskstream-id"), _orig_track_id);
+
+ node.get_property (X_("orig-track-id"), _orig_track_id);
+ node.get_property (X_("frozen"), _frozen);
+
+ node.get_property (X_("combine-ops"), _combine_ops);
+
+ string shared_ids;
+ if (node.get_property (X_("shared-with-ids"), shared_ids)) {
+ if (!shared_ids.empty()) {
+ vector<string> result;
+ ::split (shared_ids, result, ',');
+ vector<string>::iterator it = result.begin();
+ for (; it != result.end(); ++it) {
+ _shared_with_ids.push_back (PBD::ID(*it));
+ }
}
}
seen_region_nodes = true;
- if ((prop = child->property ("id")) == 0) {
+ ID id;
+ if (!child->get_property ("id", id)) {
error << _("region state node has no ID, ignored") << endmsg;
continue;
}
- ID id = prop->value ();
-
if ((region = region_by_id (id))) {
region->suspend_property_changes ();
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 ();
Playlist::state (bool full_state)
{
XMLNode *node = new XMLNode (X_("Playlist"));
- char buf[64];
- node->add_property (X_("id"), id().to_s());
- node->add_property (X_("name"), _name);
- node->add_property (X_("type"), _type.to_string());
+ node->set_property (X_("id"), id());
+ node->set_property (X_("name"), name());
+ node->set_property (X_("type"), _type);
+ node->set_property (X_("orig-track-id"), _orig_track_id);
+
+ string shared_ids;
+ list<PBD::ID>::const_iterator it = _shared_with_ids.begin();
+ for (; it != _shared_with_ids.end(); ++it) {
+ shared_ids += "," + (*it).to_s();
+ }
+ if (!shared_ids.empty()) {
+ shared_ids.erase(0,1);
+ }
- _orig_track_id.print (buf, sizeof (buf));
- node->add_property (X_("orig-track-id"), buf);
- node->add_property (X_("frozen"), _frozen ? "yes" : "no");
+ node->set_property (X_("shared-with-ids"), shared_ids);
+ node->set_property (X_("frozen"), _frozen);
if (full_state) {
RegionReadLock rlock (this);
- snprintf (buf, sizeof (buf), "%u", _combine_ops);
- node->add_property ("combine-ops", buf);
+ node->set_property ("combine-ops", _combine_ops);
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
node->add_child_nocopy ((*i)->get_state());
return all_regions.empty();
}
-pair<framepos_t, framepos_t>
+pair<samplepos_t, samplepos_t>
Playlist::get_extent () const
{
RegionReadLock rlock (const_cast<Playlist *>(this));
return _get_extent ();
}
-pair<framepos_t, framepos_t>
+pair<samplepos_t, samplepos_t>
+Playlist::get_extent_with_endspace () const
+{
+ pair<samplepos_t, samplepos_t> l = get_extent();
+ l.second += _end_space;
+ return l;
+}
+
+pair<samplepos_t, samplepos_t>
Playlist::_get_extent () const
{
- pair<framepos_t, framepos_t> ext (max_framepos, 0);
+ pair<samplepos_t, samplepos_t> ext (max_samplepos, 0);
if (regions.empty()) {
ext.first = 0;
}
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- pair<framepos_t, framepos_t> const e ((*i)->position(), (*i)->position() + (*i)->length());
+ pair<samplepos_t, samplepos_t> const e ((*i)->position(), (*i)->position() + (*i)->length());
if (e.first < ext.first) {
ext.first = e.first;
}
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++);
}
}
+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.
*/
int const divisions = 512;
/* find the start and end positions of the regions on this playlist */
- framepos_t start = INT64_MAX;
- framepos_t end = 0;
+ samplepos_t start = INT64_MAX;
+ samplepos_t end = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
start = min (start, (*i)->position());
end = max (end, (*i)->position() + (*i)->length());
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) {
}
void
-Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards)
+Playlist::nudge_after (samplepos_t start, samplecnt_t distance, bool forwards)
{
RegionList::iterator i;
bool moved = false;
if ((*i)->position() >= start) {
- framepos_t new_pos;
+ samplepos_t new_pos;
if (forwards) {
- if ((*i)->last_frame() > max_framepos - distance) {
- new_pos = max_framepos - (*i)->length();
+ if ((*i)->last_sample() > max_samplepos - distance) {
+ new_pos = max_samplepos - (*i)->length();
} else {
new_pos = (*i)->position() + distance;
}
}
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
{
}
}
+ 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;
}
break;
}
- framepos_t new_pos;
+ samplepos_t new_pos;
- if ((*next)->position() != region->last_frame() + 1) {
+ if ((*next)->position() != region->last_sample() + 1) {
/* they didn't used to touch, so after shuffle,
just have them swap positions.
*/
break;
}
- framepos_t new_pos;
- if (region->position() != (*prev)->last_frame() + 1) {
+ samplepos_t new_pos;
+ if (region->position() != (*prev)->last_sample() + 1) {
/* they didn't used to touch, so after shuffle,
just have them swap positions.
*/
return false;
}
+void
+Playlist::ripple (samplepos_t at, samplecnt_t distance, RegionList *exclude)
+{
+ ripple_locked (at, distance, exclude);
+}
+
void
Playlist::update_after_tempo_map_change ()
{
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);
}
}
bool
-Playlist::has_region_at (framepos_t const p) const
+Playlist::has_region_at (samplepos_t const p) const
{
RegionReadLock (const_cast<Playlist *> (this));
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
+/** Look from a session sample 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.
- * @return Position of next top-layered region, or max_framepos if there isn't one.
+ * @return Position of next top-layered region, or max_samplepos if there isn't one.
*/
-framepos_t
-Playlist::find_next_top_layer_position (framepos_t t) const
+samplepos_t
+Playlist::find_next_top_layer_position (samplepos_t t) const
{
RegionReadLock rlock (const_cast<Playlist *> (this));
}
}
- return max_framepos;
+ return max_samplepos;
}
boost::shared_ptr<Region>
PropertyList plist;
uint32_t channels = 0;
uint32_t layer = 0;
- framepos_t earliest_position = max_framepos;
+ samplepos_t earliest_position = max_samplepos;
vector<TwoRegions> old_and_new_regions;
vector<boost::shared_ptr<Region> > originals;
vector<boost::shared_ptr<Region> > copies;
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 */
/* now create a new PlaylistSource for each channel in the new playlist */
SourceList sources;
- pair<framepos_t,framepos_t> extent = pl->get_extent();
+ pair<samplepos_t,samplepos_t> extent = pl->get_extent();
for (uint32_t chn = 0; chn < channels; ++chn) {
sources.push_back (SourceFactory::createFromPlaylist (_type, _session, pl, id(), parent_name, chn, 0, extent.second, false, false));
pl = pls->playlist();
- framepos_t adjusted_start = 0; // gcc isn't smart enough
- framepos_t adjusted_end = 0; // gcc isn't smart enough
+ samplepos_t adjusted_start = 0; // gcc isn't smart enough
+ samplepos_t adjusted_end = 0; // gcc isn't smart enough
/* the leftmost (earliest) edge of the compound region
starts at zero in its source, or larger if it
// (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;
+ sampleoffset_t move_offset = 0;
/* there are two possibilities here:
1) the playlist that the playlist source was based on
}
boost::shared_ptr<Region> original (ca->second);
+ cassocs.erase(ca);
bool modified_region;
if (i == rl.begin()) {
}
if (!same_playlist) {
- framepos_t pos = original->position();
+ samplepos_t pos = original->position();
/* make a copy, but don't announce it */
original = RegionFactory::create (original, false);
/* the pure copy constructor resets position() to zero,
}
/* 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.
*/
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)
+{
+ RegionReadLock rlock (this);
+ for (list<AudioRange>::iterator r = ranges.begin(); r != ranges.end(); ) {
+ list<AudioRange>::iterator tmpr = r;
+ ++tmpr;
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ) {
+ RegionList::const_iterator tmpi = i;
+ ++tmpi;
+ (*i)->fade_range ((*r).start, (*r).end);
+ i = tmpi;
+ }
+ r = tmpr;
+ }
+}
+
uint32_t
Playlist::max_source_level () const
{
void
Playlist::set_orig_track_id (const PBD::ID& id)
{
+ if (shared_with(id)) {
+ // Swap 'shared_id' / origin_track_id
+ unshare_with (id);
+ share_with (_orig_track_id);
+ }
_orig_track_id = id;
}
+void
+Playlist::share_with (const PBD::ID& id)
+{
+ if (!shared_with(id)) {
+ _shared_with_ids.push_back (id);
+ }
+}
+
+void
+Playlist::unshare_with (const PBD::ID& id)
+{
+ list<PBD::ID>::iterator it = _shared_with_ids.begin ();
+ while (it != _shared_with_ids.end()) {
+ if (*it == id) {
+ _shared_with_ids.erase (it);
+ break;
+ }
+ ++it;
+ }
+}
+
+bool
+Playlist::shared_with (const PBD::ID& id) const
+{
+ bool shared = false;
+ list<PBD::ID>::const_iterator it = _shared_with_ids.begin ();
+ while (it != _shared_with_ids.end() && !shared) {
+ if (*it == id) {
+ shared = true;
+ }
+ ++it;
+ }
+
+ return shared;
+}
+
+void
+Playlist::reset_shares ()
+{
+ _shared_with_ids.clear();
+}
+
/** 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)
+Playlist::coalesce_and_check_crossfades (list<Evoral::Range<samplepos_t> > ranges)
{
/* XXX: it's a shame that this coalesce algorithm also exists in
TimeSelection::consolidate().
/* XXX: xfade: this is implemented in Evoral::RangeList */
restart:
- for (list<Evoral::Range<framepos_t> >::iterator i = ranges.begin(); i != ranges.end(); ++i) {
- for (list<Evoral::Range<framepos_t> >::iterator j = ranges.begin(); j != ranges.end(); ++j) {
+ for (list<Evoral::Range<samplepos_t> >::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ for (list<Evoral::Range<samplepos_t> >::iterator j = ranges.begin(); j != ranges.end(); ++j) {
if (i == j) {
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);
projects / ardour.git / blobdiff