#include <algorithm>
#include <sstream>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
#include "pbd/xml++.h"
-#include "pbd/stacktrace.h"
-#include "pbd/enumwriter.h"
#include "ardour/debug.h"
-#include "ardour/file_source.h"
#include "ardour/filter.h"
#include "ardour/playlist.h"
#include "ardour/playlist_source.h"
#include "ardour/region_factory.h"
#include "ardour/session.h"
#include "ardour/source.h"
-#include "ardour/source_factory.h"
#include "ardour/tempo.h"
-#include "ardour/utils.h"
+#include "ardour/transient_detector.h"
#include "i18n.h"
using namespace PBD;
namespace ARDOUR {
+ class Progress;
namespace Properties {
PBD::PropertyDescriptor<bool> muted;
PBD::PropertyDescriptor<bool> opaque;
PBD::PropertyDescriptor<bool> locked;
+ PBD::PropertyDescriptor<bool> video_locked;
PBD::PropertyDescriptor<bool> automatic;
PBD::PropertyDescriptor<bool> whole_file;
PBD::PropertyDescriptor<bool> import;
PBD::PropertyDescriptor<float> stretch;
PBD::PropertyDescriptor<float> shift;
PBD::PropertyDescriptor<PositionLockStyle> position_lock_style;
- PBD::PropertyDescriptor<framepos_t> last_relayer_bounds_from;
- PBD::PropertyDescriptor<framepos_t> last_relayer_bounds_to;
- PBD::PropertyDescriptor<uint64_t> last_layer_op_add;
- PBD::PropertyDescriptor<uint64_t> last_layer_op_bounds_change;
+ PBD::PropertyDescriptor<uint64_t> layering_index;
}
}
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for opaque = %1\n", Properties::opaque.property_id));
Properties::locked.property_id = g_quark_from_static_string (X_("locked"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for locked = %1\n", Properties::locked.property_id));
+ Properties::video_locked.property_id = g_quark_from_static_string (X_("video-locked"));
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for video-locked = %1\n", Properties::video_locked.property_id));
Properties::automatic.property_id = g_quark_from_static_string (X_("automatic"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for automatic = %1\n", Properties::automatic.property_id));
Properties::whole_file.property_id = g_quark_from_static_string (X_("whole-file"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for shift = %1\n", Properties::shift.property_id));
Properties::position_lock_style.property_id = g_quark_from_static_string (X_("positional-lock-style"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for position_lock_style = %1\n", Properties::position_lock_style.property_id));
- Properties::last_relayer_bounds_from.property_id = g_quark_from_static_string (X_("last-relayer-bounds-from"));
- DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for last_relayer_bounds_from = %1\n", Properties::last_relayer_bounds_from.property_id));
- Properties::last_relayer_bounds_to.property_id = g_quark_from_static_string (X_("last-relayer-bounds-to"));
- DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for last_relayer_bounds_to = %1\n", Properties::last_relayer_bounds_to.property_id));
- Properties::last_layer_op_add.property_id = g_quark_from_static_string (X_("last-layer-op-add"));
- DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for last_layer_op_add = %1\n", Properties::last_layer_op_add.property_id));
- Properties::last_layer_op_bounds_change.property_id = g_quark_from_static_string (X_("last-layer-op-bounds-change"));
- DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for last_layer_op_bounds_change = %1\n", Properties::last_layer_op_bounds_change.property_id));
+ Properties::layering_index.property_id = g_quark_from_static_string (X_("layering-index"));
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for layering_index = %1\n", Properties::layering_index.property_id));
}
void
add_property (_muted);
add_property (_opaque);
add_property (_locked);
+ add_property (_video_locked);
add_property (_automatic);
add_property (_whole_file);
add_property (_import);
add_property (_length);
add_property (_position);
add_property (_sync_position);
- add_property (_layer);
add_property (_ancestral_start);
add_property (_ancestral_length);
add_property (_stretch);
add_property (_shift);
add_property (_position_lock_style);
- add_property (_last_relayer_bounds_from);
- add_property (_last_relayer_bounds_to);
- add_property (_last_layer_op_add);
- add_property (_last_layer_op_bounds_change);
+ add_property (_layering_index);
}
#define REGION_DEFAULT_STATE(s,l) \
, _length (Properties::length, (l)) \
, _position (Properties::position, 0) \
, _sync_position (Properties::sync_position, (s)) \
- , _layer (Properties::layer, 0) \
+ , _transient_user_start (0) \
+ , _transient_analysis_start (0) \
+ , _transient_analysis_end (0) \
, _muted (Properties::muted, false) \
, _opaque (Properties::opaque, true) \
, _locked (Properties::locked, false) \
+ , _video_locked (Properties::video_locked, false) \
, _automatic (Properties::automatic, false) \
, _whole_file (Properties::whole_file, false) \
, _import (Properties::import, false) \
, _stretch (Properties::stretch, 1.0) \
, _shift (Properties::shift, 1.0) \
, _position_lock_style (Properties::position_lock_style, _type == DataType::AUDIO ? AudioTime : MusicTime) \
- , _last_relayer_bounds_from (Properties::last_relayer_bounds_from, 0) \
- , _last_relayer_bounds_to (Properties::last_relayer_bounds_to, 0) \
- , _last_layer_op_add (Properties::last_layer_op_add, 0) \
- , _last_layer_op_bounds_change (Properties::last_layer_op_bounds_change, 0)
+ , _layering_index (Properties::layering_index, 0)
#define REGION_COPY_STATE(other) \
_sync_marked (Properties::sync_marked, other->_sync_marked) \
, _length(Properties::length, other->_length) \
, _position(Properties::position, other->_position) \
, _sync_position(Properties::sync_position, other->_sync_position) \
- , _layer (Properties::layer, other->_layer) \
- , _muted (Properties::muted, other->_muted) \
+ , _user_transients (other->_user_transients) \
+ , _transient_user_start (other->_transient_user_start) \
+ , _transients (other->_transients) \
+ , _transient_analysis_start (other->_transient_analysis_start) \
+ , _transient_analysis_end (other->_transient_analysis_end) \
+ , _muted (Properties::muted, other->_muted) \
, _opaque (Properties::opaque, other->_opaque) \
, _locked (Properties::locked, other->_locked) \
+ , _video_locked (Properties::video_locked, other->_video_locked) \
, _automatic (Properties::automatic, other->_automatic) \
, _whole_file (Properties::whole_file, other->_whole_file) \
, _import (Properties::import, other->_import) \
, _stretch (Properties::stretch, other->_stretch) \
, _shift (Properties::shift, other->_shift) \
, _position_lock_style (Properties::position_lock_style, other->_position_lock_style) \
- , _last_relayer_bounds_from (Properties::last_relayer_bounds_from, other->_last_relayer_bounds_from) \
- , _last_relayer_bounds_to (Properties::last_relayer_bounds_to, other->_last_relayer_bounds_to) \
- , _last_layer_op_add (Properties::last_layer_op_add, other->_last_layer_op_add) \
- , _last_layer_op_bounds_change (Properties::last_layer_op_bounds_change, other->_last_layer_op_bounds_change)
+ , _layering_index (Properties::layering_index, other->_layering_index)
/* derived-from-derived constructor (no sources in constructor) */
Region::Region (Session& s, framepos_t start, framecnt_t length, const string& name, DataType type)
, _last_length (length)
, _last_position (0)
, _first_edit (EditChangesNothing)
+ , _layer (0)
{
register_properties ();
+
/* no sources at this point */
}
, _last_length (0)
, _last_position (0)
, _first_edit (EditChangesNothing)
+ , _layer (0)
{
register_properties ();
, _last_length (other->_last_length)
, _last_position(other->_last_position) \
, _first_edit (EditChangesNothing)
+ , _layer (other->_layer)
{
register_properties ();
_hidden = false;
use_sources (other->_sources);
+ set_master_sources (other->_master_sources);
_position_lock_style = other->_position_lock_style;
_first_edit = other->_first_edit;
_sync_position = _start;
}
- if (Profile->get_sae()) {
- /* reset sync point to start if its ended up
- outside region bounds.
- */
-
- if (_sync_position < _start || _sync_position >= _start + _length) {
- _sync_marked = false;
- _sync_position = _start;
- }
- }
-
assert (_type == other->data_type());
}
, _last_length (other->_last_length)
, _last_position(other->_last_position) \
, _first_edit (EditChangesNothing)
+ , _layer (other->_layer)
{
register_properties ();
_hidden = false;
use_sources (other->_sources);
+ set_master_sources (other->_master_sources);
_start = other->_start + offset;
_sync_position = _start;
}
- if (Profile->get_sae()) {
- /* reset sync point to start if its ended up
- outside region bounds.
- */
-
- if (_sync_position < _start || _sync_position >= _start + _length) {
- _sync_marked = false;
- _sync_position = _start;
- }
- }
-
assert (_type == other->data_type());
}
, _last_length (other->_last_length)
, _last_position (other->_last_position)
, _first_edit (EditChangesID)
+ , _layer (other->_layer)
{
register_properties ();
_whole_file = false;
first_edit ();
maybe_uncopy ();
- invalidate_transients ();
+ maybe_invalidate_transients ();
if (!property_changes_suspended()) {
recompute_at_end ();
_position_lock_style = ps;
if (_position_lock_style == MusicTime) {
- _session.tempo_map().bbt_time (_position, _bbt_time);
+ _beat = _session.tempo_map().beat_at_frame (_position);
}
send_change (Properties::position_lock_style);
}
void
-Region::update_after_tempo_map_change ()
+Region::update_after_tempo_map_change (bool send)
{
boost::shared_ptr<Playlist> pl (playlist());
return;
}
- TempoMap& map (_session.tempo_map());
- framepos_t pos = map.frame_time (_bbt_time);
+ const framepos_t pos = _session.tempo_map().frame_at_beat (_beat);
set_position_internal (pos, false);
/* do this even if the position is the same. this helps out
a GUI that has moved its representation already.
*/
- send_change (Properties::position);
+
+ if (send) {
+ send_change (Properties::position);
+ }
}
void
}
+/** A gui may need to create a region, then place it in an initial
+ * position determined by the user.
+ * When this takes place within one gui operation, we have to reset
+ * _last_position to prevent an implied move.
+ */
+void
+Region::set_initial_position (framepos_t pos)
+{
+ if (!can_move()) {
+ return;
+ }
+
+ if (_position != pos) {
+ _position = pos;
+
+ /* check that the new _position wouldn't make the current
+ length impossible - if so, change the length.
+
+ XXX is this the right thing to do?
+ */
+
+ if (max_framepos - _length < _position) {
+ _last_length = _length;
+ _length = max_framepos - _position;
+ }
+
+ recompute_position_from_lock_style ();
+ /* ensure that this move doesn't cause a range move */
+ _last_position = _position;
+ }
+
+
+ /* do this even if the position is the same. this helps out
+ a GUI that has moved its representation already.
+ */
+ send_change (Properties::position);
+}
+
void
Region::set_position_internal (framepos_t pos, bool allow_bbt_recompute)
{
e.g. Playlist::notify_region_moved doesn't use an out-of-date last_position.
*/
_last_position = _position;
-
+
if (_position != pos) {
_position = pos;
if (allow_bbt_recompute) {
recompute_position_from_lock_style ();
}
-
- //invalidate_transients ();
}
}
Region::recompute_position_from_lock_style ()
{
if (_position_lock_style == MusicTime) {
- _session.tempo_map().bbt_time (_position, _bbt_time);
+ _beat = _session.tempo_map().beat_at_frame (_position);
}
}
void
Region::nudge_position (frameoffset_t n)
{
- if (locked()) {
+ if (locked() || video_locked()) {
return;
}
void
Region::set_start (framepos_t pos)
{
- if (locked() || position_locked()) {
+ if (locked() || position_locked() || video_locked()) {
return;
}
/* This just sets the start, nothing else. It effectively shifts
return;
}
- _start = pos;
+ set_start_internal (pos);
_whole_file = false;
first_edit ();
- invalidate_transients ();
+ maybe_invalidate_transients ();
send_change (Properties::start);
}
}
void
-Region::trim_start (framepos_t new_position)
+Region::move_start (frameoffset_t distance)
{
- if (locked() || position_locked()) {
+ if (locked() || position_locked() || video_locked()) {
return;
}
+
framepos_t new_start;
- frameoffset_t const start_shift = new_position - _position;
- if (start_shift > 0) {
+ if (distance > 0) {
- if (_start > max_framepos - start_shift) {
- new_start = max_framepos;
+ if (_start > max_framepos - distance) {
+ new_start = max_framepos; // makes no sense
} else {
- new_start = _start + start_shift;
+ new_start = _start + distance;
}
if (!verify_start (new_start)) {
return;
}
- } else if (start_shift < 0) {
+ } else if (distance < 0) {
- if (_start < -start_shift) {
+ if (_start < -distance) {
new_start = 0;
} else {
- new_start = _start + start_shift;
+ new_start = _start + distance;
}
} else {
return;
}
- _start = new_start;
+ set_start_internal (new_start);
+
_whole_file = false;
first_edit ();
if (new_position < end) { /* can't trim it zero or negative length */
framecnt_t newlen = 0;
- framepos_t delta = 0;
if (!can_trim_start_before_source_start ()) {
/* can't trim it back past where source position zero is located */
if (new_position > _position) {
newlen = _length - (new_position - _position);
- delta = -1 * (new_position - _position);
} else {
newlen = _length + (_position - new_position);
- delta = _position - new_position;
}
trim_to_internal (new_position, newlen);
recompute_at_start ();
}
- if (_transients.size() > 0){
- adjust_transients(delta);
- }
+ maybe_invalidate_transients ();
}
}
PropertyChange what_changed;
if (_start != new_start) {
- _start = new_start;
+ set_start_internal (new_start);
what_changed.add (Properties::start);
}
}
}
+void
+Region::set_video_locked (bool yn)
+{
+ if (video_locked() != yn) {
+ _video_locked = yn;
+ send_change (Properties::video_locked);
+ }
+}
+
void
Region::set_position_locked (bool yn)
{
void
Region::set_layer (layer_t l)
{
- if (_layer != l) {
- _layer = l;
- send_change (Properties::layer);
- }
-
- Evoral::Range<framepos_t> const b = bounds ();
- _last_relayer_bounds_from = b.from;
- _last_relayer_bounds_to = b.to;
+ _layer = l;
}
XMLNode&
XMLNode *node = new XMLNode ("Region");
char buf[64];
char buf2[64];
- LocaleGuard lg (X_("POSIX"));
+ LocaleGuard lg;
const char* fe = NULL;
- add_properties (*node);
+ /* custom version of 'add_properties (*node);'
+ * skip values that have have dedicated save functions
+ * in AudioRegion::state()
+ */
+ for (OwnedPropertyList::iterator i = _properties->begin(); i != _properties->end(); ++i) {
+ if (!strcmp(i->second->property_name(), (const char*)"Envelope")) continue;
+ if (!strcmp(i->second->property_name(), (const char*)"FadeIn")) continue;
+ if (!strcmp(i->second->property_name(), (const char*)"FadeOut")) continue;
+ if (!strcmp(i->second->property_name(), (const char*)"InverseFadeIn")) continue;
+ if (!strcmp(i->second->property_name(), (const char*)"InverseFadeOut")) continue;
+ i->second->get_value (*node);
+ }
id().print (buf, sizeof (buf));
node->add_property ("id", buf);
/* note: flags are stored by derived classes */
if (_position_lock_style != AudioTime) {
- stringstream str;
- str << _bbt_time;
- node->add_property ("bbt-position", str.str());
+ snprintf (buf, sizeof(buf), "%lf", _beat);
+ node->add_property ("beat", buf);
}
for (uint32_t n=0; n < _sources.size(); ++n) {
int
Region::_set_state (const XMLNode& node, int /*version*/, PropertyChange& what_changed, bool send)
{
- const XMLProperty* prop;
+ XMLProperty const * prop;
+ Timecode::BBT_Time bbt_time;
Stateful::save_extra_xml (node);
if (_position_lock_style == MusicTime) {
if ((prop = node.property ("bbt-position")) == 0) {
- /* missing BBT info, revert to audio time locking */
- _position_lock_style = AudioTime;
+ if ((prop = node.property ("beat")) == 0) {
+ /* missing BBT info, revert to audio time locking */
+ _position_lock_style = AudioTime;
+ } else {
+ if (sscanf (prop->value().c_str(), "%lf", &_beat) != 1) {
+ _position_lock_style = AudioTime;
+ }
+ }
+
} else {
if (sscanf (prop->value().c_str(), "%d|%d|%d",
- &_bbt_time.bars,
- &_bbt_time.beats,
- &_bbt_time.ticks) != 3) {
+ &bbt_time.bars,
+ &bbt_time.beats,
+ &bbt_time.ticks) != 3) {
_position_lock_style = AudioTime;
+ } else {
+ _beat = _session.tempo_map().beat_at_bbt (bbt_time);
}
}
}
}
}
+ // saved property is invalid, region-transients are not saved
+ if (_user_transients.size() == 0){
+ _valid_transients = false;
+ }
return 0;
}
}
}
-void
-Region::set_last_layer_op (LayerOp op, uint64_t when)
-{
- switch (op) {
- case LayerOpAdd:
- _last_layer_op_add = when;
- break;
- case LayerOpBoundsChange:
- _last_layer_op_bounds_change = when;
- break;
- }
-}
-
bool
Region::overlap_equivalent (boost::shared_ptr<const Region> other) const
{
- return coverage (other->first_frame(), other->last_frame()) != OverlapNone;
+ return coverage (other->first_frame(), other->last_frame()) != Evoral::OverlapNone;
}
bool
return true;
}
+bool
+Region::any_source_equivalent (boost::shared_ptr<const Region> other) const
+{
+ if (!other) {
+ return false;
+ }
+
+ SourceList::const_iterator i;
+ SourceList::const_iterator io;
+
+ for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
+ if ((*i)->id() == (*io)->id()) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
std::string
Region::source_string () const
{
}
}
+ for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+ if (*i == source) {
+ return true;
+ }
+
+ boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
+
+ if (ps) {
+ if (ps->playlist()->uses_source (source)) {
+ return true;
+ }
+ }
+ }
+
return false;
}
}
bool
-Region::verify_length (framecnt_t len)
+Region::verify_length (framecnt_t& len)
{
if (source() && (source()->destructive() || source()->length_mutable())) {
return true;
void
-Region::invalidate_transients ()
+Region::maybe_invalidate_transients ()
+{
+ bool changed = !_onsets.empty();
+ _onsets.clear ();
+
+ if (_valid_transients || changed) {
+ send_change (PropertyChange (Properties::valid_transients));
+ return;
+ }
+}
+
+void
+Region::transients (AnalysisFeatureList& afl)
{
- _valid_transients = false;
- _transients.clear ();
+ int cnt = afl.empty() ? 0 : 1;
+
+ Region::merge_features (afl, _onsets, _position);
+ Region::merge_features (afl, _user_transients, _position + _transient_user_start - _start);
+ if (!_onsets.empty ()) {
+ ++cnt;
+ }
+ if (!_user_transients.empty ()) {
+ ++cnt;
+ }
+ if (cnt > 1 ) {
+ afl.sort ();
+ // remove exact duplicates
+ TransientDetector::cleanup_transients (afl, _session.frame_rate(), 0);
+ }
+}
- send_change (PropertyChange (Properties::valid_transients));
+bool
+Region::has_transients () const
+{
+ if (!_user_transients.empty ()) {
+ assert (_valid_transients);
+ return true;
+ }
+ if (!_onsets.empty ()) {
+ return true;
+ }
+ return false;
+}
+
+void
+Region::merge_features (AnalysisFeatureList& result, const AnalysisFeatureList& src, const frameoffset_t off) const
+{
+ for (AnalysisFeatureList::const_iterator x = src.begin(); x != src.end(); ++x) {
+ const frameoffset_t p = (*x) + off;
+ if (p < first_frame() || p > last_frame()) {
+ continue;
+ }
+ result.push_back (p);
+ }
}
void
}
}
-uint64_t
-Region::last_layer_op (LayerOp op) const
+void
+Region::set_start_internal (framecnt_t s)
{
- switch (op) {
- case LayerOpAdd:
- return _last_layer_op_add;
- case LayerOpBoundsChange:
- return _last_layer_op_bounds_change;
- }
+ _start = s;
+}
- /* NOTREACHED */
- return 0;
+framepos_t
+Region::earliest_possible_position () const
+{
+ if (_start > _position) {
+ return 0;
+ } else {
+ return _position - _start;
+ }
}
-Evoral::Range<framepos_t>
-Region::bounds () const
+framecnt_t
+Region::latest_possible_frame () const
{
- return Evoral::Range<framepos_t> (_position, _position + _length);
+ framecnt_t minlen = max_framecnt;
+
+ for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+ /* non-audio regions have a length that may vary based on their
+ * position, so we have to pass it in the call.
+ */
+ minlen = min (minlen, (*i)->length (_position));
+ }
+
+ /* the latest possible last frame is determined by the current
+ * position, plus the shortest source extent past _start.
+ */
+
+ return _position + (minlen - _start) - 1;
}
-