along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
#include <set>
#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"
using namespace ARDOUR;
using namespace PBD;
-sigc::signal<void,Playlist*> Playlist::PlaylistCreated;
-
struct ShowMeTheList {
- ShowMeTheList (Playlist *pl, const string& n) : playlist (pl), name (n) {}
+ ShowMeTheList (boost::shared_ptr<Playlist> pl, const string& n) : playlist (pl), name (n) {}
~ShowMeTheList () {
cerr << ">>>>" << name << endl; playlist->dump(); cerr << "<<<<" << name << endl << endl;
};
- Playlist *playlist;
+ boost::shared_ptr<Playlist> playlist;
string name;
};
struct RegionSortByLayer {
- bool operator() (Region *a, Region *b) {
+ bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->layer() < b->layer();
}
};
struct RegionSortByPosition {
- bool operator() (Region *a, Region *b) {
+ bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->position() < b->position();
}
};
struct RegionSortByLastLayerOp {
- bool operator() (Region *a, Region *b) {
+ bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->last_layer_op() < b->last_layer_op();
}
};
-Playlist::Playlist (Session& sess, string nom, bool hide)
- : _session (sess)
+
+Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
+ : SessionObject(sess, nom)
+ , _type(type)
{
init (hide);
+ first_set_state = false;
_name = nom;
}
-Playlist::Playlist (Session& sess, const XMLNode& node, bool hide)
- : _session (sess)
+Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
+ : SessionObject(sess, "unnamed playlist")
+ , _type(type)
{
+ const XMLProperty* prop = node.property("type");
+ assert(!prop || DataType(prop->value()) == _type);
+
init (hide);
_name = "unnamed"; /* reset by set_state */
-
- if (set_state (node)) {
- throw failed_constructor();
- }
+
+ /* set state called by derived class */
}
-Playlist::Playlist (const Playlist& other, string namestr, bool hide)
- : _name (namestr), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id)
+Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
+ : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
init (hide);
RegionList tmp;
- other.copy_regions (tmp);
+ other->copy_regions (tmp);
- in_set_state = true;
+ in_set_state++;
- for (list<Region*>::iterator x = tmp.begin(); x != tmp.end(); ++x) {
- add_region_internal( (*x), (*x)->position() );
+ for (list<boost::shared_ptr<Region> >::iterator x = tmp.begin(); x != tmp.end(); ++x) {
+ add_region_internal( (*x), (*x)->position());
}
- in_set_state = false;
+ in_set_state--;
- _splicing = other._splicing;
- _nudging = other._nudging;
- _edit_mode = other._edit_mode;
+ _splicing = other->_splicing;
+ _nudging = other->_nudging;
+ _edit_mode = other->_edit_mode;
- in_set_state = false;
+ in_set_state = 0;
+ first_set_state = false;
in_flush = false;
in_partition = false;
subcnt = 0;
_read_data_count = 0;
- _frozen = other._frozen;
- save_on_thaw = false;
-
- layer_op_counter = other.layer_op_counter;
- freeze_length = other.freeze_length;
+ _frozen = other->_frozen;
+ layer_op_counter = other->layer_op_counter;
+ freeze_length = other->freeze_length;
}
-Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t cnt, string str, bool hide)
- : _name (str), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id)
+Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
+ : SessionObject(other->_session, str), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
- RegionLock rlock2 (&((Playlist&)other));
-
- jack_nframes_t end = start + cnt - 1;
+ RegionLock rlock2 (const_cast<Playlist*> (other.get()));
+
+ nframes_t end = start + cnt - 1;
init (hide);
- for (RegionList::const_iterator i = other.regions.begin(); i != other.regions.end(); i++) {
+ in_set_state++;
+
+ for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); i++) {
- Region *region;
- Region *new_region;
- jack_nframes_t offset = 0;
- jack_nframes_t position = 0;
- jack_nframes_t len = 0;
+ boost::shared_ptr<Region> region;
+ boost::shared_ptr<Region> new_region;
+ nframes_t offset = 0;
+ nframes_t position = 0;
+ nframes_t len = 0;
string new_name;
OverlapType overlap;
_session.region_name (new_name, region->name(), false);
- new_region = createRegion (*region, offset, len, new_name, region->layer(), region->flags());
+ new_region = RegionFactory::RegionFactory::create (region, offset, len, new_name, region->layer(), region->flags());
- add_region_internal (new_region, position, true);
+ add_region_internal (new_region, position);
}
+ in_set_state--;
+ first_set_state = false;
+
/* this constructor does NOT notify others (session) */
}
void
-Playlist::ref ()
+Playlist::use ()
{
++_refcnt;
- InUse (this, true); /* EMIT SIGNAL */
+ InUse (true); /* EMIT SIGNAL */
}
void
-Playlist::unref ()
+Playlist::release ()
{
if (_refcnt > 0) {
_refcnt--;
}
+
if (_refcnt == 0) {
- InUse (this, false); /* EMIT SIGNAL */
-
- if (_hidden) {
- /* nobody knows we exist */
- delete this;
- }
+ InUse (false); /* EMIT SIGNAL */
}
}
-
void
Playlist::copy_regions (RegionList& newlist) const
{
RegionLock rlock (const_cast<Playlist *> (this));
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- newlist.push_back (createRegion (**i));
+ newlist.push_back (RegionFactory::RegionFactory::create (*i));
}
}
g_atomic_int_set (&ignore_state_changes, 0);
pending_modified = false;
pending_length = false;
+ first_set_state = true;
_refcnt = 0;
_hidden = hide;
_splicing = false;
+ _shuffling = false;
_nudging = false;
- in_set_state = false;
- _edit_mode = _session.get_edit_mode();
+ in_set_state = 0;
+ _edit_mode = Config->get_edit_mode();
in_flush = false;
in_partition = false;
subcnt = 0;
_read_data_count = 0;
_frozen = false;
- save_on_thaw = false;
layer_op_counter = 0;
freeze_length = 0;
}
Playlist::Playlist (const Playlist& pl)
- : _session (pl._session)
+ : SessionObject(pl._session, pl._name)
+ , _type(pl.data_type())
{
fatal << _("playlist const copy constructor called") << endmsg;
}
Playlist::Playlist (Playlist& pl)
- : _session (pl._session)
+ : 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) {
+ (*i)->set_playlist (boost::shared_ptr<Playlist>());
+ }
+ }
+
+ /* GoingAway must be emitted by derived classes */
}
-void
+bool
Playlist::set_name (const string& str)
{
/* in a typical situation, a playlist is being used
*/
if (_refcnt > 2) {
- return;
+ return false;
+ } else {
+ return SessionObject::set_name(str);
}
-
- _name = str;
- NameChanged(); /* EMIT SIGNAL */
}
/***********************************************************************
}
}
-
void
Playlist::notify_modified ()
{
}
void
-Playlist::notify_region_removed (Region *r)
+Playlist::notify_region_removed (boost::shared_ptr<Region> r)
{
if (holding_state ()) {
- pending_removals.insert (pending_removals.end(), r);
+ pending_removes.insert (r);
+ pending_modified = true;
+ pending_length = true;
} else {
- RegionRemoved (r); /* EMIT SIGNAL */
/* this might not be true, but we have to act
as though it could be.
*/
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
void
-Playlist::notify_region_added (Region *r)
+Playlist::notify_region_moved (boost::shared_ptr<Region> r)
+{
+ Evoral::RangeMove const move (r->last_position (), r->length (), r->position ());
+
+ if (holding_state ()) {
+
+ pending_range_moves.push_back (move);
+
+ } else {
+
+ Evoral::RangeMoveList m;
+ m.push_back (move);
+ RangesMoved (m);
+
+ }
+
+}
+
+void
+Playlist::notify_region_added (boost::shared_ptr<Region> r)
{
+ /* the length change might not be true, but we have to act
+ as though it could be.
+ */
+
if (holding_state()) {
- pending_adds.insert (pending_adds.end(), r);
+ pending_adds.insert (r);
+ pending_modified = true;
+ pending_length = true;
} else {
- RegionAdded (r); /* EMIT SIGNAL */
- /* this might not be true, but we have to act
- as though it could be.
- */
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
if (holding_state ()) {
pending_length = true;
} else {
+ pending_length = false;
LengthChanged(); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
void
Playlist::flush_notifications ()
{
- RegionList::iterator r;
- RegionList::iterator a;
- set<Region*> dependent_checks_needed;
+ set<boost::shared_ptr<Region> > dependent_checks_needed;
+ set<boost::shared_ptr<Region> >::iterator s;
uint32_t n = 0;
if (in_flush) {
// pending_bounds.sort (cmp);
for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
- if (_session.get_layer_model() == Session::MoveAddHigher) {
- timestamp_layer_op (**r);
+ if (Config->get_layer_model() == MoveAddHigher) {
+ timestamp_layer_op (*r);
}
pending_length = true;
- n++;
- }
-
- for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
dependent_checks_needed.insert (*r);
- /* don't increment n again - its the same list */
- }
-
- for (a = pending_adds.begin(); a != pending_adds.end(); ++a) {
- dependent_checks_needed.insert (*a);
- RegionAdded (*a); /* EMIT SIGNAL */
n++;
}
- for (set<Region*>::iterator x = dependent_checks_needed.begin(); x != dependent_checks_needed.end(); ++x) {
- check_dependents (**x, false);
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ dependent_checks_needed.insert (*s);
+ n++;
}
- for (r = pending_removals.begin(); r != pending_removals.end(); ++r) {
- remove_dependents (**r);
- RegionRemoved (*r); /* EMIT SIGNAL */
+ for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
+ remove_dependents (*s);
n++;
}
if (n || pending_modified) {
if (!in_set_state) {
- possibly_splice ();
relayer ();
}
pending_modified = false;
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_removals.clear ();
+ pending_removes.clear ();
pending_bounds.clear ();
+ pending_range_moves.clear ();
- if (save_on_thaw) {
- save_on_thaw = false;
- save_state (last_save_reason);
- }
-
in_flush = false;
}
*************************************************************/
void
-Playlist::add_region (const Region& region, jack_nframes_t position, float times, bool with_save)
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
{
RegionLock rlock (this);
-
times = fabs (times);
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
+ nframes_t pos = position;
if (itimes >= 1) {
- add_region_internal (const_cast<Region*>(®ion), pos, true);
- pos += region.length();
+ add_region_internal (region, pos);
+ pos += region->length();
--itimes;
}
- /* later regions will all be spliced anyway */
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
-
/* 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) {
- Region *copy = createRegion (region);
- add_region_internal (copy, pos, true);
- pos += region.length();
+ boost::shared_ptr<Region> copy = RegionFactory::create (region);
+ add_region_internal (copy, pos);
+ pos += region->length();
}
+ nframes_t length = 0;
+
if (floor (times) != times) {
- jack_nframes_t length = (jack_nframes_t) floor (region.length() * (times - floor (times)));
+ length = (nframes_t) floor (region->length() * (times - floor (times)));
string name;
- _session.region_name (name, region.name(), false);
- Region *sub = createRegion (region, 0, length, name, region.layer(), region.flags());
- add_region_internal (sub, pos, true);
- }
-
- if (with_save) {
- maybe_save_state (_("add region"));
+ _session.region_name (name, region->name(), false);
+ boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
+ add_region_internal (sub, pos);
}
+
+
+ possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
}
void
-Playlist::add_region_internal (Region *region, jack_nframes_t position, bool delay_sort)
+Playlist::set_region_ownership ()
{
- RegionSortByPosition cmp;
- jack_nframes_t old_length = 0;
+ RegionLock 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);
+ }
+}
+
+bool
+Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position)
+{
+ if (region->data_type() != _type)
+ return false;
- // cerr << "adding region " << region->name() << " at " << position << endl;
+ RegionSortByPosition cmp;
+ nframes_t old_length = 0;
if (!holding_state()) {
old_length = _get_maximum_extent();
}
- region->set_playlist (this);
+ if (!first_set_state) {
+ boost::shared_ptr<Playlist> foo (shared_from_this());
+ region->set_playlist (boost::weak_ptr<Playlist>(foo));
+ }
+
region->set_position (position, this);
- region->lock_sources ();
- timestamp_layer_op (*region);
+ timestamp_layer_op (region);
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
+ all_regions.insert (region);
+
+ possibly_splice_unlocked (position, region->length(), region);
if (!holding_state () && !in_set_state) {
/* layers get assigned from XML state */
notify_region_added (region);
if (!holding_state ()) {
- check_dependents (*region, false);
+ 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), 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
-Playlist::replace_region (Region& old, Region& newr, jack_nframes_t pos)
+Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, nframes_t pos)
{
RegionLock rlock (this);
- remove_region_internal (&old);
- add_region_internal (&newr, pos);
+ bool old_sp = _splicing;
+ _splicing = true;
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
+ remove_region_internal (old);
+ add_region_internal (newr, pos);
+
+ _splicing = old_sp;
- maybe_save_state (_("replace region"));
+ possibly_splice_unlocked (pos, (nframes64_t) old->length() - (nframes64_t) newr->length());
}
void
-Playlist::remove_region (Region *region)
+Playlist::remove_region (boost::shared_ptr<Region> region)
{
RegionLock rlock (this);
remove_region_internal (region);
-
- if (!holding_state ()) {
- possibly_splice_unlocked ();
- }
-
- maybe_save_state (_("remove region"));
}
int
-Playlist::remove_region_internal (Region *region, bool delay_sort)
+Playlist::remove_region_internal (boost::shared_ptr<Region> region)
{
RegionList::iterator i;
- jack_nframes_t old_length = 0;
-
- // cerr << "removing region " << region->name() << endl;
+ nframes_t old_length = 0;
if (!holding_state()) {
old_length = _get_maximum_extent();
}
+ if (!in_set_state) {
+ /* unset playlist */
+ region->set_playlist (boost::weak_ptr<Playlist>());
+ }
+
for (i = regions.begin(); i != regions.end(); ++i) {
if (*i == region) {
+ nframes_t pos = (*i)->position();
+ nframes64_t distance = (*i)->length();
+
regions.erase (i);
+ possibly_splice_unlocked (pos, -distance);
+
if (!holding_state ()) {
relayer ();
- remove_dependents (*region);
+ remove_dependents (region);
if (old_length != _get_maximum_extent()) {
notify_length_changed ();
return 0;
}
}
+
+
+
return -1;
}
void
-Playlist::get_equivalent_regions (const Region& other, vector<Region*>& results)
+Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
{
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- if (Config->get_use_overlap_equivalency()) {
+ 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));
- } else if ((*i)->equivalent (other)) {
+ }
+ }
+ } else {
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->equivalent (other)) {
results.push_back ((*i));
}
}
}
void
-Playlist::get_region_list_equivalent_regions (const Region& other, vector<Region*>& results)
+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::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level)
+Playlist::partition (nframes_t start, nframes_t end, bool just_top_level)
{
RegionList thawlist;
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("separation");
}
-
- maybe_save_state (_("separate"));
}
void
-Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist)
+Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
{
- RegionLock rlock (this);
- Region *region;
- Region *current;
- string new_name;
- RegionList::iterator tmp;
- OverlapType overlap;
- jack_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;
-
- for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+ {
+ 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;
- 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 (overlap == OverlapInternal) {
+ if (current->first_frame() >= start && current->last_frame() < end) {
+ if (cutting) {
+ remove_region_internal (current);
+ }
+ 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) {
+ if (!cutting) {
- /* "middle" ++++++ */
+ /* "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);
+ }
+ /* "end" ====== */
+
_session.region_name (new_name, current->name(), false);
- region = createRegion (*current, pos2 - pos1, pos3 - pos2, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
- add_region_internal (region, start, true);
+ 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);
- }
-
- /* "end" ====== */
-
- _session.region_name (new_name, current->name(), false);
- region = createRegion (*current, pos3 - pos1, pos4 - pos3, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-
- add_region_internal (region, end, true);
- new_regions.push_back (region);
-
- /* "front" ***** */
- current->freeze ();
- thawlist.push_back (current);
- current->trim_end (pos2, this);
-
- } else if (overlap == OverlapEnd) {
-
- /*
+ /* "front" ***** */
+
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_end (pos2, this);
+
+ } else if (overlap == OverlapEnd) {
+
+ /*
start end
---------------*************************------------
P1 P2 P4 P3
---------------**************+++++++++++------------
CUT:
---------------**************-----------------------
-
- */
-
- if (!cutting) {
+ */
- /* end +++++ */
+ 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));
+ add_region_internal (region, start);
+ new_regions.push_back (region);
+ }
- _session.region_name (new_name, current->name(), false);
- region = createRegion (*current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
- Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
- add_region_internal (region, start, true);
- new_regions.push_back (region);
- }
-
- /* front ****** */
-
- current->freeze ();
- thawlist.push_back (current);
- current->trim_end (pos2, this);
-
- } else if (overlap == OverlapStart) {
-
- /* split: we need 2 regions: the front and the end.
- cut: just trim current to skip the cut area
- */
+ /* front ****** */
+
+ current->freeze ();
+ thawlist.push_back (current);
+ current->trim_end (pos2, this);
+
+ } else if (overlap == OverlapStart) {
- /*
+ /* 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) {
+ if (!cutting) {
- /* front **** */
- _session.region_name (new_name, current->name(), false);
- region = createRegion (*current, 0, pos3 - pos1, new_name,
- regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
- add_region_internal (region, pos1, true);
- 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.
- */
+ /* 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);
- /*
+ } else if (overlap == OverlapExternal) {
+
+ /* 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);
+ check_dependents (*i, false);
}
}
-Playlist*
-Playlist::cut_copy (
Playlist* (Playlist::*pmf)(jack_nframes_t, jack_nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::cut_copy (
boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
{
- Playlist* ret;
- Playlist* pl;
- jack_nframes_t start;
+ boost::shared_ptr<Playlist> ret;
+ boost::shared_ptr<Playlist> pl;
+ nframes_t start;
if (ranges.empty()) {
- return 0;
+ return boost::shared_ptr<Playlist>();
}
start = ranges.front().start;
-
for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
chopped.
*/
- ret->paste (*pl, (*i).start - start, 1.0f);
- delete pl;
+ ret->paste (pl, (*i).start - start, 1.0f);
}
}
- if (ret) {
- /* manually notify session of new playlist here
- because the playlists were constructed without notifying
- */
- PlaylistCreated (ret);
- }
-
return ret;
}
-Playlist*
+boost::shared_ptr<Playlist>
Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
{
- Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::cut;
+ boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::cut;
return cut_copy (pmf, ranges, result_is_hidden);
}
-Playlist*
+boost::shared_ptr<Playlist>
Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
{
- Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::copy;
+ boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::copy;
return cut_copy (pmf, ranges, result_is_hidden);
}
-Playlist *
-Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden)
{
- Playlist *the_copy;
+ boost::shared_ptr<Playlist> the_copy;
RegionList thawlist;
char buf[32];
new_name += '.';
new_name += buf;
- if ((the_copy = copyPlaylist (*this, start, cnt, new_name, result_is_hidden)) == 0) {
- return 0;
+ if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
+ return boost::shared_ptr<Playlist>();
}
partition_internal (start, start+cnt-1, true, thawlist);
- possibly_splice ();
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("playlist cut");
}
- maybe_save_state (_("cut"));
-
return the_copy;
}
-Playlist *
-Playlist::copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::copy (nframes_t start, nframes_t cnt, bool result_is_hidden)
{
char buf[32];
new_name += buf;
cnt = min (_get_maximum_extent() - start, cnt);
- return copyPlaylist (*this, start, cnt, new_name, result_is_hidden);
+ return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
}
int
-Playlist::paste (Playlist& other, jack_nframes_t position, float times)
+Playlist::paste (boost::shared_ptr<Playlist> other, nframes_t position, float times)
{
times = fabs (times);
- jack_nframes_t old_length;
+ nframes_t old_length;
{
RegionLock rl1 (this);
- RegionLock rl2 (&other);
+ RegionLock rl2 (other.get());
old_length = _get_maximum_extent();
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
- jack_nframes_t shift = other._get_maximum_extent();
+ nframes_t pos = position;
+ nframes_t shift = other->_get_maximum_extent();
layer_t top_layer = regions.size();
while (itimes--) {
- for (RegionList::iterator i = other.regions.begin(); i != other.regions.end(); ++i) {
- Region *copy_of_region = createRegion (**i);
+ for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
+ boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i);
/* put these new regions on top of all existing ones, but preserve
the ordering they had in the original playlist.
pos += shift;
}
- possibly_splice_unlocked ();
/* XXX shall we handle fractional cases at some point? */
}
- maybe_save_state (_("paste"));
-
return 0;
}
void
-Playlist::duplicate (Region& region, jack_nframes_t position, float times)
+Playlist::duplicate (boost::shared_ptr<Region> region, nframes_t position, float times)
{
times = fabs (times);
RegionLock rl (this);
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
+ nframes_t pos = position;
while (itimes--) {
- Region *copy = createRegion (region);
- add_region_internal (copy, pos, true);
- pos += region.length();
+ boost::shared_ptr<Region> copy = RegionFactory::create (region);
+ add_region_internal (copy, pos);
+ pos += region->length();
}
if (floor (times) != times) {
- jack_nframes_t length = (jack_nframes_t) floor (region.length() * (times - floor (times)));
+ nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
string name;
- _session.region_name (name, region.name(), false);
- Region *sub = createRegion (region, 0, length, name, region.layer(), region.flags());
- add_region_internal (sub, pos, true);
+ _session.region_name (name, region->name(), false);
+ boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
+ add_region_internal (sub, pos);
+ }
+}
+
+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 ();
}
+}
- maybe_save_state (_("duplicate"));
+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 (Region& region, jack_nframes_t playlist_position)
+Playlist::split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
{
RegionLock rl (this);
+ _split_region (region, playlist_position);
+}
- if (!region.covers (playlist_position)) {
+void
+Playlist::_split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
+{
+ if (!region->covers (playlist_position)) {
return;
}
- if (region.position() == playlist_position ||
- region.last_frame() == playlist_position) {
+ if (region->position() == playlist_position ||
+ region->last_frame() == playlist_position) {
return;
}
- Region *left;
- Region *right;
- jack_nframes_t before;
- jack_nframes_t after;
+ boost::shared_ptr<Region> left;
+ boost::shared_ptr<Region> right;
+ nframes_t before;
+ nframes_t after;
string before_name;
string after_name;
- before = playlist_position - region.position();
- after = region.length() - before;
+ /* split doesn't change anything about length, so don't try to splice */
+ bool old_sp = _splicing;
+ _splicing = true;
+
+ before = playlist_position - region->position();
+ after = region->length() - before;
- _session.region_name (before_name, region.name(), false);
- left = createRegion (region, 0, before, before_name, region.layer(), Region::Flag (region.flags()|Region::LeftOfSplit));
+ _session.region_name (before_name, region->name(), false);
+ left = RegionFactory::create (region, 0, before, before_name, region->layer(), Region::Flag (region->flags()|Region::LeftOfSplit));
- _session.region_name (after_name, region.name(), false);
- right = createRegion (region, before, after, after_name, region.layer(), Region::Flag (region.flags()|Region::RightOfSplit));
+ _session.region_name (after_name, region->name(), false);
+ right = RegionFactory::create (region, before, after, after_name, region->layer(), Region::Flag (region->flags()|Region::RightOfSplit));
- add_region_internal (left, region.position(), true);
- add_region_internal (right, region.position() + before);
-
- uint64_t orig_layer_op = region.last_layer_op();
+ add_region_internal (left, region->position());
+ add_region_internal (right, region->position() + before);
+
+ uint64_t orig_layer_op = region->last_layer_op();
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->last_layer_op() > orig_layer_op) {
(*i)->set_last_layer_op( (*i)->last_layer_op() + 1 );
layer_op_counter++;
- finalize_split_region (®ion, left, right);
+ finalize_split_region (region, left, right);
- if (remove_region_internal (®ion, true)) {
- return;
- }
+ remove_region_internal (region);
- maybe_save_state (_("split"));
+ _splicing = old_sp;
}
void
-Playlist::possibly_splice ()
+Playlist::possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
+ if (_splicing || in_set_state) {
+ /* don't respond to splicing moves or state setting */
+ return;
+ }
+
if (_edit_mode == Splice) {
- splice_locked ();
+ splice_locked (at, distance, exclude);
}
}
void
-Playlist::possibly_splice_unlocked ()
+Playlist::possibly_splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
+ if (_splicing || in_set_state) {
+ /* don't respond to splicing moves or state setting */
+ return;
+ }
+
if (_edit_mode == Splice) {
- splice_unlocked ();
+ splice_unlocked (at, distance, exclude);
}
}
void
-Playlist::splice_locked ()
+Playlist::splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
{
RegionLock rl (this);
- core_splice ();
+ core_splice (at, distance, exclude);
}
-
- notify_length_changed ();
}
void
-Playlist::splice_unlocked ()
+Playlist::splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
- core_splice ();
- notify_length_changed ();
+ core_splice (at, distance, exclude);
}
void
-Playlist::core_splice ()
+Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude)
{
_splicing = true;
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-
- RegionList::iterator next;
-
- next = i;
- ++next;
-
- if (next == regions.end()) {
- break;
+
+ if (exclude && (*i) == exclude) {
+ continue;
+ }
+
+ if ((*i)->position() >= at) {
+ nframes64_t new_pos = (*i)->position() + distance;
+ if (new_pos < 0) {
+ new_pos = 0;
+ } else if (new_pos >= max_frames - (*i)->length()) {
+ new_pos = max_frames - (*i)->length();
+ }
+
+ (*i)->set_position (new_pos, this);
}
-
- (*next)->set_position ((*i)->last_frame() + 1, this);
}
-
+
_splicing = false;
+
+ notify_length_changed ();
}
void
-Playlist::region_bounds_changed (Change what_changed, Region *region)
+Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr<Region> region)
{
- if (in_set_state || _splicing || _nudging) {
+ if (in_set_state || _splicing || _nudging || _shuffling) {
return;
}
}
regions.erase (i);
- regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp),
- region);
-
+ regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
}
if (what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) {
-
+
+ nframes64_t delta = 0;
+
+ if (what_changed & ARDOUR::PositionChanged) {
+ delta = (nframes64_t) region->position() - (nframes64_t) region->last_position();
+ }
+
+ if (what_changed & ARDOUR::LengthChanged) {
+ delta += (nframes64_t) region->length() - (nframes64_t) region->last_length();
+ }
+
+ if (delta) {
+ possibly_splice (region->last_position() + region->last_length(), delta, region);
+ }
+
if (holding_state ()) {
pending_bounds.push_back (region);
} else {
- if (_session.get_layer_model() == Session::MoveAddHigher) {
+ if (Config->get_layer_model() == MoveAddHigher) {
/* it moved or changed length, so change the timestamp */
- timestamp_layer_op (*region);
+ timestamp_layer_op (region);
}
- possibly_splice ();
- check_dependents (*region, false);
notify_length_changed ();
relayer ();
+ check_dependents (region, false);
}
}
}
void
-Playlist::region_changed_proxy (Change what_changed, Region* region)
+Playlist::region_changed_proxy (Change what_changed, boost::weak_ptr<Region> weak_region)
{
+ boost::shared_ptr<Region> region (weak_region.lock());
+
+ if (!region) {
+ return;
+ }
+
+
/* this makes a virtual call to the right kind of playlist ... */
region_changed (what_changed, region);
}
bool
-Playlist::region_changed (Change what_changed, Region* region)
+Playlist::region_changed (Change what_changed, boost::shared_ptr<Region> region)
{
Change our_interests = Change (Region::MuteChanged|Region::LayerChanged|Region::OpacityChanged);
bool save = false;
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 & Region::MuteChanged) &&
- !(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_delete, bool with_save)
+Playlist::drop_regions ()
{
- RegionList::iterator i;
- RegionList tmp;
+ RegionLock rl (this);
+ regions.clear ();
+ all_regions.clear ();
+}
+void
+Playlist::clear (bool with_signals)
+{
{
RegionLock rl (this);
- tmp = regions;
- regions.clear ();
- }
-
- for (i = tmp.begin(); i != tmp.end(); ++i) {
- notify_region_removed (*i);
- if (with_delete) {
- delete *i;
+
+ 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 ();
}
- if (with_save) {
- maybe_save_state (_("clear"));
+ if (with_signals) {
+ pending_length = false;
+ LengthChanged ();
+ pending_modified = false;
+ Modified ();
}
+
}
/***********************************************************************
**********************************************************************/
Playlist::RegionList *
-Playlist::regions_at (jack_nframes_t frame)
+Playlist::regions_at (nframes_t frame)
{
RegionLock rlock (this);
return find_regions_at (frame);
}
-Region *
-Playlist::top_region_at (jack_nframes_t frame)
+boost::shared_ptr<Region>
+Playlist::top_region_at (nframes_t frame)
{
RegionLock rlock (this);
RegionList *rlist = find_regions_at (frame);
- Region *region = 0;
-
+ boost::shared_ptr<Region> region;
+
if (rlist->size()) {
RegionSortByLayer cmp;
rlist->sort (cmp);
return region;
}
+Playlist::RegionList*
+Playlist::regions_to_read (nframes_t start, nframes_t end)
+{
+ /* Caller must hold lock */
+
+ RegionList covering;
+ set<nframes_t> to_check;
+ set<boost::shared_ptr<Region> > unique;
+ RegionList here;
+
+ to_check.insert (start);
+ to_check.insert (end);
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ /* find all/any regions that span start+end */
+
+ switch ((*i)->coverage (start, end)) {
+ case OverlapNone:
+ break;
+
+ case OverlapInternal:
+ covering.push_back (*i);
+ break;
+
+ case OverlapStart:
+ to_check.insert ((*i)->position());
+ covering.push_back (*i);
+ break;
+
+ case OverlapEnd:
+ to_check.insert ((*i)->last_frame());
+ covering.push_back (*i);
+ break;
+
+ case OverlapExternal:
+ covering.push_back (*i);
+ to_check.insert ((*i)->position());
+ to_check.insert ((*i)->last_frame());
+ break;
+ }
+
+ /* don't go too far */
+
+ if ((*i)->position() > end) {
+ break;
+ }
+ }
+
+ RegionList* rlist = new RegionList;
+
+ /* find all the regions that cover each position .... */
+
+ if (covering.size() == 1) {
+
+ rlist->push_back (covering.front());
+
+ } else {
+
+ for (set<nframes_t>::iterator t = to_check.begin(); t != to_check.end(); ++t) {
+
+ here.clear ();
+
+ for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) {
+
+ if ((*x)->covers (*t)) {
+ here.push_back (*x);
+ }
+ }
+
+ RegionSortByLayer cmp;
+ here.sort (cmp);
+
+ /* ... and get the top/transparent regions at "here" */
+
+ for (RegionList::reverse_iterator c = here.rbegin(); c != here.rend(); ++c) {
+
+ unique.insert (*c);
+
+ if ((*c)->opaque()) {
+
+ /* the other regions at this position are hidden by this one */
+
+ break;
+ }
+ }
+ }
+
+ for (set<boost::shared_ptr<Region> >::iterator s = unique.begin(); s != unique.end(); ++s) {
+ rlist->push_back (*s);
+ }
+
+ if (rlist->size() > 1) {
+ /* now sort by time order */
+
+ RegionSortByPosition cmp;
+ rlist->sort (cmp);
+ }
+ }
+
+ return rlist;
+}
+
Playlist::RegionList *
-Playlist::find_regions_at (jack_nframes_t frame)
+Playlist::find_regions_at (nframes_t frame)
{
+ /* Caller must hold lock */
+
RegionList *rlist = new RegionList;
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
}
Playlist::RegionList *
-Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end)
+Playlist::regions_touched (nframes_t start, nframes_t end)
{
RegionLock rlock (this);
RegionList *rlist = new RegionList;
return rlist;
}
+nframes64_t
+Playlist::find_next_transient (nframes64_t from, int dir)
+{
+ RegionLock rlock (this);
+ AnalysisFeatureList points;
+ AnalysisFeatureList these_points;
-Region*
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if (dir > 0) {
+ if ((*i)->last_frame() < from) {
+ continue;
+ }
+ } else {
+ if ((*i)->first_frame() > from) {
+ continue;
+ }
+ }
+
+ (*i)->get_transients (these_points);
+
+ /* add first frame, just, err, because */
+
+ these_points.push_back ((*i)->first_frame());
+
+ points.insert (points.end(), these_points.begin(), these_points.end());
+ these_points.clear ();
+ }
+
+ if (points.empty()) {
+ return -1;
+ }
+
+ TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0);
+ bool reached = false;
+
+ if (dir > 0) {
+ for (AnalysisFeatureList::iterator x = points.begin(); x != points.end(); ++x) {
+ if ((*x) >= from) {
+ reached = true;
+ }
+
+ if (reached && (*x) > from) {
+ return *x;
+ }
+ }
+ } else {
+ for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) {
+ if ((*x) <= from) {
+ reached = true;
+ }
+
+ if (reached && (*x) < from) {
+ return *x;
+ }
+ }
+ }
-Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir)
+ return -1;
+}
+
+boost::shared_ptr<Region>
+Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir)
{
RegionLock rlock (this);
- Region* ret = 0;
- jack_nframes_t closest = max_frames;
+ boost::shared_ptr<Region> ret;
+ nframes_t closest = max_frames;
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- jack_nframes_t distance;
- Region* r = (*i);
- jack_nframes_t pos = 0;
+ nframes_t distance;
+ boost::shared_ptr<Region> r = (*i);
+ nframes_t pos = 0;
switch (point) {
case Start:
switch (dir) {
case 1: /* forwards */
- if (pos > frame) {
+ if (pos >= frame) {
if ((distance = pos - frame) < closest) {
closest = distance;
ret = r;
default: /* backwards */
- if (pos < frame) {
+ if (pos <= frame) {
if ((distance = frame - pos) < closest) {
closest = distance;
ret = r;
return ret;
}
+nframes64_t
+Playlist::find_next_region_boundary (nframes64_t frame, int dir)
+{
+ RegionLock rlock (this);
+
+ nframes64_t closest = max_frames;
+ nframes64_t ret = -1;
+
+ 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) {
+
+ distance = end - frame;
+
+ if (distance < closest) {
+ ret = end;
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (reset) {
+ break;
+ }
+ }
+
+ } else {
+
+ for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) {
+
+ boost::shared_ptr<Region> r = (*i);
+ nframes64_t distance;
+ bool reset;
+
+ reset = false;
+
+ if (r->last_frame() < frame) {
+
+ distance = frame - r->last_frame();
+
+ if (distance < closest) {
+ ret = r->last_frame();
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (r->first_frame() < frame) {
+ distance = frame - r->last_frame();
+
+ if (distance < closest) {
+ ret = r->first_frame();
+ closest = distance;
+ reset = true;
+ }
+ }
+
+ if (reset) {
+ break;
+ }
+ }
+ }
+
+ return ret;
+}
+
/***********************************************************************/
int
Playlist::set_state (const XMLNode& node)
{
- in_set_state = true;
-
XMLNode *child;
XMLNodeList nlist;
XMLNodeConstIterator niter;
XMLPropertyList plist;
XMLPropertyConstIterator piter;
XMLProperty *prop;
- Region *region;
+ boost::shared_ptr<Region> region;
string region_name;
- clear (false, false);
+ in_set_state++;
if (node.name() != "Playlist") {
- in_set_state = false;
+ in_set_state--;
return -1;
}
+ freeze ();
+
plist = node.properties();
for (piter = plist.begin(); piter != plist.end(); ++piter) {
}
}
+ clear (false);
+
nlist = node.children();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if (child->name() == "Region") {
- if ((region = createRegion (_session, *child, true)) == 0) {
- error << _("Playlist: cannot create region from state file") << endmsg;
+ if ((prop = child->property ("id")) == 0) {
+ error << _("region state node has no ID, ignored") << endmsg;
continue;
}
+
+ ID id = prop->value ();
+
+ if ((region = region_by_id (id))) {
+
+ Change what_changed = Change (0);
+
+ if (region->set_live_state (*child, what_changed, true)) {
+ error << _("Playlist: cannot reset region state from XML") << endmsg;
+ continue;
+ }
- add_region (*region, region->position(), 1.0, false);
+ } else if ((region = RegionFactory::create (_session, *child, true)) == 0) {
+ error << _("Playlist: cannot create region from XML") << endmsg;
+ continue;
+ }
+
+ add_region (region, region->position(), 1.0);
// So that layer_op ordering doesn't get screwed up
region->set_last_layer_op( region->layer());
}
}
-
+ notify_modified ();
+
+ thaw ();
+
/* update dependents, which was not done during add_region_internal
due to in_set_state being true
*/
for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) {
- check_dependents (**r, false);
+ check_dependents (*r, false);
}
-
- in_set_state = false;
+ in_set_state--;
+ first_set_state = false;
return 0;
}
char buf[64];
node->add_property (X_("name"), _name);
+ node->add_property (X_("type"), _type.to_string());
- _orig_diskstream_id.print (buf);
+ _orig_diskstream_id.print (buf, sizeof (buf));
node->add_property (X_("orig_diskstream_id"), buf);
node->add_property (X_("frozen"), _frozen ? "yes" : "no");
if (full_state) {
RegionLock rlock (this, false);
-
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
node->add_child_nocopy ((*i)->get_state());
}
bool
Playlist::empty() const
{
+ RegionLock rlock (const_cast<Playlist *>(this), false);
return regions.empty();
}
-jack_nframes_t
+uint32_t
+Playlist::n_regions() const
+{
+ RegionLock rlock (const_cast<Playlist *>(this), false);
+ return regions.size();
+}
+
+nframes_t
Playlist::get_maximum_extent () const
{
- RegionLock rlock (const_cast<Playlist *>(this));
+ RegionLock rlock (const_cast<Playlist *>(this), false);
return _get_maximum_extent ();
}
-jack_nframes_t
+ARDOUR::nframes_t
Playlist::_get_maximum_extent () const
{
RegionList::const_iterator i;
- jack_nframes_t max_extent = 0;
- jack_nframes_t end = 0;
+ nframes_t max_extent = 0;
+ nframes_t end = 0;
for (i = regions.begin(); i != regions.end(); ++i) {
if ((end = (*i)->position() + (*i)->length()) > max_extent) {
string newname = name;
do {
- newname = Playlist::bump_name_once (newname);
- } while (session.playlist_by_name(newname)!=NULL);
+ newname = bump_name_once (newname);
+ } while (session.playlist_by_name (newname)!=NULL);
return newname;
}
-string
-Playlist::bump_name_once (string name)
-{
- string::size_type period;
- string newname;
-
- if ((period = name.find_last_of ('.')) == string::npos) {
- newname = name;
- newname += ".1";
- } else {
- char buf[32];
- int version;
-
- sscanf (name.substr (period+1).c_str(), "%d", &version);
- snprintf (buf, sizeof(buf), "%d", version+1);
-
- newname = name.substr (0, period+1);
- newname += buf;
- }
-
- return newname;
-}
layer_t
Playlist::top_layer() const
void
Playlist::relayer ()
{
- RegionList::iterator i;
- uint32_t layer = 0;
-
/* don't send multiple Modified notifications
when multiple regions are relayered.
*/
-
+
freeze ();
- if (_session.get_layer_model() == Session::MoveAddHigher ||
- _session.get_layer_model() == Session::AddHigher) {
+ /* build up a new list of regions on each layer */
- RegionSortByLastLayerOp cmp;
- RegionList copy = regions;
+ std::vector<RegionList> layers;
+
+ /* we want to go through regions from desired lowest to desired highest layer,
+ which depends on the layer model
+ */
+
+ RegionList copy = regions;
+ /* sort according to the model */
+
+ if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
+ RegionSortByLastLayerOp cmp;
copy.sort (cmp);
+ }
+
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+
+ /* find the lowest layer that this region can go on */
+ size_t j = layers.size();
+ while (j > 0) {
+ /* try layer j - 1; it can go on if it overlaps no other region
+ that is already on that layer
+ */
+ RegionList::iterator k = layers[j - 1].begin();
+ while (k != layers[j - 1].end()) {
+ if ((*k)->overlap_equivalent (*i)) {
+ break;
+ }
+ k++;
+ }
- for (i = copy.begin(); i != copy.end(); ++i) {
- (*i)->set_layer (layer++);
+ if (k != layers[j - 1].end()) {
+ /* no overlap, so we can use this layer */
+ break;
+ }
+
+ j--;
}
- } else {
-
- /* Session::LaterHigher model */
+ if (j == layers.size()) {
+ /* we need a new layer for this region */
+ layers.push_back (RegionList ());
+ }
- for (i = regions.begin(); i != regions.end(); ++i) {
- (*i)->set_layer (layer++);
+ layers[j].push_back (*i);
+ }
+
+ /* first pass: set up the layer numbers in the regions */
+ for (size_t j = 0; j < layers.size(); ++j) {
+ for (RegionList::iterator i = layers[j].begin(); i != layers[j].end(); ++i) {
+ (*i)->set_layer (j);
}
}
/* XXX these layer functions are all deprecated */
void
-Playlist::raise_region (Region& region)
+Playlist::raise_region (boost::shared_ptr<Region> region)
{
uint32_t rsz = regions.size();
- layer_t target = region.layer() + 1U;
+ layer_t target = region->layer() + 1U;
if (target >= rsz) {
/* its already at the effective top */
}
void
-Playlist::lower_region (Region& region)
+Playlist::lower_region (boost::shared_ptr<Region> region)
{
- if (region.layer() == 0) {
+ if (region->layer() == 0) {
/* its already at the bottom */
return;
}
- layer_t target = region.layer() - 1U;
+ layer_t target = region->layer() - 1U;
move_region_to_layer (target, region, -1);
}
void
-Playlist::raise_region_to_top (Region& region)
+Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.get_layer_model() == Session::MoveAddHigher) ||
- (_session.get_layer_model() == Session::AddHigher)) {
+ if ((Config->get_layer_model() == MoveAddHigher) ||
+ (Config->get_layer_model() == AddHigher)) {
timestamp_layer_op (region);
relayer ();
}
}
void
-Playlist::lower_region_to_bottom (Region& region)
+Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.get_layer_model() == Session::MoveAddHigher) ||
- (_session.get_layer_model() == Session::AddHigher)) {
- region.set_last_layer_op (0);
+ if ((Config->get_layer_model() == MoveAddHigher) ||
+ (Config->get_layer_model() == AddHigher)) {
+ region->set_last_layer_op (0);
relayer ();
}
}
int
-Playlist::move_region_to_layer (layer_t target_layer, Region& region, int dir)
+Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr<Region> region, int dir)
{
RegionList::iterator i;
- typedef pair<Region*,layer_t> LayerInfo;
+ typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
list<LayerInfo> layerinfo;
layer_t dest;
for (i = regions.begin(); i != regions.end(); ++i) {
- if (®ion == *i) {
+ if (region == *i) {
continue;
}
down 1
*/
- if ((*i)->layer() > region.layer() && (*i)->layer() <= target_layer) {
+ if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) {
dest = (*i)->layer() - 1;
} else {
/* not affected */
up 1
*/
- if ((*i)->layer() < region.layer() && (*i)->layer() >= target_layer) {
+ if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) {
dest = (*i)->layer() + 1;
} else {
/* not affected */
x->first->set_layer (x->second);
}
- region.set_layer (target_layer);
+ region->set_layer (target_layer);
+#if 0
/* now check all dependents */
for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
- check_dependents (*(x->first), false);
+ check_dependents (x->first, false);
}
check_dependents (region, false);
+#endif
return 0;
}
void
-Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards)
+Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards)
{
RegionList::iterator i;
- jack_nframes_t new_pos;
+ nframes_t new_pos;
bool moved = false;
_nudging = true;
if (moved) {
_nudging = false;
- maybe_save_state (_("nudged"));
notify_length_changed ();
}
}
-Region*
+boost::shared_ptr<Region>
Playlist::find_region (const ID& id) const
{
RegionLock rlock (const_cast<Playlist*> (this));
- RegionList::const_iterator i;
-
- for (i = regions.begin(); i != regions.end(); ++i) {
+
+ /* searches all regions currently in use by the playlist */
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->id() == id) {
- return (*i);
+ return *i;
}
}
- return 0;
+ return boost::shared_ptr<Region> ();
}
-
-void
-Playlist::save_state (std::string why)
+
+boost::shared_ptr<Region>
+Playlist::region_by_id (ID id)
{
- if (!in_set_state) {
- StateManager::save_state (why);
+ /* searches all regions ever added to this playlist */
+
+ for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+ if ((*i)->id() == id) {
+ return *i;
+ }
}
+ return boost::shared_ptr<Region> ();
}
-
+
void
Playlist::dump () const
{
- Region *r;
+ boost::shared_ptr<Region> r;
cerr << "Playlist \"" << _name << "\" " << endl
<< regions.size() << " regions "
}
void
-Playlist::timestamp_layer_op (Region& region)
+Playlist::timestamp_layer_op (boost::shared_ptr<Region> region)
{
// struct timeval tv;
// gettimeofday (&tv, 0);
- region.set_last_layer_op (++layer_op_counter);
+ region->set_last_layer_op (++layer_op_counter);
}
+
void
-Playlist::maybe_save_state (string why)
+Playlist::shuffle (boost::shared_ptr<Region> region, int dir)
{
- if (holding_state ()) {
- save_on_thaw = true;
- last_save_reason = why;
- } else {
- save_state (why);
+ bool moved = false;
+ nframes_t new_pos;
+
+ if (region->locked()) {
+ return;
}
+
+ _shuffling = true;
+
+ {
+ RegionLock rlock (const_cast<Playlist*> (this));
+
+
+ if (dir > 0) {
+
+ RegionList::iterator next;
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i) == region) {
+ next = i;
+ ++next;
+
+ if (next != regions.end()) {
+
+ if ((*next)->locked()) {
+ break;
+ }
+
+ if ((*next)->position() != region->last_frame() + 1) {
+ /* they didn't used to touch, so after shuffle,
+ just have them swap positions.
+ */
+ new_pos = (*next)->position();
+ } else {
+ /* they used to touch, so after shuffle,
+ make sure they still do. put the earlier
+ region where the later one will end after
+ it is moved.
+ */
+ new_pos = region->position() + (*next)->length();
+ }
+
+ (*next)->set_position (region->position(), this);
+ region->set_position (new_pos, this);
+
+ /* avoid a full sort */
+
+ regions.erase (i); // removes the region from the list */
+ next++;
+ regions.insert (next, region); // adds it back after next
+
+ moved = true;
+ }
+ break;
+ }
+ }
+ } else {
+
+ RegionList::iterator prev = regions.end();
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); prev = i, ++i) {
+ if ((*i) == region) {
+
+ if (prev != regions.end()) {
+
+ if ((*prev)->locked()) {
+ break;
+ }
+
+ if (region->position() != (*prev)->last_frame() + 1) {
+ /* they didn't used to touch, so after shuffle,
+ just have them swap positions.
+ */
+ new_pos = region->position();
+ } else {
+ /* they used to touch, so after shuffle,
+ make sure they still do. put the earlier
+ one where the later one will end after
+ */
+ new_pos = (*prev)->position() + region->length();
+ }
+
+ region->set_position ((*prev)->position(), this);
+ (*prev)->set_position (new_pos, this);
+
+ /* avoid a full sort */
+
+ regions.erase (i); // remove region
+ regions.insert (prev, region); // insert region before prev
+
+ moved = true;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ _shuffling = false;
+
+ if (moved) {
+
+ relayer ();
+ check_dependents (region, false);
+
+ notify_modified();
+ }
+
+}
+
+bool
+Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+
+ if (regions.size() > 1) {
+ return true;
+ }
+
+ return false;
+}
+
+void
+Playlist::update_after_tempo_map_change ()
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+ RegionList copy (regions);
+
+ freeze ();
+
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+ (*i)->update_position_after_tempo_map_change ();
+ }
+
+ thaw ();
}
projects / ardour.git / blobdiff