X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudioregion.cc;h=9f76b0f19ed7287af598fa64ec4bd8438ecf16b7;hb=3150041423a199189c9b6ab292a078c51d9670c2;hp=e40313088279161eb4eee4591ba69cd5fcd5b2f3;hpb=b94f199970e442b9fc8ae87702babf21677692ec;p=ardour.git diff --git a/libs/ardour/audioregion.cc b/libs/ardour/audioregion.cc index e403130882..7cc8e00998 100644 --- a/libs/ardour/audioregion.cc +++ b/libs/ardour/audioregion.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2001 Paul Davis + Copyright (C) 2000-2006 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,490 +15,296 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include #include #include +#include #include -#include -#include #include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include +#include "pbd/basename.h" +#include "pbd/xml++.h" +#include "pbd/stacktrace.h" +#include "pbd/enumwriter.h" +#include "pbd/convert.h" + +#include "evoral/Curve.hpp" + +#include "ardour/audioregion.h" +#include "ardour/debug.h" +#include "ardour/session.h" +#include "ardour/gain.h" +#include "ardour/dB.h" +#include "ardour/playlist.h" +#include "ardour/audiofilesource.h" +#include "ardour/region_factory.h" +#include "ardour/runtime_functions.h" +#include "ardour/transient_detector.h" #include "i18n.h" #include using namespace std; using namespace ARDOUR; +using namespace PBD; -/* a Session will reset these to its chosen defaults by calling AudioRegion::set_default_fade() */ - -Change AudioRegion::FadeInChanged = ARDOUR::new_change(); -Change AudioRegion::FadeOutChanged = ARDOUR::new_change(); -Change AudioRegion::FadeInActiveChanged = ARDOUR::new_change(); -Change AudioRegion::FadeOutActiveChanged = ARDOUR::new_change(); -Change AudioRegion::EnvelopeActiveChanged = ARDOUR::new_change(); -Change AudioRegion::ScaleAmplitudeChanged = ARDOUR::new_change(); -Change AudioRegion::EnvelopeChanged = ARDOUR::new_change(); - -AudioRegionState::AudioRegionState (string why) - : RegionState (why), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) -{ +namespace ARDOUR { + namespace Properties { + PBD::PropertyDescriptor envelope_active; + PBD::PropertyDescriptor default_fade_in; + PBD::PropertyDescriptor default_fade_out; + PBD::PropertyDescriptor fade_in_active; + PBD::PropertyDescriptor fade_out_active; + PBD::PropertyDescriptor scale_amplitude; + } } -AudioRegion::AudioRegion (boost::shared_ptr src, nframes_t start, nframes_t length) - : Region (start, length, PBD::basename_nosuffix(src->name()), 0, Region::Flag(Region::DefaultFlags|Region::External)), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) +void +AudioRegion::make_property_quarks () { - /* basic AudioRegion constructor */ - - sources.push_back (src); - master_sources.push_back (src); - src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - - boost::shared_ptr afs = boost::dynamic_pointer_cast (src); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - - _scale_amplitude = 1.0; - - set_default_fades (); - set_default_envelope (); - - save_state ("initial state"); - - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + Properties::envelope_active.property_id = g_quark_from_static_string (X_("envelope-active")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for envelope-active = %1\n", Properties::envelope_active.property_id)); + Properties::default_fade_in.property_id = g_quark_from_static_string (X_("default-fade-in")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for default-fade-in = %1\n", Properties::default_fade_in.property_id)); + Properties::default_fade_out.property_id = g_quark_from_static_string (X_("default-fade-out")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for default-fade-out = %1\n", Properties::default_fade_out.property_id)); + Properties::fade_in_active.property_id = g_quark_from_static_string (X_("fade-in-active")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for fade-in-active = %1\n", Properties::fade_in_active.property_id)); + Properties::fade_out_active.property_id = g_quark_from_static_string (X_("fade-out-active")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for fade-out-active = %1\n", Properties::fade_out_active.property_id)); + Properties::scale_amplitude.property_id = g_quark_from_static_string (X_("scale-amplitude")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for scale-amplitude = %1\n", Properties::scale_amplitude.property_id)); } -AudioRegion::AudioRegion (boost::shared_ptr src, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags) - : Region (start, length, name, layer, flags), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) +void +AudioRegion::register_properties () { - /* basic AudioRegion constructor */ - - sources.push_back (src); - master_sources.push_back (src); - src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); + /* no need to register parent class properties */ + + add_property (_envelope_active); + add_property (_default_fade_in); + add_property (_default_fade_out); + add_property (_fade_in_active); + add_property (_fade_out_active); + add_property (_scale_amplitude); +} - boost::shared_ptr afs = boost::dynamic_pointer_cast (src); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } +#define AUDIOREGION_STATE_DEFAULT \ + _envelope_active (Properties::envelope_active, false) \ + , _default_fade_in (Properties::default_fade_in, true) \ + , _default_fade_out (Properties::default_fade_out, true) \ + , _fade_in_active (Properties::fade_in_active, true) \ + , _fade_out_active (Properties::fade_out_active, true) \ + , _scale_amplitude (Properties::scale_amplitude, 1.0) + +#define AUDIOREGION_COPY_STATE(other) \ + _envelope_active (Properties::envelope_active, other->_envelope_active) \ + , _default_fade_in (Properties::default_fade_in, other->_default_fade_in) \ + , _default_fade_out (Properties::default_fade_out, other->_default_fade_out) \ + , _fade_in_active (Properties::fade_in_active, other->_fade_in_active) \ + , _fade_out_active (Properties::fade_out_active, other->_fade_out_active) \ + , _scale_amplitude (Properties::scale_amplitude, other->_scale_amplitude) +/* a Session will reset these to its chosen defaults by calling AudioRegion::set_default_fade() */ - _scale_amplitude = 1.0; +void +AudioRegion::init () +{ + register_properties (); set_default_fades (); set_default_envelope (); - save_state ("initial state"); - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + listen_to_my_curves (); + connect_to_analysis_changed (); + connect_to_header_position_offset_changed (); } -AudioRegion::AudioRegion (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags) - : Region (start, length, name, layer, flags), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) +/** Constructor for use by derived types only */ +AudioRegion::AudioRegion (Session& s, framepos_t start, framecnt_t len, std::string name) + : Region (s, start, len, name, DataType::AUDIO) + , AUDIOREGION_STATE_DEFAULT + , _automatable (s) + , _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation))) + , _fade_out (new AutomationList(Evoral::Parameter(FadeOutAutomation))) + , _envelope (new AutomationList(Evoral::Parameter(EnvelopeAutomation))) + , _fade_in_suspended (0) + , _fade_out_suspended (0) { - /* basic AudioRegion constructor */ - - for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) { - sources.push_back (*i); - master_sources.push_back (*i); - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - - boost::shared_ptr afs = boost::dynamic_pointer_cast ((*i)); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - } - - _scale_amplitude = 1.0; - - set_default_fades (); - set_default_envelope (); - save_state ("initial state"); - - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + init (); + assert (_sources.size() == _master_sources.size()); } - -AudioRegion::AudioRegion (boost::shared_ptr other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags) - : Region (other, offset, length, name, layer, flags), - _fade_in (other->_fade_in), - _fade_out (other->_fade_out), - _envelope (other->_envelope, (double) offset, (double) offset + length) +/** Basic AudioRegion constructor */ +AudioRegion::AudioRegion (const SourceList& srcs) + : Region (srcs) + , AUDIOREGION_STATE_DEFAULT + , _automatable(srcs[0]->session()) + , _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation))) + , _fade_out (new AutomationList(Evoral::Parameter(FadeOutAutomation))) + , _envelope (new AutomationList(Evoral::Parameter(EnvelopeAutomation))) + , _fade_in_suspended (0) + , _fade_out_suspended (0) { - /* create a new AudioRegion, that is part of an existing one */ - - set > unique_srcs; - - for (SourceList::const_iterator i= other->sources.begin(); i != other->sources.end(); ++i) { - sources.push_back (*i); - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - - pair >::iterator,bool> result; - - result = unique_srcs.insert (*i); - - if (result.second) { - boost::shared_ptr afs = boost::dynamic_pointer_cast (*i); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - } - } - - for (SourceList::const_iterator i = other->master_sources.begin(); i != other->master_sources.end(); ++i) { - if (unique_srcs.find (*i) == unique_srcs.end()) { - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - } - master_sources.push_back (*i); - } - - /* return to default fades if the existing ones are too long */ - _fade_in_disabled = 0; - _fade_out_disabled = 0; - - - if (_flags & LeftOfSplit) { - if (_fade_in.back()->when >= _length) { - set_default_fade_in (); - } else { - _fade_in_disabled = other->_fade_in_disabled; - } - set_default_fade_out (); - _flags = Flag (_flags & ~Region::LeftOfSplit); - } - - if (_flags & RightOfSplit) { - if (_fade_out.back()->when >= _length) { - set_default_fade_out (); - } else { - _fade_out_disabled = other->_fade_out_disabled; - } - set_default_fade_in (); - _flags = Flag (_flags & ~Region::RightOfSplit); - } - - _scale_amplitude = other->_scale_amplitude; - - save_state ("initial state"); - - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + init (); + assert (_sources.size() == _master_sources.size()); } -AudioRegion::AudioRegion (boost::shared_ptr other) - : Region (other), - _fade_in (other->_fade_in), - _fade_out (other->_fade_out), - _envelope (other->_envelope) +AudioRegion::AudioRegion (boost::shared_ptr other, nframes64_t offset, bool offset_relative) + : Region (other, offset, offset_relative) + , AUDIOREGION_COPY_STATE (other) + , _automatable (other->session()) + , _fade_in (new AutomationList (*other->_fade_in)) + , _fade_out (new AutomationList (*other->_fade_out)) + /* As far as I can see, the _envelope's times are relative to region position, and have nothing + to do with sources (and hence _start). So when we copy the envelope, we just use the supplied offset. + */ + , _envelope (new AutomationList (*other->_envelope, offset, other->_length)) + , _fade_in_suspended (0) + , _fade_out_suspended (0) { - /* Pure copy constructor */ - - set > unique_srcs; - - for (SourceList::const_iterator i = other->sources.begin(); i != other->sources.end(); ++i) { - sources.push_back (*i); - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - pair >::iterator,bool> result; - - result = unique_srcs.insert (*i); - - if (result.second) { - boost::shared_ptr afs = boost::dynamic_pointer_cast (*i); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - } - } - - for (SourceList::const_iterator i = other->master_sources.begin(); i != other->master_sources.end(); ++i) { - master_sources.push_back (*i); - if (unique_srcs.find (*i) == unique_srcs.end()) { - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - } - } - - _scale_amplitude = other->_scale_amplitude; - _envelope = other->_envelope; - - _fade_in_disabled = 0; - _fade_out_disabled = 0; - - save_state ("initial state"); + /* don't use init here, because we got fade in/out from the other region + */ + register_properties (); + listen_to_my_curves (); + connect_to_analysis_changed (); + connect_to_header_position_offset_changed (); - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + assert(_type == DataType::AUDIO); + assert (_sources.size() == _master_sources.size()); } -AudioRegion::AudioRegion (boost::shared_ptr src, const XMLNode& node) - : Region (node), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) +AudioRegion::AudioRegion (boost::shared_ptr other, const SourceList& srcs) + : Region (boost::static_pointer_cast(other), srcs) + , AUDIOREGION_COPY_STATE (other) + , _automatable (other->session()) + , _fade_in (new AutomationList (*other->_fade_in)) + , _fade_out (new AutomationList (*other->_fade_out)) + , _envelope (new AutomationList (*other->_envelope)) + , _fade_in_suspended (0) + , _fade_out_suspended (0) { - sources.push_back (src); - master_sources.push_back (src); - src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - - boost::shared_ptr afs = boost::dynamic_pointer_cast (src); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - - set_default_fades (); + /* make-a-sort-of-copy-with-different-sources constructor (used by audio filter) */ - if (set_state (node)) { - throw failed_constructor(); - } + register_properties (); - save_state ("initial state"); + listen_to_my_curves (); + connect_to_analysis_changed (); + connect_to_header_position_offset_changed (); - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + assert (_sources.size() == _master_sources.size()); } -AudioRegion::AudioRegion (SourceList& srcs, const XMLNode& node) - : Region (node), - _fade_in (0.0, 2.0, 1.0, false), - _fade_out (0.0, 2.0, 1.0, false), - _envelope (0.0, 2.0, 1.0, false) +AudioRegion::AudioRegion (SourceList& srcs) + : Region (srcs) + , AUDIOREGION_STATE_DEFAULT + , _automatable(srcs[0]->session()) + , _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation))) + , _fade_out (new AutomationList(Evoral::Parameter(FadeOutAutomation))) + , _envelope (new AutomationList(Evoral::Parameter(EnvelopeAutomation))) + , _fade_in_suspended (0) + , _fade_out_suspended (0) { - set > unique_srcs; - - for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) { - sources.push_back (*i); - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - pair >::iterator,bool> result; - - result = unique_srcs.insert (*i); - - if (result.second) { - boost::shared_ptr afs = boost::dynamic_pointer_cast (*i); - if (afs) { - afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed)); - } - } - } - - for (SourceList::iterator i = srcs.begin(); i != srcs.end(); ++i) { - master_sources.push_back (*i); - if (unique_srcs.find (*i) == unique_srcs.end()) { - (*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted)); - } - } - - set_default_fades (); - _scale_amplitude = 1.0; - - if (set_state (node)) { - throw failed_constructor(); - } - - save_state ("initial state"); + init (); - _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed)); + assert(_type == DataType::AUDIO); + assert (_sources.size() == _master_sources.size()); } AudioRegion::~AudioRegion () { - GoingAway (); /* EMIT SIGNAL */ } -StateManager::State* -AudioRegion::state_factory (std::string why) const -{ - AudioRegionState* state = new AudioRegionState (why); - - Region::store_state (*state); - - state->_fade_in = _fade_in; - state->_fade_out = _fade_out; - state->_envelope = _envelope; - state->_scale_amplitude = _scale_amplitude; - state->_fade_in_disabled = _fade_in_disabled; - state->_fade_out_disabled = _fade_out_disabled; - - return state; -} - -Change -AudioRegion::restore_state (StateManager::State& sstate) +void +AudioRegion::post_set () { - AudioRegionState* state = dynamic_cast (&sstate); - - Change what_changed = Region::restore_and_return_flags (*state); - - if (_flags != Flag (state->_flags)) { - - uint32_t old_flags = _flags; - - _flags = Flag (state->_flags); - - if ((old_flags ^ state->_flags) & EnvelopeActive) { - what_changed = Change (what_changed|EnvelopeActiveChanged); - } - } - - if (!(_fade_in == state->_fade_in)) { - _fade_in = state->_fade_in; - what_changed = Change (what_changed|FadeInChanged); + if (!_sync_marked) { + _sync_position = _start; } - if (!(_fade_out == state->_fade_out)) { - _fade_out = state->_fade_out; - what_changed = Change (what_changed|FadeOutChanged); - } - - if (_scale_amplitude != state->_scale_amplitude) { - _scale_amplitude = state->_scale_amplitude; - what_changed = Change (what_changed|ScaleAmplitudeChanged); - } + /* return to default fades if the existing ones are too long */ - if (_fade_in_disabled != state->_fade_in_disabled) { - if (_fade_in_disabled == 0 && state->_fade_in_disabled) { - set_fade_in_active (false); - } else if (_fade_in_disabled && state->_fade_in_disabled == 0) { - set_fade_in_active (true); - } - _fade_in_disabled = state->_fade_in_disabled; - } - - if (_fade_out_disabled != state->_fade_out_disabled) { - if (_fade_out_disabled == 0 && state->_fade_out_disabled) { - set_fade_out_active (false); - } else if (_fade_out_disabled && state->_fade_out_disabled == 0) { - set_fade_out_active (true); - } - _fade_out_disabled = state->_fade_out_disabled; + if (_left_of_split) { + if (_fade_in->back()->when >= _length) { + set_default_fade_in (); + } + set_default_fade_out (); + _left_of_split = false; } - /* XXX need a way to test stored state versus current for envelopes */ - - _envelope = state->_envelope; - what_changed = Change (what_changed); + if (_right_of_split) { + if (_fade_out->back()->when >= _length) { + set_default_fade_out (); + } - return what_changed; -} + set_default_fade_in (); + _right_of_split = false; + } -UndoAction -AudioRegion::get_memento() const -{ - return sigc::bind (mem_fun (*(const_cast (this)), &StateManager::use_state), _current_state_id); + /* If _length changed, adjust our gain envelope accordingly */ + _envelope->truncate_end (_length); } -bool -AudioRegion::verify_length (nframes_t len) +void +AudioRegion::connect_to_analysis_changed () { - if (boost::dynamic_pointer_cast(source())) { - return true; - } - - for (uint32_t n=0; n < sources.size(); ++n) { - if (_start > sources[n]->length() - len) { - return false; - } + for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) { + (*i)->AnalysisChanged.connect_same_thread (*this, boost::bind (&AudioRegion::invalidate_transients, this)); } - return true; } -bool -AudioRegion::verify_start_and_length (nframes_t new_start, nframes_t new_length) +void +AudioRegion::connect_to_header_position_offset_changed () { - if (boost::dynamic_pointer_cast(source())) { - return true; - } + set > unique_srcs; - for (uint32_t n=0; n < sources.size(); ++n) { - if (new_length > sources[n]->length() - new_start) { - return false; - } - } - return true; -} -bool -AudioRegion::verify_start (nframes_t pos) -{ - if (boost::dynamic_pointer_cast(source())) { - return true; - } + for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) { - for (uint32_t n=0; n < sources.size(); ++n) { - if (pos > sources[n]->length() - _length) { - return false; + /* connect only once to HeaderPositionOffsetChanged, even if sources are replicated + */ + + if (unique_srcs.find (*i) == unique_srcs.end ()) { + unique_srcs.insert (*i); + boost::shared_ptr afs = boost::dynamic_pointer_cast (*i); + if (afs) { + afs->HeaderPositionOffsetChanged.connect_same_thread (*this, boost::bind (&AudioRegion::source_offset_changed, this)); + } } } - return true; } -bool -AudioRegion::verify_start_mutable (nframes_t& new_start) +void +AudioRegion::listen_to_my_curves () { - if (boost::dynamic_pointer_cast(source())) { - return true; - } - - for (uint32_t n=0; n < sources.size(); ++n) { - if (new_start > sources[n]->length() - _length) { - new_start = sources[n]->length() - _length; - } - } - return true; + _envelope->StateChanged.connect_same_thread (*this, boost::bind (&AudioRegion::envelope_changed, this)); + _fade_in->StateChanged.connect_same_thread (*this, boost::bind (&AudioRegion::fade_in_changed, this)); + _fade_out->StateChanged.connect_same_thread (*this, boost::bind (&AudioRegion::fade_out_changed, this)); } + void AudioRegion::set_envelope_active (bool yn) { if (envelope_active() != yn) { - char buf[64]; - if (yn) { - snprintf (buf, sizeof (buf), "envelope active"); - _flags = Flag (_flags|EnvelopeActive); - } else { - snprintf (buf, sizeof (buf), "envelope off"); - _flags = Flag (_flags & ~EnvelopeActive); - } - if (!_frozen) { - save_state (buf); - } - send_change (EnvelopeActiveChanged); - + _envelope_active = yn; + send_change (PropertyChange (Properties::envelope_active)); } } -nframes_t +ARDOUR::nframes_t AudioRegion::read_peaks (PeakData *buf, nframes_t npeaks, nframes_t offset, nframes_t cnt, uint32_t chan_n, double samples_per_unit) const { - if (chan_n >= sources.size()) { - return 0; + if (chan_n >= _sources.size()) { + return 0; } - - if (sources[chan_n]->read_peaks (buf, npeaks, offset, cnt, samples_per_unit)) { + + if (audio_source(chan_n)->read_peaks (buf, npeaks, offset, cnt, samples_per_unit)) { return 0; } else { - if (_scale_amplitude != 1.0) { + if (_scale_amplitude != 1.0f) { for (nframes_t n = 0; n < npeaks; ++n) { buf[n].max *= _scale_amplitude; buf[n].min *= _scale_amplitude; @@ -508,36 +314,58 @@ AudioRegion::read_peaks (PeakData *buf, nframes_t npeaks, nframes_t offset, nfra } } -nframes_t -AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position, - nframes_t cnt, - uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const +framecnt_t +AudioRegion::read (Sample* buf, framepos_t timeline_position, framecnt_t cnt, int channel) const { - return _read_at (sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames); + /* raw read, no fades, no gain, nada */ + return _read_at (_sources, _length, buf, 0, 0, _position + timeline_position, cnt, channel, 0, 0, ReadOps (0)); } -nframes_t -AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position, - nframes_t cnt, uint32_t chan_n) const +framecnt_t +AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, + framepos_t file_position, framecnt_t cnt, uint32_t chan_n, + framecnt_t read_frames, framecnt_t skip_frames) const { - return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0); + /* regular diskstream/butler read complete with fades etc */ + return _read_at (_sources, _length, buf, mixdown_buffer, gain_buffer, + file_position, cnt, chan_n, read_frames, skip_frames, ReadOps (~0)); } -nframes_t -AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer, - nframes_t position, nframes_t cnt, - uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const +framecnt_t +AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, + framepos_t position, framecnt_t cnt, uint32_t chan_n) const { - nframes_t internal_offset; - nframes_t buf_offset; - nframes_t to_read; + /* do not read gain/scaling/fades and do not count this disk i/o in statistics */ - /* precondition: caller has verified that we cover the desired section */ + return _read_at (_master_sources, _master_sources.front()->length(_master_sources.front()->timeline_position()), + buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0, ReadOps (0)); +} + +framecnt_t +AudioRegion::_read_at (const SourceList& /*srcs*/, framecnt_t limit, + Sample *buf, Sample *mixdown_buffer, float *gain_buffer, + framepos_t position, + framecnt_t cnt, + uint32_t chan_n, + framecnt_t /*read_frames*/, + framecnt_t /*skip_frames*/, + ReadOps rops) const +{ + frameoffset_t internal_offset; + frameoffset_t buf_offset; + framecnt_t to_read; + bool raw = (rops == ReadOpsNone); + + if (n_channels() == 0) { + return 0; + } - if (chan_n >= sources.size()) { + if (muted() && !raw) { return 0; /* read nothing */ } - + + /* precondition: caller has verified that we cover the desired section */ + if (position < _position) { internal_offset = 0; buf_offset = _position - position; @@ -547,104 +375,135 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff buf_offset = 0; } - if (internal_offset >= _length) { + if (internal_offset >= limit) { return 0; /* read nothing */ } - if ((to_read = min (cnt, _length - internal_offset)) == 0) { + if ((to_read = min (cnt, limit - internal_offset)) == 0) { return 0; /* read nothing */ } - if (opaque()) { + if (opaque() || raw) { /* overwrite whatever is there */ mixdown_buffer = buf + buf_offset; } else { mixdown_buffer += buf_offset; } - if (muted()) { - return 0; /* read nothing */ + if (rops & ReadOpsCount) { + _read_data_count = 0; } - _read_data_count = 0; + if (chan_n < n_channels()) { + + boost::shared_ptr src = audio_source(chan_n); + if (src->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) { + return 0; /* "read nothing" */ + } + + if (rops & ReadOpsCount) { + _read_data_count += src->read_data_count(); + } + + } else { + + /* track is N-channel, this region has less channels; silence the ones + we don't have. + */ + + if (Config->get_replicate_missing_region_channels()) { + /* track is N-channel, this region has less channels, so use a relevant channel + */ + + uint32_t channel = n_channels() % chan_n; + boost::shared_ptr src = audio_source (channel); - if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) { - return 0; /* "read nothing" */ + if (src->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) { + return 0; /* "read nothing" */ + } + + /* adjust read data count appropriately since this was a duplicate read */ + src->dec_read_data_count (to_read); + } else { + memset (mixdown_buffer, 0, sizeof (Sample) * cnt); + } } - _read_data_count += srcs[chan_n]->read_data_count(); + if (rops & ReadOpsFades) { - /* fade in */ + /* fade in */ - if (_flags & FadeIn) { + if (_fade_in_active && _session.config.get_use_region_fades()) { - nframes_t fade_in_length = (nframes_t) _fade_in.back()->when; - - /* see if this read is within the fade in */ + nframes_t fade_in_length = (nframes_t) _fade_in->back()->when; - if (internal_offset < fade_in_length) { - - nframes_t limit; + /* see if this read is within the fade in */ - limit = min (to_read, fade_in_length - internal_offset); + if (internal_offset < fade_in_length) { - _fade_in.get_vector (internal_offset, internal_offset+limit, gain_buffer, limit); + nframes_t fi_limit; - for (nframes_t n = 0; n < limit; ++n) { - mixdown_buffer[n] *= gain_buffer[n]; + fi_limit = min (to_read, fade_in_length - internal_offset); + + + _fade_in->curve().get_vector (internal_offset, internal_offset+fi_limit, gain_buffer, fi_limit); + + for (nframes_t n = 0; n < fi_limit; ++n) { + mixdown_buffer[n] *= gain_buffer[n]; + } } } - } - - /* fade out */ - if (_flags & FadeOut) { - - /* see if some part of this read is within the fade out */ + /* fade out */ + + if (_fade_out_active && _session.config.get_use_region_fades()) { + + /* see if some part of this read is within the fade out */ /* ................. >| REGION - _length - + limit + { } FADE fade_out_length - ^ - _length - fade_out_length + ^ + limit - fade_out_length |--------------| ^internal_offset ^internal_offset + to_read - we need the intersection of [internal_offset,internal_offset+to_read] with - [_length - fade_out_length, _length] + we need the intersection of [internal_offset,internal_offset+to_read] with + [limit - fade_out_length, limit] */ - - nframes_t fade_out_length = (nframes_t) _fade_out.back()->when; - nframes_t fade_interval_start = max(internal_offset, _length-fade_out_length); - nframes_t fade_interval_end = min(internal_offset + to_read, _length); - if (fade_interval_end > fade_interval_start) { - /* (part of the) the fade out is in this buffer */ - - nframes_t limit = fade_interval_end - fade_interval_start; - nframes_t curve_offset = fade_interval_start - (_length-fade_out_length); - nframes_t fade_offset = fade_interval_start - internal_offset; - - _fade_out.get_vector (curve_offset,curve_offset+limit, gain_buffer, limit); - - for (nframes_t n = 0, m = fade_offset; n < limit; ++n, ++m) { - mixdown_buffer[m] *= gain_buffer[n]; + nframes_t fade_out_length = (nframes_t) _fade_out->back()->when; + nframes_t fade_interval_start = max(internal_offset, limit-fade_out_length); + nframes_t fade_interval_end = min(internal_offset + to_read, limit); + + if (fade_interval_end > fade_interval_start) { + /* (part of the) the fade out is in this buffer */ + + nframes_t fo_limit = fade_interval_end - fade_interval_start; + nframes_t curve_offset = fade_interval_start - (limit-fade_out_length); + nframes_t fade_offset = fade_interval_start - internal_offset; + + _fade_out->curve().get_vector (curve_offset, curve_offset+fo_limit, gain_buffer, fo_limit); + + for (nframes_t n = 0, m = fade_offset; n < fo_limit; ++n, ++m) { + mixdown_buffer[m] *= gain_buffer[n]; + } } - } + } } - /* Regular gain curves */ + /* Regular gain curves and scaling */ - if (envelope_active()) { - _envelope.get_vector (internal_offset, internal_offset + to_read, gain_buffer, to_read); - - if (_scale_amplitude != 1.0f) { + if ((rops & ReadOpsOwnAutomation) && envelope_active()) { + _envelope->curve().get_vector (internal_offset, internal_offset + to_read, gain_buffer, to_read); + + if ((rops & ReadOpsOwnScaling) && _scale_amplitude != 1.0f) { for (nframes_t n = 0; n < to_read; ++n) { mixdown_buffer[n] *= gain_buffer[n] * _scale_amplitude; } @@ -653,11 +512,17 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff mixdown_buffer[n] *= gain_buffer[n]; } } - } else if (_scale_amplitude != 1.0f) { - Session::apply_gain_to_buffer (mixdown_buffer, to_read, _scale_amplitude); + } else if ((rops & ReadOpsOwnScaling) && _scale_amplitude != 1.0f) { + + // XXX this should be using what in 2.0 would have been: + // Session::apply_gain_to_buffer (mixdown_buffer, to_read, _scale_amplitude); + + for (nframes_t n = 0; n < to_read; ++n) { + mixdown_buffer[n] *= _scale_amplitude; + } } - if (!opaque()) { + if (!opaque() && (buf != mixdown_buffer)) { /* gack. the things we do for users. */ @@ -667,375 +532,405 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff for (nframes_t n = 0; n < to_read; ++n) { buf[n] += mixdown_buffer[n]; } - } - + } + return to_read; } - + XMLNode& -AudioRegion::state (bool full) +AudioRegion::state () { - XMLNode& node (Region::state (full)); + XMLNode& node (Region::state ()); XMLNode *child; char buf[64]; - char buf2[64]; LocaleGuard lg (X_("POSIX")); - - snprintf (buf, sizeof (buf), "0x%x", (int) _flags); - node.add_property ("flags", buf); - snprintf (buf, sizeof(buf), "%.12g", _scale_amplitude); - node.add_property ("scale-gain", buf); - for (uint32_t n=0; n < sources.size(); ++n) { - snprintf (buf2, sizeof(buf2), "source-%d", n); - sources[n]->id().print (buf, sizeof (buf)); - node.add_property (buf2, buf); - } - - snprintf (buf, sizeof (buf), "%u", (uint32_t) sources.size()); + snprintf (buf, sizeof (buf), "%u", (uint32_t) _sources.size()); node.add_property ("channels", buf); - if (full) { + Stateful::add_properties (node); + + child = node.add_child ("Envelope"); + + bool default_env = false; - child = node.add_child (X_("FadeIn")); - - if ((_flags & DefaultFadeIn)) { - child->add_property (X_("default"), X_("yes")); - } else { - _fade_in.store_state (*child); - } - - child = node.add_child (X_("FadeOut")); - - if ((_flags & DefaultFadeOut)) { - child->add_property (X_("default"), X_("yes")); - } else { - _fade_out.store_state (*child); + // If there are only two points, the points are in the start of the region and the end of the region + // so, if they are both at 1.0f, that means the default region. + + if (_envelope->size() == 2 && + _envelope->front()->value == 1.0f && + _envelope->back()->value==1.0f) { + if (_envelope->front()->when == 0 && _envelope->back()->when == _length) { + default_env = true; } } - child = node.add_child ("Envelope"); - - if (full) { - bool default_env = false; - - // If there are only two points, the points are in the start of the region and the end of the region - // so, if they are both at 1.0f, that means the default region. - if (_envelope.size() == 2 && - _envelope.front()->value == 1.0f && - _envelope.back()->value==1.0f) { - if (_envelope.front()->when == 0 && _envelope.back()->when == _length) { - default_env = true; - } - } - - if (default_env) { - child->add_property ("default", "yes"); - } else { - _envelope.store_state (*child); - } + if (default_env) { + child->add_property ("default", "yes"); } else { + child->add_child_nocopy (_envelope->get_state ()); + } + + child = node.add_child (X_("FadeIn")); + + if (_default_fade_in) { child->add_property ("default", "yes"); + } else { + child->add_child_nocopy (_fade_in->get_state ()); } - if (full && _extra_xml) { - node.add_child_copy (*_extra_xml); + child = node.add_child (X_("FadeOut")); + + if (_default_fade_out) { + child->add_property ("default", "yes"); + } else { + child->add_child_nocopy (_fade_out->get_state ()); } return node; } int -AudioRegion::set_state (const XMLNode& node) +AudioRegion::_set_state (const XMLNode& node, int version, PropertyChange& what_changed, bool send) { const XMLNodeList& nlist = node.children(); const XMLProperty *prop; LocaleGuard lg (X_("POSIX")); + boost::shared_ptr the_playlist (_playlist.lock()); - Region::set_state (node); + suspend_property_changes (); - if ((prop = node.property ("flags")) != 0) { - _flags = Flag (strtol (prop->value().c_str(), (char **) 0, 16)); - - _flags = Flag (_flags & ~Region::LeftOfSplit); - _flags = Flag (_flags & ~Region::RightOfSplit); + if (the_playlist) { + the_playlist->freeze (); } - if ((prop = node.property ("scale-gain")) != 0) { - _scale_amplitude = atof (prop->value().c_str()); - } else { - _scale_amplitude = 1.0; - } - - /* Now find envelope description and other misc child items */ - + + /* this will set all our State members and stuff controlled by the Region. + It should NOT send any changed signals - that is our responsibility. + */ + + Region::_set_state (node, version, what_changed, false); + + if ((prop = node.property ("scale-gain")) != 0) { + float a = atof (prop->value().c_str()); + if (a != _scale_amplitude) { + _scale_amplitude = a; + what_changed.add (Properties::scale_amplitude); + } + } + + /* Now find envelope description and other related child items */ + + _envelope->freeze (); + for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) { - XMLNode *child; XMLProperty *prop; - + child = (*niter); - + if (child->name() == "Envelope") { - - _envelope.clear (); - if ((prop = child->property ("default")) != 0) { + _envelope->clear (); + + if ((prop = child->property ("default")) != 0 || _envelope->set_state (*child, version)) { set_default_envelope (); - } else { - _envelope.load_state (*child); } - _envelope.set_max_xval (_length); - _envelope.truncate_end (_length); - + _envelope->set_max_xval (_length); + _envelope->truncate_end (_length); + + } else if (child->name() == "FadeIn") { - - _fade_in.clear (); - + + _fade_in->clear (); + if ((prop = child->property ("default")) != 0 || (prop = child->property ("steepness")) != 0) { set_default_fade_in (); } else { - - _fade_in.load_state (*child); + XMLNode* grandchild = child->child ("AutomationList"); + if (grandchild) { + _fade_in->set_state (*grandchild, version); + } + } + + if ((prop = child->property ("active")) != 0) { + if (string_is_affirmative (prop->value())) { + set_fade_in_active (true); + } else { + set_fade_in_active (false); + } } } else if (child->name() == "FadeOut") { - - _fade_out.clear (); + + _fade_out->clear (); if ((prop = child->property ("default")) != 0 || (prop = child->property ("steepness")) != 0) { set_default_fade_out (); } else { - _fade_out.load_state (*child); + XMLNode* grandchild = child->child ("AutomationList"); + if (grandchild) { + _fade_out->set_state (*grandchild, version); + } } - } + + if ((prop = child->property ("active")) != 0) { + if (string_is_affirmative (prop->value())) { + set_fade_out_active (true); + } else { + set_fade_out_active (false); + } + } + + } + } + + _envelope->thaw (); + resume_property_changes (); + + if (send) { + send_change (what_changed); + } + + if (the_playlist) { + the_playlist->thaw (); } return 0; } +int +AudioRegion::set_state (const XMLNode& node, int version) +{ + PropertyChange what_changed; + return _set_state (node, version, what_changed, true); +} + void AudioRegion::set_fade_in_shape (FadeShape shape) { - set_fade_in (shape, (nframes_t) _fade_in.back()->when); + set_fade_in (shape, (nframes_t) _fade_in->back()->when); } void AudioRegion::set_fade_out_shape (FadeShape shape) { - set_fade_out (shape, (nframes_t) _fade_out.back()->when); + set_fade_out (shape, (nframes_t) _fade_out->back()->when); +} + +void +AudioRegion::set_fade_in (boost::shared_ptr f) +{ + _fade_in->freeze (); + *_fade_in = *f; + _fade_in->thaw (); + + send_change (PropertyChange (Properties::fade_in)); } void -AudioRegion::set_fade_in (FadeShape shape, nframes_t len) +AudioRegion::set_fade_in (FadeShape shape, framecnt_t len) { - _fade_in.freeze (); - _fade_in.clear (); + _fade_in->freeze (); + _fade_in->clear (); switch (shape) { case Linear: - _fade_in.add (0.0, 0.0); - _fade_in.add (len, 1.0); + _fade_in->fast_simple_add (0.0, 0.0); + _fade_in->fast_simple_add (len, 1.0); break; case Fast: - _fade_in.add (0, 0); - _fade_in.add (len * 0.389401, 0.0333333); - _fade_in.add (len * 0.629032, 0.0861111); - _fade_in.add (len * 0.829493, 0.233333); - _fade_in.add (len * 0.9447, 0.483333); - _fade_in.add (len * 0.976959, 0.697222); - _fade_in.add (len, 1); + _fade_in->fast_simple_add (0, 0); + _fade_in->fast_simple_add (len * 0.389401, 0.0333333); + _fade_in->fast_simple_add (len * 0.629032, 0.0861111); + _fade_in->fast_simple_add (len * 0.829493, 0.233333); + _fade_in->fast_simple_add (len * 0.9447, 0.483333); + _fade_in->fast_simple_add (len * 0.976959, 0.697222); + _fade_in->fast_simple_add (len, 1); break; case Slow: - _fade_in.add (0, 0); - _fade_in.add (len * 0.0207373, 0.197222); - _fade_in.add (len * 0.0645161, 0.525); - _fade_in.add (len * 0.152074, 0.802778); - _fade_in.add (len * 0.276498, 0.919444); - _fade_in.add (len * 0.481567, 0.980556); - _fade_in.add (len * 0.767281, 1); - _fade_in.add (len, 1); + _fade_in->fast_simple_add (0, 0); + _fade_in->fast_simple_add (len * 0.0207373, 0.197222); + _fade_in->fast_simple_add (len * 0.0645161, 0.525); + _fade_in->fast_simple_add (len * 0.152074, 0.802778); + _fade_in->fast_simple_add (len * 0.276498, 0.919444); + _fade_in->fast_simple_add (len * 0.481567, 0.980556); + _fade_in->fast_simple_add (len * 0.767281, 1); + _fade_in->fast_simple_add (len, 1); break; case LogA: - _fade_in.add (0, 0); - _fade_in.add (len * 0.0737327, 0.308333); - _fade_in.add (len * 0.246544, 0.658333); - _fade_in.add (len * 0.470046, 0.886111); - _fade_in.add (len * 0.652074, 0.972222); - _fade_in.add (len * 0.771889, 0.988889); - _fade_in.add (len, 1); + _fade_in->fast_simple_add (0, 0); + _fade_in->fast_simple_add (len * 0.0737327, 0.308333); + _fade_in->fast_simple_add (len * 0.246544, 0.658333); + _fade_in->fast_simple_add (len * 0.470046, 0.886111); + _fade_in->fast_simple_add (len * 0.652074, 0.972222); + _fade_in->fast_simple_add (len * 0.771889, 0.988889); + _fade_in->fast_simple_add (len, 1); break; case LogB: - _fade_in.add (0, 0); - _fade_in.add (len * 0.304147, 0.0694444); - _fade_in.add (len * 0.529954, 0.152778); - _fade_in.add (len * 0.725806, 0.333333); - _fade_in.add (len * 0.847926, 0.558333); - _fade_in.add (len * 0.919355, 0.730556); - _fade_in.add (len, 1); + _fade_in->fast_simple_add (0, 0); + _fade_in->fast_simple_add (len * 0.304147, 0.0694444); + _fade_in->fast_simple_add (len * 0.529954, 0.152778); + _fade_in->fast_simple_add (len * 0.725806, 0.333333); + _fade_in->fast_simple_add (len * 0.847926, 0.558333); + _fade_in->fast_simple_add (len * 0.919355, 0.730556); + _fade_in->fast_simple_add (len, 1); break; } - _fade_in.thaw (); - _fade_in_shape = shape; + _fade_in->thaw (); +} - if (!_frozen) { - save_state (_("fade in change")); - } +void +AudioRegion::set_fade_out (boost::shared_ptr f) +{ + _fade_out->freeze (); + *_fade_out = *f; + _fade_out->thaw (); - send_change (FadeInChanged); + send_change (PropertyChange (Properties::fade_in)); } void -AudioRegion::set_fade_out (FadeShape shape, nframes_t len) +AudioRegion::set_fade_out (FadeShape shape, framecnt_t len) { - _fade_out.freeze (); - _fade_out.clear (); + _fade_out->freeze (); + _fade_out->clear (); switch (shape) { case Fast: - _fade_out.add (len * 0, 1); - _fade_out.add (len * 0.023041, 0.697222); - _fade_out.add (len * 0.0553, 0.483333); - _fade_out.add (len * 0.170507, 0.233333); - _fade_out.add (len * 0.370968, 0.0861111); - _fade_out.add (len * 0.610599, 0.0333333); - _fade_out.add (len * 1, 0); + _fade_out->fast_simple_add (len * 0, 1); + _fade_out->fast_simple_add (len * 0.023041, 0.697222); + _fade_out->fast_simple_add (len * 0.0553, 0.483333); + _fade_out->fast_simple_add (len * 0.170507, 0.233333); + _fade_out->fast_simple_add (len * 0.370968, 0.0861111); + _fade_out->fast_simple_add (len * 0.610599, 0.0333333); + _fade_out->fast_simple_add (len * 1, 0); break; case LogA: - _fade_out.add (len * 0, 1); - _fade_out.add (len * 0.228111, 0.988889); - _fade_out.add (len * 0.347926, 0.972222); - _fade_out.add (len * 0.529954, 0.886111); - _fade_out.add (len * 0.753456, 0.658333); - _fade_out.add (len * 0.9262673, 0.308333); - _fade_out.add (len * 1, 0); + _fade_out->fast_simple_add (len * 0, 1); + _fade_out->fast_simple_add (len * 0.228111, 0.988889); + _fade_out->fast_simple_add (len * 0.347926, 0.972222); + _fade_out->fast_simple_add (len * 0.529954, 0.886111); + _fade_out->fast_simple_add (len * 0.753456, 0.658333); + _fade_out->fast_simple_add (len * 0.9262673, 0.308333); + _fade_out->fast_simple_add (len * 1, 0); break; case Slow: - _fade_out.add (len * 0, 1); - _fade_out.add (len * 0.305556, 1); - _fade_out.add (len * 0.548611, 0.991736); - _fade_out.add (len * 0.759259, 0.931129); - _fade_out.add (len * 0.918981, 0.68595); - _fade_out.add (len * 0.976852, 0.22865); - _fade_out.add (len * 1, 0); + _fade_out->fast_simple_add (len * 0, 1); + _fade_out->fast_simple_add (len * 0.305556, 1); + _fade_out->fast_simple_add (len * 0.548611, 0.991736); + _fade_out->fast_simple_add (len * 0.759259, 0.931129); + _fade_out->fast_simple_add (len * 0.918981, 0.68595); + _fade_out->fast_simple_add (len * 0.976852, 0.22865); + _fade_out->fast_simple_add (len * 1, 0); break; case LogB: - _fade_out.add (len * 0, 1); - _fade_out.add (len * 0.080645, 0.730556); - _fade_out.add (len * 0.277778, 0.289256); - _fade_out.add (len * 0.470046, 0.152778); - _fade_out.add (len * 0.695853, 0.0694444); - _fade_out.add (len * 1, 0); + _fade_out->fast_simple_add (len * 0, 1); + _fade_out->fast_simple_add (len * 0.080645, 0.730556); + _fade_out->fast_simple_add (len * 0.277778, 0.289256); + _fade_out->fast_simple_add (len * 0.470046, 0.152778); + _fade_out->fast_simple_add (len * 0.695853, 0.0694444); + _fade_out->fast_simple_add (len * 1, 0); break; case Linear: - _fade_out.add (len * 0, 1); - _fade_out.add (len * 1, 0); + _fade_out->fast_simple_add (len * 0, 1); + _fade_out->fast_simple_add (len * 1, 0); break; } - _fade_out.thaw (); - _fade_out_shape = shape; - - if (!_frozen) { - save_state (_("fade in change")); - } - - send_change (FadeOutChanged); + _fade_out->thaw (); } void -AudioRegion::set_fade_in_length (nframes_t len) +AudioRegion::set_fade_in_length (framecnt_t len) { - bool changed = _fade_in.extend_to (len); + if (len > _length) { + len = _length - 1; + } - if (changed) { - _flags = Flag (_flags & ~DefaultFadeIn); + bool changed = _fade_in->extend_to (len); - if (!_frozen) { - char buf[64]; - snprintf (buf, sizeof (buf), "fade in length changed to %u", len); - save_state (buf); - } - - send_change (FadeInChanged); + if (changed) { + _default_fade_in = false; + send_change (PropertyChange (Properties::fade_in)); } } void -AudioRegion::set_fade_out_length (nframes_t len) +AudioRegion::set_fade_out_length (framecnt_t len) { - bool changed = _fade_out.extend_to (len); + if (len > _length) { + len = _length - 1; + } + + bool changed = _fade_out->extend_to (len); if (changed) { - _flags = Flag (_flags & ~DefaultFadeOut); - - if (!_frozen) { - char buf[64]; - snprintf (buf, sizeof (buf), "fade out length changed to %u", len); - save_state (buf); - } + _default_fade_out = false; + send_change (PropertyChange (Properties::fade_out)); } - - send_change (FadeOutChanged); } void AudioRegion::set_fade_in_active (bool yn) { - if (yn == (_flags & FadeIn)) { + if (yn == _fade_in_active) { return; } - if (yn) { - _flags = Flag (_flags|FadeIn); - } else { - _flags = Flag (_flags & ~FadeIn); - } - send_change (FadeInActiveChanged); + _fade_in_active = yn; + send_change (PropertyChange (Properties::fade_in_active)); } void AudioRegion::set_fade_out_active (bool yn) { - if (yn == (_flags & FadeOut)) { + if (yn == _fade_out_active) { return; } - if (yn) { - _flags = Flag (_flags | FadeOut); - } else { - _flags = Flag (_flags & ~FadeOut); - } + _fade_out_active = yn; + send_change (PropertyChange (Properties::fade_out_active)); +} + +bool +AudioRegion::fade_in_is_default () const +{ + return _fade_in->size() == 2 && _fade_in->front()->when == 0 && _fade_in->back()->when == 64; +} - send_change (FadeOutActiveChanged); +bool +AudioRegion::fade_out_is_default () const +{ + return _fade_out->size() == 2 && _fade_out->front()->when == 0 && _fade_out->back()->when == 64; } void AudioRegion::set_default_fade_in () { + _fade_in_suspended = 0; set_fade_in (Linear, 64); } void AudioRegion::set_default_fade_out () { + _fade_out_suspended = 0; set_fade_out (Linear, 64); } void AudioRegion::set_default_fades () { - _fade_in_disabled = 0; - _fade_out_disabled = 0; set_default_fade_in (); set_default_fade_out (); } @@ -1043,237 +938,238 @@ AudioRegion::set_default_fades () void AudioRegion::set_default_envelope () { - _envelope.freeze (); - _envelope.clear (); - _envelope.add (0, 1.0f); - _envelope.add (_length, 1.0f); - _envelope.thaw (); + _envelope->freeze (); + _envelope->clear (); + _envelope->fast_simple_add (0, 1.0f); + _envelope->fast_simple_add (_length, 1.0f); + _envelope->thaw (); } void AudioRegion::recompute_at_end () { - /* our length has changed. recompute a new final point by interpolating + /* our length has changed. recompute a new final point by interpolating based on the the existing curve. */ - - _envelope.freeze (); - _envelope.truncate_end (_length); - _envelope.set_max_xval (_length); - _envelope.thaw (); - if (_fade_in.back()->when > _length) { - _fade_in.extend_to (_length); - send_change (FadeInChanged); + _envelope->freeze (); + _envelope->truncate_end (_length); + _envelope->set_max_xval (_length); + _envelope->thaw (); + + if (_left_of_split) { + set_default_fade_out (); + _left_of_split = false; + } else if (_fade_out->back()->when > _length) { + _fade_out->extend_to (_length); + send_change (PropertyChange (Properties::fade_out)); + } + + if (_fade_in->back()->when > _length) { + _fade_in->extend_to (_length); + send_change (PropertyChange (Properties::fade_in)); } - - if (_fade_out.back()->when > _length) { - _fade_out.extend_to (_length); - send_change (FadeOutChanged); - } -} +} void AudioRegion::recompute_at_start () { /* as above, but the shift was from the front */ - _envelope.truncate_start (_length); + _envelope->truncate_start (_length); - if (_fade_in.back()->when > _length) { - _fade_in.extend_to (_length); - send_change (FadeInChanged); + if (_right_of_split) { + set_default_fade_in (); + _right_of_split = false; + } else if (_fade_in->back()->when > _length) { + _fade_in->extend_to (_length); + send_change (PropertyChange (Properties::fade_in)); } - if (_fade_out.back()->when > _length) { - _fade_out.extend_to (_length); - send_change (FadeOutChanged); + if (_fade_out->back()->when > _length) { + _fade_out->extend_to (_length); + send_change (PropertyChange (Properties::fade_out)); } } int -AudioRegion::separate_by_channel (Session& session, vector& v) const +AudioRegion::separate_by_channel (Session& /*session*/, vector >& v) const { SourceList srcs; string new_name; + int n = 0; - for (SourceList::const_iterator i = master_sources.begin(); i != master_sources.end(); ++i) { + if (_sources.size() < 2) { + return 0; + } + for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) { srcs.clear (); srcs.push_back (*i); - /* generate a new name */ - - if (session.region_name (new_name, _name)) { - return -1; + new_name = _name; + + if (_sources.size() == 2) { + if (n == 0) { + new_name += "-L"; + } else { + new_name += "-R"; + } + } else { + new_name += '-'; + new_name += ('0' + n + 1); } - /* create a copy with just one source */ + /* create a copy with just one source. prevent if from being thought of as + "whole file" even if it covers the entire source file(s). + */ + + PropertyList plist; + + plist.add (Properties::start, _start.val()); + plist.add (Properties::length, _length.val()); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, _layer.val()); - v.push_back (new AudioRegion (srcs, _start, _length, new_name, _layer, _flags)); + v.push_back(RegionFactory::create (srcs, plist)); + v.back()->set_whole_file (false); + + ++n; } return 0; } -void -AudioRegion::source_deleted () +framecnt_t +AudioRegion::read_raw_internal (Sample* buf, framepos_t pos, framecnt_t cnt, int channel) const { - sources.clear (); - drop_references (); + return audio_source()->read (buf, pos, cnt, channel); } -vector -AudioRegion::master_source_names () +int +AudioRegion::exportme (Session& /*session*/, ARDOUR::ExportSpecification& /*spec*/) { - SourceList::iterator i; - - vector names; - for (i = master_sources.begin(); i != master_sources.end(); ++i) { - names.push_back((*i)->name()); - } - - return names; + // TODO EXPORT +// const nframes_t blocksize = 4096; +// nframes_t to_read; +// int status = -1; +// +// spec.channels = _sources.size(); +// +// if (spec.prepare (blocksize, session.frame_rate())) { +// goto out; +// } +// +// spec.pos = 0; +// spec.total_frames = _length; +// +// while (spec.pos < _length && !spec.stop) { +// +// +// /* step 1: interleave */ +// +// to_read = min (_length - spec.pos, blocksize); +// +// if (spec.channels == 1) { +// +// if (read_raw_internal (spec.dataF, _start + spec.pos, to_read) != to_read) { +// goto out; +// } +// +// } else { +// +// Sample buf[blocksize]; +// +// for (uint32_t chan = 0; chan < spec.channels; ++chan) { +// +// if (audio_source(chan)->read (buf, _start + spec.pos, to_read) != to_read) { +// goto out; +// } +// +// for (nframes_t x = 0; x < to_read; ++x) { +// spec.dataF[chan+(x*spec.channels)] = buf[x]; +// } +// } +// } +// +// if (spec.process (to_read)) { +// goto out; +// } +// +// spec.pos += to_read; +// spec.progress = (double) spec.pos /_length; +// +// } +// +// status = 0; +// +// out: +// spec.running = false; +// spec.status = status; +// spec.clear(); +// +// return status; + return 0; } -bool -AudioRegion::source_equivalent (boost::shared_ptr o) const +void +AudioRegion::set_scale_amplitude (gain_t g) { - boost::shared_ptr other = boost::dynamic_pointer_cast(o); - - if (!other) - return false; + boost::shared_ptr pl (playlist()); - SourceList::const_iterator i; - SourceList::const_iterator io; + _scale_amplitude = g; - for (i = sources.begin(), io = other->sources.begin(); i != sources.end() && io != other->sources.end(); ++i, ++io) { - if ((*i)->id() != (*io)->id()) { - return false; - } - } + /* tell the diskstream we're in */ - for (i = master_sources.begin(), io = other->master_sources.begin(); i != master_sources.end() && io != other->master_sources.end(); ++i, ++io) { - if ((*i)->id() != (*io)->id()) { - return false; - } + if (pl) { + pl->ContentsChanged(); } - return true; -} + /* tell everybody else */ -int -AudioRegion::apply (AudioFilter& filter) -{ - return filter.run (boost::shared_ptr (this)); + send_change (PropertyChange (Properties::scale_amplitude)); } -int -AudioRegion::exportme (Session& session, AudioExportSpecification& spec) +/** @return the maximum (linear) amplitude of the region */ +double +AudioRegion::maximum_amplitude () const { - const nframes_t blocksize = 4096; - nframes_t to_read; - int status = -1; - - spec.channels = sources.size(); - - if (spec.prepare (blocksize, session.frame_rate())) { - goto out; - } + framepos_t fpos = _start; + framepos_t const fend = _start + _length; + double maxamp = 0; - spec.pos = 0; - spec.total_frames = _length; + framecnt_t const blocksize = 64 * 1024; + Sample buf[blocksize]; + + while (fpos < fend) { - while (spec.pos < _length && !spec.stop) { - - - /* step 1: interleave */ - - to_read = min (_length - spec.pos, blocksize); - - if (spec.channels == 1) { + uint32_t n; - if (sources.front()->read (spec.dataF, _start + spec.pos, to_read) != to_read) { - goto out; - } + framecnt_t const to_read = min (fend - fpos, blocksize); - } else { + for (n = 0; n < n_channels(); ++n) { - Sample buf[blocksize]; + /* read it in */ - for (uint32_t chan = 0; chan < spec.channels; ++chan) { - - if (sources[chan]->read (buf, _start + spec.pos, to_read) != to_read) { - goto out; - } - - for (nframes_t x = 0; x < to_read; ++x) { - spec.dataF[chan+(x*spec.channels)] = buf[x]; - } + if (read_raw_internal (buf, fpos, to_read, 0) != to_read) { + return 0; } - } - - if (spec.process (to_read)) { - goto out; - } - - spec.pos += to_read; - spec.progress = (double) spec.pos /_length; - - } - - status = 0; - out: - spec.running = false; - spec.status = status; - spec.clear(); - - return status; -} - -boost::shared_ptr -AudioRegion::get_parent() -{ - boost::shared_ptr r; - - if (_playlist) { - boost::shared_ptr ar; - boost::shared_ptr grrr2 = boost::dynamic_pointer_cast (shared_from_this()); - - if (grrr2 && (ar = _playlist->session().find_whole_file_parent (grrr2))) { - return boost::static_pointer_cast (ar); + maxamp = compute_peak (buf, to_read, maxamp); } - } - - return r; -} - -void -AudioRegion::set_scale_amplitude (gain_t g) -{ - _scale_amplitude = g; - - /* tell the diskstream we're in */ - if (_playlist) { - _playlist->Modified(); + fpos += to_read; } - /* tell everybody else */ - - send_change (ScaleAmplitudeChanged); + return maxamp; } +/** Normalize using a given maximum amplitude and target, so that region + * _scale_amplitude becomes target / max_amplitude. + */ void -AudioRegion::normalize_to (float target_dB) +AudioRegion::normalize (float max_amplitude, float target_dB) { - const nframes_t blocksize = 64 * 1024; - Sample buf[blocksize]; - nframes_t fpos; - nframes_t fend; - nframes_t to_read; - double maxamp = 0; gain_t target = dB_to_coefficient (target_dB); if (target == 1.0f) { @@ -1283,81 +1179,51 @@ AudioRegion::normalize_to (float target_dB) target -= FLT_EPSILON; } - fpos = _start; - fend = _start + _length; - - /* first pass: find max amplitude */ - - while (fpos < fend) { - - uint32_t n; - - to_read = min (fend - fpos, blocksize); - - for (n = 0; n < n_channels(); ++n) { - - /* read it in */ - - if (source (n)->read (buf, fpos, to_read) != to_read) { - return; - } - - maxamp = Session::compute_peak (buf, to_read, maxamp); - } - - fpos += to_read; - }; - - if (maxamp == 0.0f) { + if (max_amplitude == 0.0f) { /* don't even try */ return; } - if (maxamp == target) { + if (max_amplitude == target) { /* we can't do anything useful */ return; } - /* compute scale factor */ - - _scale_amplitude = target/maxamp; - - if (!_frozen) { - char buf[64]; - snprintf (buf, sizeof (buf), _("normalized to %.2fdB"), target_dB); - save_state (buf); - } - - /* tell the diskstream we're in */ - - if (_playlist) { - _playlist->Modified(); - } + set_scale_amplitude (target / max_amplitude); +} - /* tell everybody else */ +void +AudioRegion::fade_in_changed () +{ + send_change (PropertyChange (Properties::fade_in)); +} - send_change (ScaleAmplitudeChanged); +void +AudioRegion::fade_out_changed () +{ + send_change (PropertyChange (Properties::fade_out)); } void -AudioRegion::envelope_changed (Change ignored) +AudioRegion::envelope_changed () { - save_state (_("envelope change")); - send_change (EnvelopeChanged); + send_change (PropertyChange (Properties::envelope)); } void AudioRegion::suspend_fade_in () { - if (++_fade_in_disabled == 1) { - set_fade_in_active (false); + if (++_fade_in_suspended == 1) { + if (fade_in_is_default()) { + set_fade_in_active (false); + } } } void AudioRegion::resume_fade_in () { - if (_fade_in_disabled && --_fade_in_disabled == 0) { + if (--_fade_in_suspended == 0 && _fade_in_suspended) { set_fade_in_active (true); } } @@ -1365,15 +1231,17 @@ AudioRegion::resume_fade_in () void AudioRegion::suspend_fade_out () { - if (++_fade_out_disabled == 1) { - set_fade_out_active (false); + if (++_fade_out_suspended == 1) { + if (fade_out_is_default()) { + set_fade_out_active (false); + } } } void AudioRegion::resume_fade_out () { - if (_fade_out_disabled && --_fade_out_disabled == 0) { + if (--_fade_out_suspended == 0 &&_fade_out_suspended) { set_fade_out_active (true); } } @@ -1381,12 +1249,12 @@ AudioRegion::resume_fade_out () bool AudioRegion::speed_mismatch (float sr) const { - if (sources.empty()) { + if (_sources.empty()) { /* impossible, but ... */ return false; } - float fsr = sources.front()->sample_rate(); + float fsr = audio_source()->sample_rate(); return fsr != sr; } @@ -1394,17 +1262,290 @@ AudioRegion::speed_mismatch (float sr) const void AudioRegion::source_offset_changed () { - if (boost::dynamic_pointer_cast(sources.front())) { - set_start (source()->natural_position(), this); + /* XXX this fixes a crash that should not occur. It does occur + becauses regions are not being deleted when a session + is unloaded. That bug must be fixed. + */ + + if (_sources.empty()) { + return; + } + + boost::shared_ptr afs = boost::dynamic_pointer_cast(_sources.front()); + + if (afs && afs->destructive()) { + // set_start (source()->natural_position(), this); set_position (source()->natural_position(), this); - } + } +} + +boost::shared_ptr +AudioRegion::audio_source (uint32_t n) const +{ + // Guaranteed to succeed (use a static cast for speed?) + return boost::dynamic_pointer_cast(source(n)); +} + +int +AudioRegion::adjust_transients (nframes64_t delta) +{ + for (AnalysisFeatureList::iterator x = _transients.begin(); x != _transients.end(); ++x) { + (*x) = (*x) + delta; + } + + send_change (PropertyChange (Properties::valid_transients)); + + return 0; +} + +int +AudioRegion::update_transient (nframes64_t old_position, nframes64_t new_position) +{ + for (AnalysisFeatureList::iterator x = _transients.begin(); x != _transients.end(); ++x) { + if ((*x) == old_position) { + (*x) = new_position; + send_change (PropertyChange (Properties::valid_transients)); + + break; + } + } + + return 0; +} + +void +AudioRegion::add_transient (nframes64_t where) +{ + _transients.push_back(where); + _valid_transients = true; + + send_change (PropertyChange (Properties::valid_transients)); +} + +void +AudioRegion::remove_transient (nframes64_t where) +{ + _transients.remove(where); + _valid_transients = true; + + send_change (PropertyChange (Properties::valid_transients)); +} + +int +AudioRegion::set_transients (AnalysisFeatureList& results) +{ + _transients.clear(); + _transients = results; + _valid_transients = true; + + send_change (PropertyChange (Properties::valid_transients)); + + return 0; } +int +AudioRegion::get_transients (AnalysisFeatureList& results, bool force_new) +{ + boost::shared_ptr pl = playlist(); + + if (!pl) { + return -1; + } + + if (_valid_transients && !force_new) { + results = _transients; + return 0; + } + + SourceList::iterator s; + + for (s = _sources.begin() ; s != _sources.end(); ++s) { + if (!(*s)->has_been_analysed()) { + cerr << "For " << name() << " source " << (*s)->name() << " has not been analyzed\n"; + break; + } + } + + if (s == _sources.end()) { + /* all sources are analyzed, merge data from each one */ + + for (s = _sources.begin() ; s != _sources.end(); ++s) { + + /* find the set of transients within the bounds of this region */ + + AnalysisFeatureList::iterator low = lower_bound ((*s)->transients.begin(), + (*s)->transients.end(), + _start); + + AnalysisFeatureList::iterator high = upper_bound ((*s)->transients.begin(), + (*s)->transients.end(), + _start + _length); + + /* and add them */ + + results.insert (results.end(), low, high); + } + + TransientDetector::cleanup_transients (results, pl->session().frame_rate(), 3.0); + + /* translate all transients to current position */ + + for (AnalysisFeatureList::iterator x = results.begin(); x != results.end(); ++x) { + (*x) -= _start; + (*x) += _position; + } + + _transients = results; + _valid_transients = true; + + return 0; + } + + /* no existing/complete transient info */ + + static bool analyse_dialog_shown = false; /* global per instance of Ardour */ + + if (!Config->get_auto_analyse_audio()) { + if (!analyse_dialog_shown) { + pl->session().Dialog (_("\ +You have requested an operation that requires audio analysis.\n\n \ +You currently have \"auto-analyse-audio\" disabled, which means\n\ +that transient data must be generated every time it is required.\n\n\ +If you are doing work that will require transient data on a\n\ +regular basis, you should probably enable \"auto-analyse-audio\"\n\ ++then quit ardour and restart.\n\n\ ++This dialog will not display again. But you may notice a slight delay\n\ ++in this and future transient-detection operations.\n\ ++")); + analyse_dialog_shown = true; + } + } + + TransientDetector t (pl->session().frame_rate()); + bool existing_results = !results.empty(); + + _transients.clear (); + _valid_transients = false; + + for (uint32_t i = 0; i < n_channels(); ++i) { + + AnalysisFeatureList these_results; + + t.reset (); + + if (t.run ("", this, i, these_results)) { + return -1; + } + + /* translate all transients to give absolute position */ + + for (AnalysisFeatureList::iterator i = these_results.begin(); i != these_results.end(); ++i) { + (*i) += _position; + } + + /* merge */ + + _transients.insert (_transients.end(), these_results.begin(), these_results.end()); + } + + if (!results.empty()) { + if (existing_results) { + + /* merge our transients into the existing ones, then clean up + those. + */ + + results.insert (results.end(), _transients.begin(), _transients.end()); + TransientDetector::cleanup_transients (results, pl->session().frame_rate(), 3.0); + } + + /* make sure ours are clean too */ + + TransientDetector::cleanup_transients (_transients, pl->session().frame_rate(), 3.0); + + } else { + + TransientDetector::cleanup_transients (_transients, pl->session().frame_rate(), 3.0); + results = _transients; + } + + _valid_transients = true; + + return 0; +} + +/** Find areas of `silence' within a region. + * + * @param threshold Threshold below which signal is considered silence (as a sample value) + * @param min_length Minimum length of silent period to be reported. + * @return Silent periods; first of pair is the offset within the region, second is the length of the period + */ + +std::list > +AudioRegion::find_silence (Sample threshold, framecnt_t min_length, InterThreadInfo& itt) const +{ + framecnt_t const block_size = 64 * 1024; + Sample loudest[block_size]; + Sample buf[block_size]; + + framepos_t pos = _start; + framepos_t const end = _start + _length - 1; + + std::list > silent_periods; + + bool in_silence = false; + frameoffset_t silence_start = 0; + bool silence; + + while (pos < end && !itt.cancel) { + + /* fill `loudest' with the loudest absolute sample at each instant, across all channels */ + memset (loudest, 0, sizeof (Sample) * block_size); + for (uint32_t n = 0; n < n_channels(); ++n) { + + read_raw_internal (buf, pos, block_size, n); + for (framecnt_t i = 0; i < block_size; ++i) { + loudest[i] = max (loudest[i], abs (buf[i])); + } + } + + /* now look for silence */ + for (framecnt_t i = 0; i < block_size; ++i) { + silence = abs (loudest[i]) < threshold; + if (silence && !in_silence) { + /* non-silence to silence */ + in_silence = true; + silence_start = pos + i; + } else if (!silence && in_silence) { + /* silence to non-silence */ + in_silence = false; + if (pos + i - 1 - silence_start >= min_length) { + silent_periods.push_back (std::make_pair (silence_start, pos + i - 1)); + } + } + } + + pos += block_size; + itt.progress = (end-pos)/(double)_length; + } + + if (in_silence && end - 1 - silence_start >= min_length) { + /* last block was silent, so finish off the last period */ + silent_periods.push_back (std::make_pair (silence_start, end)); + } + + itt.done = true; + + return silent_periods; +} + + + extern "C" { - int region_read_peaks_from_c (void *arg, uint32_t npeaks, uint32_t start, uint32_t cnt, intptr_t data, uint32_t n_chan, double samples_per_unit) + int region_read_peaks_from_c (void *arg, uint32_t npeaks, uint32_t start, uint32_t cnt, intptr_t data, uint32_t n_chan, double samples_per_unit) { - return ((AudioRegion *) arg)->read_peaks ((PeakData *) data, (nframes_t) npeaks, (nframes_t) start, (nframes_t) cnt, n_chan,samples_per_unit); + return ((AudioRegion *) arg)->read_peaks ((PeakData *) data, (framecnt_t) npeaks, (framepos_t) start, (framecnt_t) cnt, n_chan,samples_per_unit); } uint32_t region_length_from_c (void *arg) @@ -1415,7 +1556,7 @@ uint32_t region_length_from_c (void *arg) uint32_t sourcefile_length_from_c (void *arg, double zoom_factor) { - return ( (AudioRegion *) arg)->source()->available_peaks (zoom_factor) ; + return ( (AudioRegion *) arg)->audio_source()->available_peaks (zoom_factor) ; } } /* extern "C" */