#include <sigc++/bind.h>
-#include <pbd/failed_constructor.h>
-#include <pbd/stl_delete.h>
-#include <pbd/xml++.h>
-#include <pbd/stacktrace.h>
-
-#include <ardour/playlist.h>
-#include <ardour/session.h>
-#include <ardour/region.h>
-#include <ardour/region_factory.h>
-#include <ardour/playlist_factory.h>
-#include <ardour/transient_detector.h>
+#include "pbd/failed_constructor.h"
+#include "pbd/stl_delete.h"
+#include "pbd/xml++.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/playlist.h"
+#include "ardour/session.h"
+#include "ardour/region.h"
+#include "ardour/region_factory.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/transient_detector.h"
#include "i18n.h"
Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty));
}
-Playlist::Playlist (const Playlist& pl)
- : SessionObject(pl._session, pl._name)
- , _type(pl.data_type())
-{
- fatal << _("playlist const copy constructor called") << endmsg;
-}
-
-Playlist::Playlist (Playlist& pl)
- : SessionObject(pl._session, pl._name)
- , _type(pl.data_type())
-{
- fatal << _("playlist non-const copy constructor called") << endmsg;
-}
-
Playlist::~Playlist ()
{
- {
+ {
RegionLock rl (this);
for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
}
}
-
void
Playlist::notify_modified ()
{
pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
pending_modified = false;
+ RegionRemoved (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
Modified (); /* EMIT SIGNAL */
}
}
+void
+Playlist::notify_region_moved (boost::shared_ptr<Region> r)
+{
+ Evoral::RangeMove<nframes_t> const move (r->last_position (), r->length (), r->position ());
+
+ if (holding_state ()) {
+
+ pending_range_moves.push_back (move);
+
+ } else {
+
+ list< Evoral::RangeMove<nframes_t> > m;
+ m.push_back (move);
+ RangesMoved (m);
+ }
+
+}
+
void
Playlist::notify_region_added (boost::shared_ptr<Region> r)
{
pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
pending_modified = false;
+ RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
Modified (); /* EMIT SIGNAL */
}
}
// pending_bounds.sort (cmp);
for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
- if (Config->get_layer_model() == MoveAddHigher) {
+ if (_session.config.get_layer_model() == MoveAddHigher) {
timestamp_layer_op (*r);
}
+
pending_length = true;
dependent_checks_needed.insert (*r);
- n++;
- }
- for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
- dependent_checks_needed.insert (*s);
n++;
}
for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
remove_dependents (*s);
+ RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ n++;
+ }
+
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ dependent_checks_needed.insert (*s);
n++;
}
relayer ();
}
pending_modified = false;
- Modified (); /* EMIT SIGNAL */
-
+ Modified (); /* EMIT SIGNAL */
}
for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
check_dependents (*s, false);
}
+ if (!pending_range_moves.empty ()) {
+ RangesMoved (pending_range_moves);
+ }
+
pending_adds.clear ();
pending_removes.clear ();
pending_bounds.clear ();
+ pending_range_moves.clear ();
in_flush = false;
}
*************************************************************/
void
-Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
-{
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times, bool auto_partition)
+{
RegionLock rlock (this);
- delay_notifications();
times = fabs (times);
int itimes = (int) floor (times);
nframes_t pos = position;
+
+ if(times == 1 && auto_partition){
+ partition(pos, (nframes_t) (pos + region->length()), true);
+ }
if (itimes >= 1) {
add_region_internal (region, pos);
add_region_internal (sub, pos);
}
-
possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
- release_notifications ();
}
void
}
}
-void
+bool
Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position)
{
+ if (region->data_type() != _type){
+ return false;
+ }
+
RegionSortByPosition cmp;
+
nframes_t old_length = 0;
if (!holding_state()) {
notify_region_added (region);
if (!holding_state ()) {
+
check_dependents (region, false);
+
if (old_length != _get_maximum_extent()) {
notify_length_changed ();
}
}
- region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy),
- boost::weak_ptr<Region> (region)));
+ region_state_changed_connections.push_back (
+ region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy),
+ boost::weak_ptr<Region> (region)))
+ );
+
+ return true;
}
void
}
void
-Playlist::partition (nframes_t start, nframes_t end, bool just_top_level)
+Playlist::partition (nframes_t start, nframes_t end, bool cut)
{
RegionList thawlist;
- partition_internal (start, end, false, thawlist);
+ partition_internal (start, end, cut, thawlist);
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("separation");
void
Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
{
- RegionLock rlock (this);
- boost::shared_ptr<Region> region;
- boost::shared_ptr<Region> current;
- string new_name;
- RegionList::iterator tmp;
- OverlapType overlap;
- nframes_t pos1, pos2, pos3, pos4;
RegionList new_regions;
- in_partition = true;
-
- /* need to work from a copy, because otherwise the regions we add during the process
- get operated on as well.
- */
-
- RegionList copy = regions;
+ {
+ RegionLock rlock (this);
- for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+ boost::shared_ptr<Region> region;
+ boost::shared_ptr<Region> current;
+ string new_name;
+ RegionList::iterator tmp;
+ OverlapType overlap;
+ nframes_t pos1, pos2, pos3, pos4;
- tmp = i;
- ++tmp;
-
- current = *i;
+ in_partition = true;
- if (current->first_frame() == start && current->last_frame() == end) {
- if (cutting) {
- remove_region_internal (current);
- }
- continue;
- }
+ /* need to work from a copy, because otherwise the regions we add during the process
+ get operated on as well.
+ */
- if ((overlap = current->coverage (start, end)) == OverlapNone) {
- continue;
- }
+ RegionList copy = regions;
- pos1 = current->position();
- pos2 = start;
- pos3 = end;
- pos4 = current->last_frame();
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+
+ tmp = i;
+ ++tmp;
+
+ current = *i;
+
+ if (current->first_frame() >= start && current->last_frame() < end) {
+
+ if (cutting) {
+ remove_region_internal (current);
+ }
- if (overlap == OverlapInternal) {
+ continue;
+ }
- /* split: we need 3 new regions, the front, middle and end.
- cut: we need 2 regions, the front and end.
+ /* coverage will return OverlapStart if the start coincides
+ with the end point. we do not partition such a region,
+ so catch this special case.
*/
+
+ if (current->first_frame() >= end) {
+ continue;
+ }
+
+ if ((overlap = current->coverage (start, end)) == OverlapNone) {
+ continue;
+ }
+
+ pos1 = current->position();
+ pos2 = start;
+ pos3 = end;
+ pos4 = current->last_frame();
- /*
+ if (overlap == OverlapInternal) {
+ /* split: we need 3 new regions, the front, middle and end.
+ cut: we need 2 regions, the front and end.
+ */
+
+ /*
start end
---------------*************************------------
P1 P2 P3 P4
CUT
---------------*****----------------====------------
- */
+ */
- if (!cutting) {
-
- /* "middle" ++++++ */
+ if (!cutting) {
+ /* "middle" ++++++ */
+
+ _session.region_name (new_name, current->name(), false);
+ region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
+ regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
- _session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
- add_region_internal (region, start);
- new_regions.push_back (region);
- }
+ /* "end" ====== */
- /* "end" ====== */
-
- _session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-
- add_region_internal (region, end);
- new_regions.push_back (region);
+ _session.region_name (new_name, current->name(), false);
+ region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name,
+ regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
- /* "front" ***** */
+ add_region_internal (region, end);
+ new_regions.push_back (region);
+
+ /* "front" ***** */
- current->freeze ();
- thawlist.push_back (current);
- current->trim_end (pos2, this);
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_end (pos2, this);
- } else if (overlap == OverlapEnd) {
+ } else if (overlap == OverlapEnd) {
- /*
+ /*
start end
---------------*************************------------
P1 P2 P4 P3
---------------**************+++++++++++------------
CUT:
---------------**************-----------------------
+ */
+
+ if (!cutting) {
- */
+ /* end +++++ */
+
+ _session.region_name (new_name, current->name(), false);
+ region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
+ Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
- if (!cutting) {
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
- /* end +++++ */
+ /* front ****** */
- _session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
- Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
- add_region_internal (region, start);
- new_regions.push_back (region);
- }
-
- /* front ****** */
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_end (pos2, this);
- current->freeze ();
- thawlist.push_back (current);
- current->trim_end (pos2, this);
+ } else if (overlap == OverlapStart) {
- } else if (overlap == 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
CUT:
-------------------*********************------------
- */
+ */
- if (!cutting) {
-
- /* front **** */
- _session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, 0, pos3 - pos1, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
- add_region_internal (region, pos1);
- new_regions.push_back (region);
- }
-
- /* end */
-
- current->freeze ();
- thawlist.push_back (current);
- current->trim_front (pos3, this);
+ if (!cutting) {
+ /* front **** */
+ _session.region_name (new_name, current->name(), false);
+ region = RegionFactory::create (current, 0, pos3 - pos1, new_name,
+ regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
- } else if (overlap == OverlapExternal) {
+ add_region_internal (region, pos1);
+ new_regions.push_back (region);
+ }
+
+ /* end */
+
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_front (pos3, this);
+ } else if (overlap == OverlapExternal) {
- /* split: no split required.
- cut: remove the region.
- */
+ /* split: no split required.
+ cut: remove the region.
+ */
- /*
+ /*
start end
---------------*************************------------
P2 P1 P3 P4
CUT:
----------------------------------------------------
- */
+ */
+
+ if (cutting) {
+ remove_region_internal (current);
+ }
- if (cutting) {
- remove_region_internal (current);
+ new_regions.push_back (current);
}
- new_regions.push_back (current);
}
- }
- in_partition = false;
+ in_partition = false;
+ }
for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) {
check_dependents (*i, false);
}
}
+void
+Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bool ignore_music_glue)
+{
+ RegionLock rlock (this);
+ RegionList copy (regions);
+ RegionList fixup;
+
+ for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
+
+ if ((*r)->last_frame() < at) {
+ /* too early */
+ continue;
+ }
+
+ if (at > (*r)->first_frame() && at < (*r)->last_frame()) {
+ /* intersected region */
+ if (!move_intersected) {
+ continue;
+ }
+ }
+
+ /* do not move regions glued to music time - that
+ has to be done separately.
+ */
+
+ if (!ignore_music_glue && (*r)->positional_lock_style() != Region::AudioTime) {
+ fixup.push_back (*r);
+ continue;
+ }
+
+ (*r)->set_position ((*r)->position() + distance, this);
+ }
+
+ for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) {
+ (*r)->recompute_position_from_lock_style ();
+ }
+}
+
+void
+Playlist::split (nframes64_t at)
+{
+ RegionLock rlock (this);
+ RegionList copy (regions);
+
+ /* use a copy since this operation can modify the region list
+ */
+
+ for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
+ _split_region (*r, at);
+ }
+}
+
void
Playlist::split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
{
RegionLock rl (this);
+ _split_region (region, playlist_position);
+}
+void
+Playlist::_split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
+{
if (!region->covers (playlist_position)) {
return;
}
if (holding_state ()) {
pending_bounds.push_back (region);
} else {
- if (Config->get_layer_model() == MoveAddHigher) {
+ if (_session.config.get_layer_model() == MoveAddHigher) {
/* it moved or changed length, so change the timestamp */
timestamp_layer_op (region);
}
return false;
}
- {
- if (what_changed & BoundsChanged) {
- region_bounds_changed (what_changed, region);
- save = !(_splicing || _nudging);
- }
+ if (what_changed & BoundsChanged) {
+ region_bounds_changed (what_changed, region);
+ save = !(_splicing || _nudging);
+ }
- if ((what_changed & our_interests) &&
- !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
- check_dependents (region, false);
- }
+ if ((what_changed & our_interests) &&
+ !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ check_dependents (region, false);
+ }
+
+ if (what_changed & Change (ARDOUR::PositionChanged)) {
+ notify_region_moved (region);
+ }
- if (what_changed & our_interests) {
- save = true;
- }
+ if (what_changed & our_interests) {
+ save = true;
}
return save;
void
Playlist::clear (bool with_signals)
{
- {
+ {
RegionLock rl (this);
+
+ for (
+ std::list<sigc::connection>::iterator i = region_state_changed_connections.begin ();
+ i != region_state_changed_connections.end ();
+ ++i
+ ) {
+ i->disconnect ();
+ }
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
pending_removes.insert (*i);
}
+
regions.clear ();
}
boost::shared_ptr<Region> ret;
nframes_t closest = max_frames;
+ bool end_iter = false;
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if(end_iter) break;
+
nframes_t distance;
boost::shared_ptr<Region> r = (*i);
nframes_t pos = 0;
pos = r->last_frame ();
break;
case SyncPoint:
- pos = r->adjust_to_sync (r->first_frame());
+ pos = r->sync_position ();
+ // r->adjust_to_sync (r->first_frame());
break;
}
switch (dir) {
case 1: /* forwards */
- if (pos >= frame) {
+ if (pos > frame) {
if ((distance = pos - frame) < closest) {
closest = distance;
ret = r;
+ end_iter = true;
}
}
break;
default: /* backwards */
-
- if (pos <= frame) {
+
+ if (pos < frame) {
if ((distance = frame - pos) < closest) {
closest = distance;
ret = r;
}
}
+ else {
+ end_iter = true;
+ }
+
break;
}
}
if (dir > 0) {
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-
+
boost::shared_ptr<Region> r = (*i);
nframes64_t distance;
- nframes64_t end = r->position() + r->length();
- bool reset;
-
- reset = false;
-
+
if (r->first_frame() > frame) {
distance = r->first_frame() - frame;
if (distance < closest) {
ret = r->first_frame();
closest = distance;
- reset = true;
}
}
- if (end > frame) {
+ if (r->last_frame () > frame) {
- distance = end - frame;
+ distance = r->last_frame () - frame;
if (distance < closest) {
- ret = end;
+ ret = r->last_frame ();
closest = distance;
- reset = true;
}
}
-
- if (reset) {
- break;
- }
}
} else {
boost::shared_ptr<Region> r = (*i);
nframes64_t distance;
- bool reset;
-
- reset = false;
if (r->last_frame() < frame) {
if (distance < closest) {
ret = r->last_frame();
closest = distance;
- reset = true;
}
}
if (r->first_frame() < frame) {
- distance = frame - r->last_frame();
+ distance = frame - r->first_frame();
+
if (distance < closest) {
ret = r->first_frame();
closest = distance;
- reset = true;
}
}
-
- if (reset) {
- break;
- }
}
}
+
void
Playlist::mark_session_dirty ()
{
layer_t
Playlist::top_layer() const
{
- RegionLock rlock (const_cast<Playlist *> (this));
+ RegionLock rlock (const_cast<Playlist *> (this));
layer_t top = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
/* sort according to the model */
- if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
+ if (_session.config.get_layer_model() == MoveAddHigher || _session.config.get_layer_model() == AddHigher) {
RegionSortByLastLayerOp cmp;
copy.sort (cmp);
}
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((Config->get_layer_model() == MoveAddHigher) ||
- (Config->get_layer_model() == AddHigher)) {
+ if ((_session.config.get_layer_model() == MoveAddHigher) ||
+ (_session.config.get_layer_model() == AddHigher)) {
timestamp_layer_op (region);
relayer ();
}
Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((Config->get_layer_model() == MoveAddHigher) ||
- (Config->get_layer_model() == AddHigher)) {
+ if ((_session.config.get_layer_model() == MoveAddHigher) ||
+ (_session.config.get_layer_model() == AddHigher)) {
region->set_last_layer_op (0);
relayer ();
}
thaw ();
}
+
+void
+Playlist::foreach_region (sigc::slot<void, boost::shared_ptr<Region> > s)
+{
+ RegionLock rl (this, false);
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ s (*i);
+ }
+}
+
+
projects / ardour.git / blobdiff