const string TempoSection::xml_state_node_name = "Tempo";
TempoSection::TempoSection (const XMLNode& node)
- : MetricSection (0.0)
+ : MetricSection (0.0, 0, MusicTime)
, Tempo (TempoMap::default_tempo())
, _c_func (0.0)
, _active (true)
+ , _locked_to_meter (false)
{
- const XMLProperty *prop;
+ XMLProperty const * prop;
LocaleGuard lg;
BBT_Time bbt;
double pulse;
uint32_t frame;
+ _legacy_bbt = BBT_Time (0, 0, 0);
+
if ((prop = node.property ("start")) != 0) {
if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
&bbt.bars,
/* legacy session - start used to be in bbt*/
_legacy_bbt = bbt;
pulse = -1.0;
- set_pulse (pulse);
+ info << _("Legacy session detected. TempoSection XML node will be altered.") << endmsg;
}
- } else {
- warning << _("TempoSection XML node has no \"start\" property") << endmsg;
}
-
if ((prop = node.property ("pulse")) != 0) {
- if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1 || pulse < 0.0) {
- error << _("TempoSection XML node has an illegal \"beat\" value") << endmsg;
- } else {
- set_pulse (pulse);
+ if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1) {
+ error << _("TempoSection XML node has an illegal \"pulse\" value") << endmsg;
}
}
+
+ set_pulse (pulse);
+
if ((prop = node.property ("frame")) != 0) {
if (sscanf (prop->value().c_str(), "%" PRIu32, &frame) != 1) {
error << _("TempoSection XML node has an illegal \"frame\" value") << endmsg;
}
if ((prop = node.property ("lock-style")) == 0) {
- set_position_lock_style (MusicTime);
+ if (movable()) {
+ set_position_lock_style (MusicTime);
+ } else {
+ set_position_lock_style (AudioTime);
+ }
} else {
set_position_lock_style (PositionLockStyle (string_2_enum (prop->value(), position_lock_style())));
}
+
+ if ((prop = node.property ("locked-to-meter")) == 0) {
+ set_locked_to_meter (false);
+ } else {
+ set_locked_to_meter (string_is_affirmative (prop->value()));
+ }
}
XMLNode&
root->add_property ("active", buf);
root->add_property ("tempo-type", enum_2_string (_type));
root->add_property ("lock-style", enum_2_string (position_lock_style()));
+ root->add_property ("locked-to-meter", locked_to_meter()?"yes":"no");
return *root;
}
TempoSection::tempo_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
return pulses_per_minute();
}
framepos_t
TempoSection::frame_at_tempo (const double& ppm, const double& b, const framecnt_t& frame_rate) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
return ((b - pulse()) * frames_per_pulse (frame_rate)) + frame();
}
TempoSection::tempo_at_pulse (const double& p) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
return pulses_per_minute();
}
double const ppm = pulse_tempo_at_pulse (p - pulse());
double
TempoSection::pulse_at_tempo (const double& ppm, const framepos_t& f, const framecnt_t& frame_rate) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
double const pulses = ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
return pulses;
}
double
TempoSection::pulse_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
return ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
}
framepos_t
TempoSection::frame_at_pulse (const double& p, const framecnt_t& frame_rate) const
{
- if (_type == Constant) {
+ if (_type == Constant || _c_func == 0.0) {
return (framepos_t) floor ((p - pulse()) * frames_per_pulse (frame_rate)) + frame();
}
b(t) = T0(e^(ct) - 1) / c
To find the time t at beat duration b, we use the inverse function of the beat function (the time function) which can be shown to be:
-t(b) = log((cb / T0) + 1) / c
+t(b) = log((c.b / T0) + 1) / c
The time t at which Tempo T occurs is a as above:
t(T) = log(T / T0) / c
By substituting our expanded t as a in the c function above, our problem is reduced to:
c = T0 (e^(log (Ta / T0)) - 1) / b
+Of course the word 'beat' has been left loosely defined above.
+In music, a beat is defined by the musical pulse (which comes from the tempo)
+and the meter in use at a particular time (how many pulse divisions there are in one bar).
+It would be more accurate to substitute the work 'pulse' for 'beat' above.
+
+Anyway ...
+
We can now store c for future time calculations.
If the following tempo section (the one that defines c in conjunction with this one)
is changed or moved, c is no longer valid.
return c_func (end_bpm, frame_to_minute (end_frame - frame(), frame_rate));
}
-framecnt_t
+framepos_t
TempoSection::minute_to_frame (const double& time, const framecnt_t& frame_rate) const
{
- return (framecnt_t) floor ((time * 60.0 * frame_rate) + 0.5);
+ return (framepos_t) floor ((time * 60.0 * frame_rate) + 0.5);
}
double
-TempoSection::frame_to_minute (const framecnt_t& frame, const framecnt_t& frame_rate) const
+TempoSection::frame_to_minute (const framepos_t& frame, const framecnt_t& frame_rate) const
{
return (frame / (double) frame_rate) / 60.0;
}
/* position function */
double
-TempoSection::a_func (double end_bpm, double c_func) const
+TempoSection::a_func (double end_ppm, double c_func) const
{
- return log (end_bpm / pulses_per_minute()) / c_func;
+ return log (end_ppm / pulses_per_minute()) / c_func;
}
/*function constant*/
double
-TempoSection::c_func (double end_bpm, double end_time) const
+TempoSection::c_func (double end_ppm, double end_time) const
{
- return log (end_bpm / pulses_per_minute()) / end_time;
+ return log (end_ppm / pulses_per_minute()) / end_time;
}
/* tempo in ppm at time in minutes */
const string MeterSection::xml_state_node_name = "Meter";
MeterSection::MeterSection (const XMLNode& node)
- : MetricSection (0.0), Meter (TempoMap::default_meter())
+ : MetricSection (0.0, 0, MusicTime), Meter (TempoMap::default_meter())
{
XMLProperty const * prop;
- BBT_Time start;
LocaleGuard lg;
- const XMLProperty *prop;
BBT_Time bbt;
double pulse = 0.0;
double beat = 0.0;
error << _("MeterSection XML node has an illegal \"start\" value") << endmsg;
} else {
/* legacy session - start used to be in bbt*/
+ info << _("Legacy session detected - MeterSection XML node will be altered.") << endmsg;
pulse = -1.0;
}
- } else {
- error << _("MeterSection XML node has no \"start\" property") << endmsg;
}
if ((prop = node.property ("pulse")) != 0) {
- if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1 || pulse < 0.0) {
+ if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1) {
error << _("MeterSection XML node has an illegal \"pulse\" value") << endmsg;
}
}
if ((prop = node.property ("beat")) != 0) {
if (sscanf (prop->value().c_str(), "%lf", &beat) != 1) {
- error << _("MeterSection XML node has an illegal \"beat\" vlue") << endmsg;
+ error << _("MeterSection XML node has an illegal \"beat\" value") << endmsg;
}
}
start.first = beat;
if ((prop = node.property ("bbt")) == 0) {
- error << _("MeterSection XML node has no \"bbt\" property") << endmsg;
+ warning << _("MeterSection XML node has no \"bbt\" property") << endmsg;
} else if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
&bbt.bars,
&bbt.beats,
&bbt.ticks) < 3) {
error << _("MeterSection XML node has an illegal \"bbt\" value") << endmsg;
- //throw failed_constructor();
+ throw failed_constructor();
}
start.second = bbt;
throw failed_constructor();
}
- if ((prop = node.property ("lock-style")) == 0) {
- warning << _("MeterSection XML node has no \"lock-style\" property") << endmsg;
- set_position_lock_style (MusicTime);
- } else {
- set_position_lock_style (PositionLockStyle (string_2_enum (prop->value(), position_lock_style())));
- }
-
if ((prop = node.property ("movable")) == 0) {
error << _("MeterSection XML node has no \"movable\" property") << endmsg;
throw failed_constructor();
}
set_movable (string_is_affirmative (prop->value()));
+
+ if ((prop = node.property ("lock-style")) == 0) {
+ warning << _("MeterSection XML node has no \"lock-style\" property") << endmsg;
+ if (movable()) {
+ set_position_lock_style (MusicTime);
+ } else {
+ set_position_lock_style (AudioTime);
+ }
+ } else {
+ set_position_lock_style (PositionLockStyle (string_2_enum (prop->value(), position_lock_style())));
+ }
}
XMLNode&
/*
Tempo Map Overview
- Tempo can be thought of as a source of the musical pulse.
- Meters divide that pulse into measures and beats.
- Tempo pulses can be divided to be in sympathy with the meter, but this does not affect the beat
- at any particular time.
+ Tempo is the rate of the musical pulse.
+ Meters divide the pulses into measures and beats.
+
Note that Tempo::beats_per_minute() has nothing to do with musical beats.
It should rather be thought of as tempo note divisions per minute.
Having done this, we can now find any one of tempo, beat, frame or pulse if a beat, frame, pulse or tempo is known.
+ With tepo sections potentially being ramped, meters provide a way of mapping beats to whole pulses without
+ referring to the tempo function(s) involved as the distance in whole pulses between a meter and a subsequent beat is
+ sb->beat() - meter->beat() / meter->note_divisor().
+ Because every meter falls on a known pulse, (derived from its bar), the rest is easy as the duration in pulses between
+ two meters is of course
+ (meater_b->bar - meter_a->bar) * meter_a->divisions_per_bar / meter_a->note_divisor.
+
+ Below, beat calculations are based on meter sections and all pulse and tempo calculations are based on tempo sections.
+ Beat to frame conversion of course requires the use of meter and tempo.
+
+ Remembering that ramped tempo sections interact, it is important to avoid referring to any other tempos when moving tempo sections,
+ Here, beats (meters) are used to determine the new pulse (see predict_tempo_position())
+
The first tempo and first meter are special. they must move together, and must be locked to audio.
Audio locked tempos which lie before the first meter are made inactive.
They will be re-activated if the first meter is again placed before them.
_frame_rate = fr;
BBT_Time start (1, 1, 0);
- TempoSection *t = new TempoSection (0.0, _default_tempo.beats_per_minute(), _default_tempo.note_type(), TempoSection::Constant);
- MeterSection *m = new MeterSection (0.0, 0.0, start, _default_meter.divisions_per_bar(), _default_meter.note_divisor());
+ TempoSection *t = new TempoSection (0.0, 0, _default_tempo.beats_per_minute(), _default_tempo.note_type(), TempoSection::Ramp, AudioTime);
+ MeterSection *m = new MeterSection (0.0, 0, 0.0, start, _default_meter.divisions_per_bar(), _default_meter.note_divisor(), AudioTime);
t->set_movable (false);
m->set_movable (false);
TempoMap::~TempoMap ()
{
+ Metrics::const_iterator d = _metrics.begin();
+ while (d != _metrics.end()) {
+ delete (*d);
+ ++d;
+ }
+ _metrics.clear();
}
void
if (dynamic_cast<TempoSection*> (*i) != 0) {
if (tempo.frame() == (*i)->frame()) {
if ((*i)->movable()) {
+ delete (*i);
_metrics.erase (i);
return true;
}
}
bool
-TempoMap::remove_meter_locked (const MeterSection& tempo)
+TempoMap::remove_meter_locked (const MeterSection& meter)
{
Metrics::iterator i;
+ for (i = _metrics.begin(); i != _metrics.end(); ++i) {
+ TempoSection* t = 0;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (meter.frame() == (*i)->frame()) {
+ if (t->locked_to_meter()) {
+ delete (*i);
+ _metrics.erase (i);
+ break;
+ }
+ }
+ }
+ }
+
for (i = _metrics.begin(); i != _metrics.end(); ++i) {
if (dynamic_cast<MeterSection*> (*i) != 0) {
- if (tempo.frame() == (*i)->frame()) {
+ if (meter.frame() == (*i)->frame()) {
if ((*i)->movable()) {
+ delete (*i);
_metrics.erase (i);
return true;
}
*/
MeterSection* m = 0;
if ((m = dynamic_cast<MeterSection*>(section)) != 0) {
- //assert (m->bbt().ticks == 0);
if ((m->bbt().beats != 1) || (m->bbt().ticks != 0)) {
- pair<double, BBT_Time> corrected = make_pair (m->pulse(), m->bbt());
+ pair<double, BBT_Time> corrected = make_pair (m->beat(), m->bbt());
corrected.second.beats = 1;
corrected.second.ticks = 0;
- corrected.first = bbt_to_beats_locked (_metrics, corrected.second);
+ corrected.first = beat_at_bbt_locked (_metrics, corrected.second);
warning << string_compose (_("Meter changes can only be positioned on the first beat of a bar. Moving from %1 to %2"),
m->bbt(), corrected.second) << endmsg;
//m->set_pulse (corrected);
}
need_add = false;
} else {
+ delete (*i);
_metrics.erase (i);
}
break;
*/
*(dynamic_cast<Meter*>(*i)) = *(dynamic_cast<Meter*>(insert_meter));
- (*i)->set_position_lock_style (insert_meter->position_lock_style());
+ (*i)->set_position_lock_style (AudioTime);
need_add = false;
} else {
+ delete (*i);
_metrics.erase (i);
}
}
_metrics.insert (i, section);
- //dump (_metrics, std::cerr);
+ //dump (_metrics, std::cout);
}
}
-void
-TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const double& pulse, TempoSection::Type type)
+TempoSection*
+TempoMap::add_tempo (const Tempo& tempo, const double& pulse, const framepos_t& frame, ARDOUR::TempoSection::Type type, PositionLockStyle pls)
{
+ TempoSection* ts = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- TempoSection& first (first_tempo());
- if (ts.pulse() != first.pulse()) {
- remove_tempo_locked (ts);
- add_tempo_locked (tempo, pulse, true, type);
- } else {
- first.set_type (type);
- {
- /* cannot move the first tempo section */
- *static_cast<Tempo*>(&first) = tempo;
- recompute_map (_metrics);
- }
- }
+ ts = add_tempo_locked (tempo, pulse, frame, type, pls, true);
}
+
PropertyChanged (PropertyChange ());
+
+ return ts;
}
void
-TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const framepos_t& frame, TempoSection::Type type)
+TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const double& pulse, const framepos_t& frame, TempoSection::Type type, PositionLockStyle pls)
{
+ const bool locked_to_meter = ts.locked_to_meter();
+
{
Glib::Threads::RWLock::WriterLock lm (lock);
TempoSection& first (first_tempo());
if (ts.frame() != first.frame()) {
remove_tempo_locked (ts);
- add_tempo_locked (tempo, frame, true, type);
+ add_tempo_locked (tempo, pulse, frame, type, pls, true, locked_to_meter);
} else {
first.set_type (type);
first.set_pulse (0.0);
+ first.set_frame (frame);
first.set_position_lock_style (AudioTime);
{
/* cannot move the first tempo section */
PropertyChanged (PropertyChange ());
}
-void
-TempoMap::add_tempo (const Tempo& tempo, const double& pulse, ARDOUR::TempoSection::Type type)
-{
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- add_tempo_locked (tempo, pulse, true, type);
- }
-
- PropertyChanged (PropertyChange ());
-}
-
-void
-TempoMap::add_tempo (const Tempo& tempo, const framepos_t& frame, ARDOUR::TempoSection::Type type)
-{
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- add_tempo_locked (tempo, frame, true, type);
- }
-
-
- PropertyChanged (PropertyChange ());
-}
-
-void
-TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, bool recompute, ARDOUR::TempoSection::Type type)
+TempoSection*
+TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, framepos_t frame
+ , TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter)
{
- TempoSection* ts = new TempoSection (pulse, tempo.beats_per_minute(), tempo.note_type(), type);
+ TempoSection* t = new TempoSection (pulse, frame, tempo.beats_per_minute(), tempo.note_type(), type, pls);
+ t->set_locked_to_meter (locked_to_meter);
- do_insert (ts);
+ do_insert (t);
if (recompute) {
- solve_map (_metrics, ts, ts->pulse());
+ if (pls == AudioTime) {
+ solve_map_frame (_metrics, t, t->frame());
+ } else {
+ solve_map_pulse (_metrics, t, t->pulse());
+ }
+ recompute_meters (_metrics);
}
-}
-
-void
-TempoMap::add_tempo_locked (const Tempo& tempo, framepos_t frame, bool recompute, ARDOUR::TempoSection::Type type)
-{
- TempoSection* ts = new TempoSection (frame, tempo.beats_per_minute(), tempo.note_type(), type);
- do_insert (ts);
-
- if (recompute) {
- solve_map (_metrics, ts, ts->frame());
- }
+ return t;
}
-void
-TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const BBT_Time& where)
+MeterSection*
+TempoMap::add_meter (const Meter& meter, const double& beat, const Timecode::BBT_Time& where, const framepos_t& frame, PositionLockStyle pls)
{
+ MeterSection* m = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
+ m = add_meter_locked (meter, beat, where, frame, pls, true);
+ }
- if (ms.movable()) {
- remove_meter_locked (ms);
- add_meter_locked (meter, bbt_to_beats_locked (_metrics, where), where, true);
- } else {
- MeterSection& first (first_meter());
- const PositionLockStyle pl = ms.position_lock_style();
- /* cannot move the first meter section */
- *static_cast<Meter*>(&first) = meter;
- first.set_position_lock_style (pl);
- }
- recompute_map (_metrics);
+
+#ifndef NDEBUG
+ if (DEBUG_ENABLED(DEBUG::TempoMap)) {
+ dump (_metrics, std::cerr);
}
+#endif
PropertyChanged (PropertyChange ());
+ return m;
}
void
-TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const framepos_t& frame)
+TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const BBT_Time& where, const framepos_t& frame, PositionLockStyle pls)
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
-
- const double beat = ms.beat();
- const BBT_Time bbt = ms.bbt();
+ const double beat = beat_at_bbt_locked (_metrics, where);
if (ms.movable()) {
remove_meter_locked (ms);
- add_meter_locked (meter, frame, beat, bbt, true);
+ add_meter_locked (meter, beat, where, frame, pls, true);
} else {
MeterSection& first (first_meter());
TempoSection& first_t (first_tempo());
first_t.set_frame (first.frame());
first_t.set_pulse (0.0);
first_t.set_position_lock_style (AudioTime);
+ recompute_map (_metrics);
}
- recompute_map (_metrics);
- }
- PropertyChanged (PropertyChange ());
-}
-
-
-MeterSection*
-TempoMap::add_meter (const Meter& meter, const double& beat, const BBT_Time& where)
-{
- MeterSection* m = 0;
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- m = add_meter_locked (meter, beat, where, true);
}
-
-#ifndef NDEBUG
- if (DEBUG_ENABLED(DEBUG::TempoMap)) {
- dump (_metrics, std::cerr);
- }
-#endif
-
PropertyChanged (PropertyChange ());
-
- return m;
}
MeterSection*
-TempoMap::add_meter (const Meter& meter, const framepos_t& frame, const double& beat, const Timecode::BBT_Time& where)
+TempoMap::add_meter_locked (const Meter& meter, double beat, const Timecode::BBT_Time& where, framepos_t frame, PositionLockStyle pls, bool recompute)
{
- MeterSection* m = 0;
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- m = add_meter_locked (meter, frame, beat, where, true);
- }
-
+ const MeterSection& prev_m = meter_section_at_locked (_metrics, frame - 1);
+ const double pulse = ((where.bars - prev_m.bbt().bars) * (prev_m.divisions_per_bar() / prev_m.note_divisor())) + prev_m.pulse();
-#ifndef NDEBUG
- if (DEBUG_ENABLED(DEBUG::TempoMap)) {
- dump (_metrics, std::cerr);
+ if (pls == AudioTime) {
+ /* add meter-locked tempo */
+ add_tempo_locked (tempo_at_frame_locked (_metrics, frame), pulse, frame, TempoSection::Ramp, AudioTime, true, true);
}
-#endif
-
- PropertyChanged (PropertyChange ());
-
- return m;
-}
-
-MeterSection*
-TempoMap::add_meter_locked (const Meter& meter, double beat, BBT_Time where, bool recompute)
-{
- /* a new meter always starts a new bar on the first beat. so
- round the start time appropriately. remember that
- `where' is based on the existing tempo map, not
- the result after we insert the new meter.
- */
+ MeterSection* new_meter = new MeterSection (pulse, frame, beat, where, meter.divisions_per_bar(), meter.note_divisor(), pls);
- if (where.beats != 1) {
- where.beats = 1;
- where.bars++;
- }
- /* new meters *always* start on a beat. */
- where.ticks = 0;
- const double pulse = pulse_at_beat_locked (_metrics, beat);
- MeterSection* new_meter = new MeterSection (pulse, beat, where, meter.divisions_per_bar(), meter.note_divisor());
do_insert (new_meter);
if (recompute) {
- solve_map (_metrics, new_meter, pulse);
- }
-
- return new_meter;
-}
-MeterSection*
-TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, double beat, Timecode::BBT_Time where, bool recompute)
-{
-
- MeterSection* new_meter = new MeterSection (frame, beat, where, meter.divisions_per_bar(), meter.note_divisor());
-
- double pulse = pulse_at_frame_locked (_metrics, frame);
- new_meter->set_pulse (pulse);
-
- do_insert (new_meter);
-
- if (recompute) {
- solve_map (_metrics, new_meter, frame);
+ if (pls == AudioTime) {
+ solve_map_frame (_metrics, new_meter, frame);
+ } else {
+ solve_map_bbt (_metrics, new_meter, where);
+ }
}
return new_meter;
if (!t->active()) {
continue;
}
+ if (!t->movable()) {
+ if (!prev_t) {
+ t->set_pulse (0.0);
+ prev_t = t;
+ continue;
+ }
+ }
if (prev_t) {
if (t->position_lock_style() == AudioTime) {
prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
+ if (!t->locked_to_meter()) {
+ t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
+ }
} else {
prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
prev_t->set_c_func (0.0);
}
-/* tempos must be positioned correctly */
+/* tempos must be positioned correctly.
+ the current approach is to use a meter's bbt time as its base position unit.
+ an audio-locked meter requires a recomputation of pulse and beat (but not bbt),
+ while a music-locked meter requires recomputations of frame pulse and beat (but not bbt)
+*/
void
TempoMap::recompute_meters (Metrics& metrics)
{
if (meter->position_lock_style() == AudioTime) {
double pulse = 0.0;
pair<double, BBT_Time> b_bbt;
- if (meter->movable()) {
- const double beats = ((pulse_at_frame_locked (metrics, meter->frame()) - prev_m->pulse()) * prev_m->note_divisor());
- const double floor_beats = beats - fmod (beats, prev_m->divisions_per_bar());
- b_bbt = make_pair (floor_beats + prev_m->beat(), BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
- const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor());
- const double pulse_off = true_pulse - (beats / prev_m->note_divisor());
- pulse = true_pulse - pulse_off;
+ TempoSection* meter_locked_tempo = 0;
+ for (Metrics::const_iterator ii = metrics.begin(); ii != metrics.end(); ++ii) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
+ if ((t->locked_to_meter() || !t->movable()) && t->frame() == meter->frame()) {
+ meter_locked_tempo = t;
+ break;
+ }
+ }
+ }
+
+ if (prev_m) {
+ const double beats = (meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
+ if (beats + prev_m->beat() != meter->beat()) {
+ /* reordering caused a bbt change */
+ b_bbt = make_pair (beats + prev_m->beat()
+ , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
+ pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
+
+ } else if (meter->movable()) {
+ b_bbt = make_pair (meter->beat(), meter->bbt());
+ pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
+ }
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
+ if (meter_locked_tempo) {
+ meter_locked_tempo->set_pulse (pulse);
+ }
meter->set_beat (b_bbt);
meter->set_pulse (pulse);
+
} else {
+ /* MusicTime */
double pulse = 0.0;
+ pair<double, BBT_Time> b_bbt;
if (prev_m) {
- pulse = prev_m->pulse() + ((meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar() / prev_m->note_divisor());
+ const double beats = (meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
+ if (beats + prev_m->beat() != meter->beat()) {
+ /* reordering caused a bbt change */
+ b_bbt = make_pair (beats + prev_m->beat()
+ , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
+ } else {
+ b_bbt = make_pair (beats + prev_m->beat(), meter->bbt());
+ }
+ pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
} else {
/* shouldn't happen - the first is audio-locked */
pulse = pulse_at_beat_locked (metrics, meter->beat());
+ b_bbt = make_pair (meter->beat(), meter->bbt());
}
- pair<double, BBT_Time> new_beat (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), meter->bbt());
- meter->set_beat (new_beat);
- meter->set_frame (frame_at_pulse_locked (metrics, pulse));
+
+ meter->set_beat (b_bbt);
meter->set_pulse (pulse);
+ meter->set_frame (frame_at_pulse_locked (metrics, pulse));
}
prev_m = meter;
}
}
- //dump (_metrics, std::cerr;
}
void
}
double
-TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
+TempoMap::beat_at_frame (const framecnt_t& frame) const
{
- /* HOLD (at least) THE READER LOCK */
- TempoSection* prev_t = 0;
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return beat_at_frame_locked (_metrics, frame);
+}
+
+/* meter / tempo section based */
+double
+TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
+{
+ const TempoSection& ts = tempo_section_at_locked (metrics, frame);
+ MeterSection* prev_m = 0;
+ MeterSection* next_m = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
- TempoSection* t;
- if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
- if (!t->active()) {
- continue;
- }
- if (prev_t && t->frame() > frame) {
- /*the previous ts is the one containing the frame */
- const double ret = prev_t->pulse_at_frame (frame, _frame_rate);
- return ret;
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->frame() > frame) {
+ next_m = m;
+ break;
}
- prev_t = t;
+ prev_m = m;
}
}
+ if (frame < prev_m->frame()) {
+ return 0.0;
+ }
+ const double beat = prev_m->beat() + (ts.pulse_at_frame (frame, _frame_rate) - prev_m->pulse()) * prev_m->note_divisor();
- /* treated as constant for this ts */
- const double pulses_in_section = (frame - prev_t->frame()) / prev_t->frames_per_pulse (_frame_rate);
+ if (next_m && next_m->beat() < beat) {
+ return next_m->beat();
+ }
- return pulses_in_section + prev_t->pulse();
+ return beat;
}
-double
-TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
+framecnt_t
+TempoMap::frame_at_beat (const double& beat) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return frame_at_beat_locked (_metrics, beat);
+}
+
+/* meter section based */
+framecnt_t
+TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
{
+ const TempoSection& prev_t = tempo_section_at_beat_locked (metrics, beat);
MeterSection* prev_m = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
}
prev_m = m;
}
-
}
- double const ret = prev_m->pulse() + ((beat - prev_m->beat()) / prev_m->note_divisor());
- return ret;
+
+ return prev_t.frame_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse(), _frame_rate);
}
double
}
double
-TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
{
MeterSection* prev_m = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_m && m->pulse() > pulse) {
+ if (prev_m && m->beat() > beat) {
break;
}
prev_m = m;
}
- }
-
- double const beats_in_section = (pulse - prev_m->pulse()) * prev_m->note_divisor();
- return beats_in_section + prev_m->beat();
+ }
+ double const ret = prev_m->pulse() + ((beat - prev_m->beat()) / prev_m->note_divisor());
+ return ret;
}
double
return beat_at_pulse_locked (_metrics, pulse);
}
-framecnt_t
-TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+double
+TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const
{
- /* HOLD THE READER LOCK */
-
- const TempoSection* prev_t = 0;
+ MeterSection* prev_m = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
- TempoSection* t;
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->pulse() > pulse) {
+ if (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > m->beat()) {
+ break;
+ }
+ }
+ prev_m = m;
+ }
+ }
+
+ double const ret = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat();
+ return ret;
+}
+
+double
+TempoMap::pulse_at_frame (const framecnt_t& frame) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return pulse_at_frame_locked (_metrics, frame);
+}
+
+/* tempo section based */
+double
+TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
+{
+ /* HOLD (at least) THE READER LOCK */
+ TempoSection* prev_t = 0;
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (!t->active()) {
+ continue;
+ }
+ if (prev_t && t->frame() > frame) {
+ /*the previous ts is the one containing the frame */
+ const double ret = prev_t->pulse_at_frame (frame, _frame_rate);
+ return ret;
+ }
+ prev_t = t;
+ }
+ }
+
+ /* treated as constant for this ts */
+ const double pulses_in_section = (frame - prev_t->frame()) / prev_t->frames_per_pulse (_frame_rate);
+
+ return pulses_in_section + prev_t->pulse();
+}
+
+framecnt_t
+TempoMap::frame_at_pulse (const double& pulse) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return frame_at_pulse_locked (_metrics, pulse);
+}
+
+/* tempo section based */
+framecnt_t
+TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+{
+ /* HOLD THE READER LOCK */
+
+ const TempoSection* prev_t = 0;
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
if (!t->active()) {
return ret;
}
-double
-TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
-{
- const double pulse = pulse_at_frame_locked (metrics, frame);
- return beat_at_pulse_locked (metrics, pulse);
-}
-
-double
-TempoMap::beat_at_frame (const framecnt_t& frame) const
+const Tempo
+TempoMap::tempo_at_frame (const framepos_t& frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return beat_at_frame_locked (_metrics, frame);
+ return tempo_at_frame_locked (_metrics, frame);
}
-framecnt_t
-TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
+const Tempo
+TempoMap::tempo_at_frame_locked (const Metrics& metrics, const framepos_t& frame) const
{
- const framecnt_t frame = frame_at_pulse_locked (metrics, pulse_at_beat_locked (metrics, beat));
- return frame;
+ TempoSection* prev_t = 0;
+
+ Metrics::const_iterator i;
+
+ for (i = _metrics.begin(); i != _metrics.end(); ++i) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (!t->active()) {
+ continue;
+ }
+ if ((prev_t) && t->frame() > frame) {
+ /* t is the section past frame */
+ const double ret_bpm = prev_t->tempo_at_frame (frame, _frame_rate) * prev_t->note_type();
+ const Tempo ret_tempo (ret_bpm, prev_t->note_type());
+ return ret_tempo;
+ }
+ prev_t = t;
+ }
+ }
+
+ const double ret = prev_t->beats_per_minute();
+ const Tempo ret_tempo (ret, prev_t->note_type ());
+
+ return ret_tempo;
}
-framecnt_t
-TempoMap::frame_at_beat (const double& beat) const
+
+double
+TempoMap::beat_at_bbt (const Timecode::BBT_Time& bbt)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return frame_at_beat_locked (_metrics, beat);
+ return beat_at_bbt_locked (_metrics, bbt);
}
+
double
-TempoMap::bbt_to_beats_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const
+TempoMap::beat_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const
{
/* CALLER HOLDS READ LOCK */
}
}
- const double remaining_bars = (bbt.bars - 1) - (prev_m->bbt().bars - 1);
+ const double remaining_bars = bbt.bars - prev_m->bbt().bars;
const double remaining_bars_in_beats = remaining_bars * prev_m->divisions_per_bar();
const double ret = remaining_bars_in_beats + prev_m->beat() + (bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat);
return ret;
}
-double
-TempoMap::bbt_to_beats (const Timecode::BBT_Time& bbt)
+Timecode::BBT_Time
+TempoMap::bbt_at_beat (const double& beats)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return bbt_to_beats_locked (_metrics, bbt);
+ return bbt_at_beat_locked (_metrics, beats);
}
Timecode::BBT_Time
-TempoMap::beats_to_bbt_locked (const Metrics& metrics, const double& b) const
+TempoMap::bbt_at_beat_locked (const Metrics& metrics, const double& b) const
{
/* CALLER HOLDS READ LOCK */
MeterSection* prev_m = 0;
- const double beats = (b < 0.0) ? 0.0 : b;
+ const double beats = max (0.0, b);
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m = 0;
return ret;
}
-Timecode::BBT_Time
-TempoMap::beats_to_bbt (const double& beats)
+double
+TempoMap::pulse_at_bbt (const Timecode::BBT_Time& bbt)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return beats_to_bbt_locked (_metrics, beats);
+
+ return pulse_at_bbt_locked (_metrics, bbt);
+}
+
+double
+TempoMap::pulse_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const
+{
+ /* CALLER HOLDS READ LOCK */
+
+ MeterSection* prev_m = 0;
+
+ /* because audio-locked meters have 'fake' integral beats,
+ there is no pulse offset here.
+ */
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m) {
+ if (m->bbt().bars > bbt.bars) {
+ break;
+ }
+ }
+ prev_m = m;
+ }
+ }
+
+ const double remaining_bars = bbt.bars - prev_m->bbt().bars;
+ const double remaining_pulses = remaining_bars * prev_m->divisions_per_bar() / prev_m->note_divisor();
+ const double ret = remaining_pulses + prev_m->pulse() + (((bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat)) / prev_m->note_divisor());
+
+ return ret;
}
Timecode::BBT_Time
-TempoMap::pulse_to_bbt (const double& pulse)
+TempoMap::bbt_at_pulse (const double& pulse)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
+
+ return bbt_at_pulse_locked (_metrics, pulse);
+}
+
+Timecode::BBT_Time
+TempoMap::bbt_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+{
MeterSection* prev_m = 0;
- for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m = 0;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
Glib::Threads::RWLock::ReaderLock lm (lock);
const double beat = beat_at_frame_locked (_metrics, frame);
- bbt = beats_to_bbt_locked (_metrics, beat);
-}
-
-framepos_t
-TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
-{
- /* HOLD THE READER LOCK */
-
- const framepos_t ret = frame_at_beat_locked (metrics, bbt_to_beats_locked (metrics, bbt));
- return ret;
+ bbt = bbt_at_beat_locked (_metrics, beat);
}
framepos_t
return frame_time_locked (_metrics, bbt);
}
+/* meter section based */
+framepos_t
+TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
+{
+ /* HOLD THE READER LOCK */
+
+ const framepos_t ret = frame_at_beat_locked (metrics, beat_at_bbt_locked (metrics, bbt));
+ return ret;
+}
+
bool
-TempoMap::check_solved (Metrics& metrics, bool by_frame)
+TempoMap::check_solved (const Metrics& metrics) const
{
TempoSection* prev_t = 0;
+ MeterSection* prev_m = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
TempoSection* t;
+ MeterSection* m;
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
if (!t->active()) {
continue;
}
if (prev_t) {
- if ((by_frame && t->frame() < prev_t->frame()) || (!by_frame && t->pulse() < prev_t->pulse())) {
+ if ((t->frame() <= prev_t->frame()) || (t->pulse() <= prev_t->pulse())) {
return false;
}
- if (t->frame() == prev_t->frame()) {
- return false;
+ /* precision check ensures tempo and frames align.*/
+ if (t->frame() != prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate)) {
+ if (!t->locked_to_meter()) {
+ return false;
+ }
}
+ }
+ prev_t = t;
+ }
+
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->position_lock_style() == AudioTime) {
+ TempoSection* t = const_cast<TempoSection*>(&tempo_section_at_locked (metrics, m->frame() - 1));
+ const double nascent_m_pulse = ((m->beat() - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse();
+ const framepos_t nascent_m_frame = t->frame_at_pulse (nascent_m_pulse, _frame_rate);
- /* precision check ensures pulses and frames align independent of lock style.*/
- if (by_frame && t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) {
+ if (t && (nascent_m_frame > m->frame() || nascent_m_frame < 0)) {
return false;
}
}
- prev_t = t;
+
+ prev_m = m;
}
+
}
return true;
}
bool
-TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t& frame)
+TempoMap::solve_map_frame (Metrics& imaginary, TempoSection* section, const framepos_t& frame)
{
TempoSection* prev_t = 0;
TempoSection* section_prev = 0;
}
if (section->movable() && frame <= first_m_frame) {
return false;
- } else {
- section->set_active (true);
}
+
+ section->set_active (true);
section->set_frame (frame);
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
} else {
prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+ if (!t->locked_to_meter()) {
+ t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+ }
}
}
prev_t = t;
if (section_prev) {
section_prev->set_c_func (section_prev->compute_c_func_frame (section->pulses_per_minute(), frame, _frame_rate));
- section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate));
+ if (!section->locked_to_meter()) {
+ section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate));
+ }
}
- if (section->position_lock_style() == MusicTime) {
- /* we're setting the frame */
- section->set_position_lock_style (AudioTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (MusicTime);
- } else {
- recompute_tempos (imaginary);
- }
+ recompute_tempos (imaginary);
- if (check_solved (imaginary, true)) {
- recompute_meters (imaginary);
+ if (check_solved (imaginary)) {
return true;
}
MetricSectionFrameSorter fcmp;
imaginary.sort (fcmp);
- if (section->position_lock_style() == MusicTime) {
- /* we're setting the frame */
- section->set_position_lock_style (AudioTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (MusicTime);
- } else {
- recompute_tempos (imaginary);
- }
- if (check_solved (imaginary, true)) {
- recompute_meters (imaginary);
- return true;
- }
- MetricSectionSorter cmp;
- imaginary.sort (cmp);
- if (section->position_lock_style() == MusicTime) {
- /* we're setting the frame */
- section->set_position_lock_style (AudioTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (MusicTime);
- } else {
- recompute_tempos (imaginary);
- }
- if (check_solved (imaginary, true)) {
- recompute_meters (imaginary);
+ recompute_tempos (imaginary);
+
+ if (check_solved (imaginary)) {
return true;
}
- //dump (imaginary, std::cerr);
return false;
}
bool
-TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pulse)
+TempoMap::solve_map_pulse (Metrics& imaginary, TempoSection* section, const double& pulse)
{
TempoSection* prev_t = 0;
TempoSection* section_prev = 0;
if (!t->active()) {
continue;
}
+ if (!t->movable()) {
+ t->set_pulse (0.0);
+ prev_t = t;
+ continue;
+ }
if (prev_t) {
if (t == section) {
section_prev = prev_t;
t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
} else {
prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+ if (!t->locked_to_meter()) {
+ t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+ }
}
}
prev_t = t;
}
}
+
if (section_prev) {
section_prev->set_c_func (section_prev->compute_c_func_pulse (section->pulses_per_minute(), pulse, _frame_rate));
section->set_frame (section_prev->frame_at_pulse (pulse, _frame_rate));
}
- if (section->position_lock_style() == AudioTime) {
- /* we're setting the pulse */
- section->set_position_lock_style (MusicTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (AudioTime);
- } else {
- recompute_tempos (imaginary);
- }
- if (check_solved (imaginary, false)) {
- recompute_meters (imaginary);
+ recompute_tempos (imaginary);
+
+ if (check_solved (imaginary)) {
return true;
}
MetricSectionSorter cmp;
imaginary.sort (cmp);
- if (section->position_lock_style() == AudioTime) {
- /* we're setting the pulse */
- section->set_position_lock_style (MusicTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (AudioTime);
- } else {
- recompute_tempos (imaginary);
- }
-
- if (check_solved (imaginary, false)) {
- recompute_meters (imaginary);
- return true;
- }
- MetricSectionFrameSorter fcmp;
- imaginary.sort (fcmp);
- if (section->position_lock_style() == AudioTime) {
- /* we're setting the pulse */
- section->set_position_lock_style (MusicTime);
- recompute_tempos (imaginary);
- section->set_position_lock_style (AudioTime);
- } else {
- recompute_tempos (imaginary);
- }
-
- if (check_solved (imaginary, false)) {
- recompute_meters (imaginary);
+ recompute_tempos (imaginary);
+ /* Reordering
+ * XX need a restriction here, but only for this case,
+ * as audio locked tempos don't interact in the same way.
+ *
+ * With music-locked tempos, the solution to cross-dragging can fly off the screen
+ * e.g.
+ * |50 bpm |250 bpm |60 bpm
+ * drag 250 to the pulse after 60->
+ * a clue: dragging the second 60 <- past the 250 would cause no such problem.
+ */
+ if (check_solved (imaginary)) {
return true;
}
- //dump (imaginary, std::cerr);
-
return false;
}
-void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
+bool
+TempoMap::solve_map_frame (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
{
- MeterSection* prev_m = 0;
- MeterSection* section_prev = 0; // section previous to section
+ /* disallow moving first meter past any subsequent one, and any movable meter before the first one */
+ const MeterSection* other = &meter_section_at_locked (imaginary, frame);
+ if ((!section->movable() && other->movable()) || (!other->movable() && section->movable() && other->frame() >= frame)) {
+ return false;
+ }
if (!section->movable()) {
/* lock the first tempo to our first meter */
if (!set_active_tempos (imaginary, frame)) {
- return;
+ return false;
}
- TempoSection* first_t = &first_tempo();
- Metrics future_map;
- TempoSection* new_section = copy_metrics_and_point (future_map, first_t);
-
- new_section->set_frame (frame);
- new_section->set_pulse (0.0);
- new_section->set_active (true);
+ }
- if (solve_map (future_map, new_section, frame)) {
- first_t->set_frame (frame);
- first_t->set_pulse (0.0);
- first_t->set_active (true);
- solve_map (imaginary, first_t, frame);
- } else {
- return;
+ /* it would make sense to bail out if there is no audio-locked meter,
+ however it may be desirable to move a music-locked meter by frame at some point.
+ */
+ TempoSection* meter_locked_tempo = 0;
+ for (Metrics::const_iterator ii = imaginary.begin(); ii != imaginary.end(); ++ii) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
+ if ((t->locked_to_meter() || !t->movable()) && t->frame() == section->frame()) {
+ meter_locked_tempo = t;
+ break;
+ }
}
}
- section->set_frame (frame);
+ if (!meter_locked_tempo) {
+ return false;
+ }
+
+ MeterSection* prev_m = 0;
+ Metrics future_map;
+ TempoSection* tempo_copy = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+ bool solved = false;
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (m == section){
- section_prev = prev_m;
- continue;
- }
- if (prev_m) {
- double pulse = 0.0;
- if (m->position_lock_style() == MusicTime) {
- pulse = prev_m->pulse() + ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar() / prev_m->note_divisor());
- m->set_frame (frame_at_pulse_locked (imaginary, pulse));
- if (pulse > section->pulse()) {
- /* moving 'section' will affect later meters' beat (but not bbt).*/
- pair<double, BBT_Time> new_beat (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt());
- m->set_beat (new_beat);
+ if (prev_m && section->movable()) {
+ const double beats = (pulse_at_frame_locked (imaginary, frame) - prev_m->pulse()) * prev_m->note_divisor();
+ if (beats + prev_m->beat() < section->beat()) {
+ /* set the frame/pulse corresponding to its musical position,
+ * as an earlier time than this has been requested.
+ */
+ const double new_pulse = ((section->beat() - prev_m->beat())
+ / prev_m->note_divisor()) + prev_m->pulse();
+
+ const framepos_t smallest_frame = frame_at_pulse_locked (future_map, new_pulse);
+
+ if ((solved = solve_map_frame (future_map, tempo_copy, smallest_frame))) {
+ meter_locked_tempo->set_pulse (new_pulse);
+ solve_map_frame (imaginary, meter_locked_tempo, smallest_frame);
+ section->set_frame (smallest_frame);
+ section->set_pulse (new_pulse);
+ } else {
+ solved = false;
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
+
+ if (!solved) {
+ return false;
+ }
+ } else {
+ /* all is ok. set section's tempo */
+ MeterSection* meter_copy = const_cast<MeterSection*> (&meter_section_at_locked (future_map, section->frame()));
+ meter_copy->set_frame (frame);
+
+ if ((solved = solve_map_frame (future_map, tempo_copy, frame))) {
+ section->set_frame (frame);
+ meter_locked_tempo->set_pulse (((section->beat() - prev_m->beat())
+ / prev_m->note_divisor()) + prev_m->pulse());
+ solve_map_frame (imaginary, meter_locked_tempo, frame);
+ } else {
+ solved = false;
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
+
+ if (!solved) {
+ return false;
+ }
}
} else {
- pair<double, BBT_Time> b_bbt;
- if (m->movable()) {
- const double beats = ((pulse_at_frame_locked (imaginary, m->frame()) - prev_m->pulse()) * prev_m->note_divisor());
- const double floor_beats = beats - fmod (beats , prev_m->divisions_per_bar());
- b_bbt = make_pair (floor_beats + prev_m->beat()
- , BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
- const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor());
- const double pulse_off = true_pulse - (beats / prev_m->note_divisor());
- pulse = true_pulse - pulse_off;
+ /* not movable (first meter atm) */
+
+ tempo_copy->set_frame (frame);
+ tempo_copy->set_pulse (0.0);
+
+ if ((solved = solve_map_frame (future_map, tempo_copy, frame))) {
+ section->set_frame (frame);
+ meter_locked_tempo->set_frame (frame);
+ meter_locked_tempo->set_pulse (0.0);
+ solve_map_frame (imaginary, meter_locked_tempo, frame);
} else {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- pulse = 0.0;
+ solved = false;
}
- m->set_beat (b_bbt);
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
+
+ if (!solved) {
+ return false;
+ }
+
+ pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ section->set_beat (b_bbt);
+ section->set_pulse (0.0);
+
}
- m->set_pulse (pulse);
+ break;
}
+
prev_m = m;
}
}
- if (section_prev || !section->movable()) {
- /*
- here we set the beat for this frame.
- we set it 'incorrectly' to the next bar's first beat
- and use the delat to find the meter's pulse.
- */
- double pulse = 0.0;
- pair<double, BBT_Time> b_bbt;
- if (section->movable()) {
- const double beats = ((pulse_at_frame_locked (imaginary, frame) - prev_m->pulse()) * prev_m->note_divisor());
- const double floor_beats = beats - fmod (beats, prev_m->divisions_per_bar());
- b_bbt = make_pair (floor_beats + prev_m->beat(), BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
- const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor());
- const double pulse_off = true_pulse - (beats / prev_m->note_divisor());
- pulse = true_pulse - pulse_off;
- } else {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- }
- section->set_beat (b_bbt);
- section->set_pulse (pulse);
- }
+ MetricSectionFrameSorter fcmp;
+ imaginary.sort (fcmp);
- if (section->position_lock_style() == MusicTime) {
- /* we're setting the frame */
- section->set_position_lock_style (AudioTime);
- recompute_meters (imaginary);
- section->set_position_lock_style (MusicTime);
- } else {
- recompute_meters (imaginary);
- }
- //dump (imaginary, std::cerr);
+ recompute_meters (imaginary);
+
+ return true;
}
-void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pulse)
+bool
+TempoMap::solve_map_bbt (Metrics& imaginary, MeterSection* section, const BBT_Time& when)
{
+ /* disallow setting section to an existing meter's bbt */
+ for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (m != section && m->bbt().bars == when.bars) {
+ return false;
+ }
+ }
+ }
+
MeterSection* prev_m = 0;
MeterSection* section_prev = 0;
- section->set_pulse (pulse);
-
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (m == section){
+ pair<double, BBT_Time> b_bbt;
+ double new_pulse = 0.0;
+
+ if (prev_m && m->bbt().bars > when.bars && !section_prev){
section_prev = prev_m;
+ const double beats = (when.bars - section_prev->bbt().bars) * section_prev->divisions_per_bar();
+ const double pulse = (beats / section_prev->note_divisor()) + section_prev->pulse();
+ pair<double, BBT_Time> b_bbt = make_pair (beats + section_prev->beat(), when);
+
+ section->set_beat (b_bbt);
+ section->set_pulse (pulse);
+ section->set_frame (frame_at_pulse_locked (imaginary, pulse));
+ prev_m = section;
continue;
}
- if (prev_m) {
- double pulse = 0.0;
- if (m->position_lock_style() == MusicTime) {
- pulse = prev_m->pulse() + ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar() / prev_m->note_divisor());
- m->set_frame (frame_at_pulse_locked (imaginary, pulse));
-
- if (pulse > section->pulse()) {
- /* moving 'section' will affect later meters' beat (but not bbt).*/
- pair<double, BBT_Time> new_beat (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt());
- m->set_beat (new_beat);
+
+ if (m->position_lock_style() == AudioTime) {
+ TempoSection* meter_locked_tempo = 0;
+
+ for (Metrics::const_iterator ii = imaginary.begin(); ii != imaginary.end(); ++ii) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
+ if ((t->locked_to_meter() || !t->movable()) && t->frame() == m->frame()) {
+ meter_locked_tempo = t;
+ break;
+ }
}
- } else {
- pair<double, BBT_Time> b_bbt;
- if (m->movable()) {
- const double beats = ((pulse_at_frame_locked (imaginary, m->frame()) - prev_m->pulse()) * prev_m->note_divisor());
- const double floor_beats = beats - fmod (beats, prev_m->divisions_per_bar());
- b_bbt = make_pair (floor_beats + prev_m->beat()
- , BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
- const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor());
- const double pulse_off = true_pulse - (beats / prev_m->note_divisor());
- pulse = true_pulse - pulse_off;
- } else {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ }
+
+ if (!meter_locked_tempo) {
+ return false;
+ }
+
+ if (prev_m) {
+ const double beats = ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar());
+
+ if (beats + prev_m->beat() != m->beat()) {
+ /* tempo/ meter change caused a change in beat (bar). */
+ b_bbt = make_pair (beats + prev_m->beat()
+ , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
+ new_pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
+ } else if (m->movable()) {
+ b_bbt = make_pair (m->beat(), m->bbt());
+ new_pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
}
- m->set_beat (b_bbt);
+ } else {
+ b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
- m->set_pulse (pulse);
+
+ meter_locked_tempo->set_pulse (new_pulse);
+ m->set_beat (b_bbt);
+ m->set_pulse (new_pulse);
+
+ } else {
+ /* MusicTime */
+ const double beats = ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar());
+ if (beats + prev_m->beat() != m->beat()) {
+ /* tempo/ meter change caused a change in beat (bar). */
+ b_bbt = make_pair (beats + prev_m->beat()
+ , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
+ } else {
+ b_bbt = make_pair (beats + prev_m->beat()
+ , m->bbt());
+ }
+ new_pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
+ m->set_beat (b_bbt);
+ m->set_pulse (new_pulse);
+ m->set_frame (frame_at_pulse_locked (imaginary, new_pulse));
}
+
prev_m = m;
}
}
- if (section_prev) {
- const double beats = ((pulse - section_prev->pulse()) * section_prev->note_divisor());
- const int32_t bars = (beats + 1) / section_prev->divisions_per_bar();
- pair<double, BBT_Time> b_bbt = make_pair (beats + section_prev->beat(), BBT_Time (bars + section_prev->bbt().bars, 1, 0));
+ if (!section_prev) {
+
+ const double beats = (when.bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
+ const double pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
+ pair<double, BBT_Time> b_bbt = make_pair (beats + prev_m->beat(), when);
+
section->set_beat (b_bbt);
+ section->set_pulse (pulse);
section->set_frame (frame_at_pulse_locked (imaginary, pulse));
}
MetricSectionSorter cmp;
imaginary.sort (cmp);
- if (section->position_lock_style() == AudioTime) {
- /* we're setting the pulse */
- section->set_position_lock_style (MusicTime);
- recompute_meters (imaginary);
- section->set_position_lock_style (AudioTime);
- } else {
- recompute_meters (imaginary);
- }
+
+ recompute_meters (imaginary);
+
+ return true;
}
/** places a copy of _metrics into copy and returns a pointer
- * to section's equivalent.
+ * to section's equivalent in copy.
*/
TempoSection*
-TempoMap::copy_metrics_and_point (Metrics& copy, TempoSection* section)
+TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section)
{
- TempoSection* t;
TempoSection* ret = 0;
- MeterSection* m;
- for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+ MeterSection* m;
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
if (t == section) {
- if (t->position_lock_style() == MusicTime) {
- ret = new TempoSection (t->pulse(), t->beats_per_minute(), t->note_type(), t->type());
- } else {
- ret = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
- }
- ret->set_active (t->active());
- ret->set_movable (t->movable());
+ ret = new TempoSection (*t);
copy.push_back (ret);
continue;
}
- TempoSection* cp = 0;
- if (t->position_lock_style() == MusicTime) {
- cp = new TempoSection (t->pulse(), t->beats_per_minute(), t->note_type(), t->type());
- } else {
- cp = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
- }
- cp->set_active (t->active());
- cp->set_movable (t->movable());
+
+ TempoSection* cp = new TempoSection (*t);
copy.push_back (cp);
}
if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
- MeterSection* cp = 0;
- if (m->position_lock_style() == MusicTime) {
- cp = new MeterSection (m->pulse(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
- cp->set_frame (m->frame());
- } else {
- cp = new MeterSection (m->frame(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
- cp->set_pulse (m->pulse());
+ MeterSection* cp = new MeterSection (*m);
+ copy.push_back (cp);
+ }
+ }
+
+ return ret;
+}
+
+MeterSection*
+TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section)
+{
+ MeterSection* ret = 0;
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+ MeterSection* m;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ TempoSection* cp = new TempoSection (*t);
+ copy.push_back (cp);
+ }
+
+ if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
+ if (m == section) {
+ ret = new MeterSection (*m);
+ copy.push_back (ret);
+ continue;
}
- cp->set_movable (m->movable());
+ MeterSection* cp = new MeterSection (*m);
copy.push_back (cp);
}
}
- //recompute_map (copy);
+
return ret;
}
TempoMap::can_solve_bbt (TempoSection* ts, const BBT_Time& bbt)
{
Metrics copy;
- TempoSection* new_section = 0;
+ TempoSection* tempo_copy = 0;
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- new_section = copy_metrics_and_point (copy, ts);
+ tempo_copy = copy_metrics_and_point (_metrics, copy, ts);
+ if (!tempo_copy) {
+ return false;
+ }
}
- double const beat = bbt_to_beats_locked (copy, bbt);
- bool ret = solve_map (copy, new_section, pulse_at_beat_locked (copy, beat));
+ const bool ret = solve_map_pulse (copy, tempo_copy, pulse_at_bbt_locked (copy, bbt));
Metrics::const_iterator d = copy.begin();
while (d != copy.end()) {
}
/**
-* This is for a gui that needs to know the frame of a tempo section if it were to be moved to some bbt time,
+* This is for a gui that needs to know the pulse or frame of a tempo section if it were to be moved to some bbt time,
* taking any possible reordering as a consequence of this into account.
* @param section - the section to be altered
-* @param bpm - the new Tempo
* @param bbt - the bbt where the altered tempo will fall
-* @return returns - the position in frames where the new tempo section will lie.
+* @return returns - the position in pulses and frames (as a pair) where the new tempo section will lie.
*/
-framepos_t
-TempoMap::predict_tempo_frame (TempoSection* section, const BBT_Time& bbt)
+pair<double, framepos_t>
+TempoMap::predict_tempo_position (TempoSection* section, const BBT_Time& bbt)
{
- Glib::Threads::RWLock::ReaderLock lm (lock);
Metrics future_map;
- framepos_t ret = 0;
- TempoSection* new_section = copy_metrics_and_point (future_map, section);
-
- const double beat = bbt_to_beats_locked (future_map, bbt);
- if (solve_map (future_map, new_section, pulse_at_beat_locked (future_map, beat))) {
- ret = new_section->frame();
- } else {
- ret = frame_at_beat_locked (_metrics, beat);
- }
-
- Metrics::const_iterator d = future_map.begin();
- while (d != future_map.end()) {
- delete (*d);
- ++d;
- }
- return ret;
-}
+ pair<double, framepos_t> ret = make_pair (0.0, 0);
-double
-TempoMap::predict_tempo_pulse (TempoSection* section, const framepos_t& frame)
-{
Glib::Threads::RWLock::ReaderLock lm (lock);
- Metrics future_map;
- double ret = 0.0;
- TempoSection* new_section = copy_metrics_and_point (future_map, section);
- if (solve_map (future_map, new_section, frame)) {
- ret = new_section->pulse();
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, section);
+
+ const double beat = beat_at_bbt_locked (future_map, bbt);
+
+ if (solve_map_pulse (future_map, tempo_copy, pulse_at_beat_locked (future_map, beat))) {
+ ret.first = tempo_copy->pulse();
+ ret.second = tempo_copy->frame();
} else {
- ret = pulse_at_frame_locked (_metrics, frame);
+ ret.first = section->pulse();
+ ret.second = section->frame();
}
Metrics::const_iterator d = future_map.begin();
}
void
-TempoMap::gui_move_tempo_frame (TempoSection* ts, const framepos_t& frame)
+TempoMap::gui_move_tempo (TempoSection* ts, const framepos_t& frame)
{
Metrics future_map;
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- TempoSection* new_section = copy_metrics_and_point (future_map, ts);
- if (solve_map (future_map, new_section, frame)) {
- solve_map (_metrics, ts, frame);
+
+ if (ts->position_lock_style() == MusicTime) {
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
+ const double pulse = pulse_at_frame_locked (future_map, frame);
+ if (solve_map_pulse (future_map, tempo_copy, pulse)) {
+ solve_map_pulse (_metrics, ts, pulse);
+ recompute_meters (_metrics);
+ }
+ }
+
+ } else {
+
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
+ if (solve_map_frame (future_map, tempo_copy, frame)) {
+ solve_map_frame (_metrics, ts, frame);
+ recompute_meters (_metrics);
+ }
}
}
}
void
-TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat)
+TempoMap::gui_move_meter (MeterSection* ms, const framepos_t& frame)
{
Metrics future_map;
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- TempoSection* new_section = copy_metrics_and_point (future_map, ts);
- if (solve_map (future_map, new_section, pulse_at_beat_locked (future_map, beat))) {
- solve_map (_metrics, ts, pulse_at_beat_locked (_metrics, beat));
+
+ if (ms->position_lock_style() == AudioTime) {
+
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+ MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
+
+ if (solve_map_frame (future_map, copy, frame)) {
+ solve_map_frame (_metrics, ms, frame);
+ recompute_tempos (_metrics);
+ }
+ }
+ } else {
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+ MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
+
+ const double beat = beat_at_frame_locked (_metrics, frame);
+ const Timecode::BBT_Time bbt = bbt_at_beat_locked (_metrics, beat);
+
+ if (solve_map_bbt (future_map, copy, bbt)) {
+ solve_map_bbt (_metrics, ms, bbt);
+ recompute_tempos (_metrics);
+ }
}
}
MetricPositionChanged (); // Emit Signal
}
-void
-TempoMap::gui_move_meter (MeterSection* ms, const framepos_t& frame)
-{
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, frame);
- }
-
- MetricPositionChanged (); // Emit Signal
-}
-
-void
-TempoMap::gui_move_meter (MeterSection* ms, const double& beat)
-{
- {
- Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, pulse_at_beat_locked (_metrics, beat));
- }
-
- MetricPositionChanged (); // Emit Signal
-}
-
bool
TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm)
{
bool can_solve = false;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- TempoSection* new_section = copy_metrics_and_point (future_map, ts);
- new_section->set_beats_per_minute (bpm.beats_per_minute());
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
+ tempo_copy->set_beats_per_minute (bpm.beats_per_minute());
recompute_tempos (future_map);
- if (check_solved (future_map, true)) {
+ if (check_solved (future_map)) {
ts->set_beats_per_minute (bpm.beats_per_minute());
recompute_map (_metrics);
can_solve = true;
return can_solve;
}
+void
+TempoMap::gui_dilate_tempo (TempoSection* ts, const framepos_t& frame, const framepos_t& end_frame, const double& pulse)
+{
+ /*
+ Ts (future prev_t) Tnext
+ | |
+ | [drag^] |
+ |----------|----------
+ e_f pulse(frame)
+ */
+
+ Metrics future_map;
+
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+
+ if (!ts) {
+ return;
+ }
+
+ TempoSection* prev_t = copy_metrics_and_point (_metrics, future_map, ts);
+ TempoSection* prev_to_prev_t = 0;
+ const frameoffset_t fr_off = end_frame - frame;
+
+ if (prev_t && prev_t->pulse() > 0.0) {
+ prev_to_prev_t = const_cast<TempoSection*>(&tempo_section_at_locked (future_map, prev_t->frame() - 1));
+ }
+
+ TempoSection* next_t = 0;
+ for (Metrics::iterator i = future_map.begin(); i != future_map.end(); ++i) {
+ TempoSection* t = 0;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (t->frame() > ts->frame()) {
+ next_t = t;
+ break;
+ }
+ }
+ }
+
+ /* the change in frames is the result of changing the slope of at most 2 previous tempo sections.
+ constant to constant is straightforward, as the tempo prev to prev_t has constant slope.
+ */
+ double contribution = 0.0;
+ double start_pulse = prev_t->pulse_at_frame (frame, _frame_rate);
+
+ if (next_t && prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+ contribution = (prev_t->frame() - prev_to_prev_t->frame()) / (double) (next_t->frame() - prev_to_prev_t->frame());
+ }
+
+ frameoffset_t prev_t_frame_contribution = fr_off - (contribution * (double) fr_off);
+ double end_pulse = prev_t->pulse_at_frame (end_frame, _frame_rate);
+ double new_bpm;
+
+ if (prev_t->type() == TempoSection::Constant || prev_t->c_func() == 0.0) {
+
+ if (prev_t->position_lock_style() == MusicTime) {
+ if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+
+ new_bpm = prev_t->beats_per_minute() * ((frame - prev_to_prev_t->frame())
+ / (double) ((frame + prev_t_frame_contribution) - prev_to_prev_t->frame()));
+
+ } else {
+ /* prev to prev is irrelevant */
+
+ if (start_pulse != prev_t->pulse()) {
+ new_bpm = prev_t->beats_per_minute() * ((start_pulse - prev_t->pulse()) / (end_pulse - prev_t->pulse()));
+ } else {
+ new_bpm = prev_t->beats_per_minute();
+ }
+ }
+ } else {
+ /* AudioTime */
+ if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+ new_bpm = prev_t->beats_per_minute() * ((frame - prev_t->frame())
+ / (double) ((frame + prev_t_frame_contribution) - prev_t->frame()));
+ } else {
+ /* prev_to_prev_t is irrelevant */
+
+ if (end_frame != prev_t->frame()) {
+ new_bpm = prev_t->beats_per_minute() * ((frame - prev_t->frame()) / (double) (end_frame - prev_t->frame()));
+ } else {
+ new_bpm = prev_t->beats_per_minute();
+ }
+ }
+ }
+ } else {
+
+ double frame_ratio;
+ double pulse_ratio;
+ const framepos_t pulse_pos = prev_t->frame_at_pulse (pulse, _frame_rate);
+
+ if (prev_to_prev_t) {
+
+ frame_ratio = (((pulse_pos - fr_off) - prev_to_prev_t->frame()) / (double) ((pulse_pos) - prev_to_prev_t->frame()));
+ pulse_ratio = ((start_pulse - prev_to_prev_t->pulse()) / (end_pulse - prev_to_prev_t->pulse()));
+ } else {
+
+ frame_ratio = (((pulse_pos - fr_off) - prev_t->frame()) / (double) ((pulse_pos) - prev_t->frame()));
+ pulse_ratio = (start_pulse / end_pulse);
+ }
+ new_bpm = prev_t->beats_per_minute() * (pulse_ratio * frame_ratio);
+ }
+
+ prev_t->set_beats_per_minute (new_bpm);
+ recompute_tempos (future_map);
+ recompute_meters (future_map);
+
+ if (check_solved (future_map)) {
+ ts->set_beats_per_minute (new_bpm);
+ recompute_tempos (_metrics);
+ recompute_meters (_metrics);
+ }
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
+
+ MetricPositionChanged (); // Emit Signal
+}
+
framecnt_t
TempoMap::bbt_duration_at (framepos_t pos, const BBT_Time& bbt, int dir)
{
const double tick_at_time = beat_at_frame_locked (_metrics, pos) * BBT_Time::ticks_per_beat;
const double bbt_ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat);
const double total_beats = (tick_at_time + bbt_ticks) / BBT_Time::ticks_per_beat;
- const framecnt_t time_at_bbt = frame_at_beat_locked (_metrics, total_beats);
- const framecnt_t ret = time_at_bbt;
- return ret;
+ return frame_at_beat_locked (_metrics, total_beats);
}
framepos_t
return ret_frame;
}
-void
-TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num)
-{
- if (sub_num == -1) {
- const double bpb = meter_section_at (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
- if ((double) when.beats > bpb / 2.0) {
- ++when.bars;
- }
- when.beats = 1;
- when.ticks = 0;
- return;
- } else if (sub_num == 0) {
- const double bpb = meter_section_at (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
- if ((double) when.ticks > BBT_Time::ticks_per_beat / 2.0) {
- ++when.beats;
- while ((double) when.beats > bpb) {
- ++when.bars;
- when.beats -= (uint32_t) floor (bpb);
- }
- }
- when.ticks = 0;
- return;
- }
- const uint32_t ticks_one_subdivisions_worth = BBT_Time::ticks_per_beat / sub_num;
- double rem;
- if ((rem = fmod ((double) when.ticks, (double) ticks_one_subdivisions_worth)) > (ticks_one_subdivisions_worth / 2.0)) {
- /* closer to the next subdivision, so shift forward */
-
- when.ticks = when.ticks + (ticks_one_subdivisions_worth - rem);
-
- if (when.ticks > Timecode::BBT_Time::ticks_per_beat) {
- ++when.beats;
- when.ticks -= Timecode::BBT_Time::ticks_per_beat;
- }
-
- } else if (rem > 0) {
- /* closer to previous subdivision, so shift backward */
-
- if (rem > when.ticks) {
- if (when.beats == 0) {
- /* can't go backwards past zero, so ... */
- }
- /* step back to previous beat */
- --when.beats;
- when.ticks = Timecode::BBT_Time::ticks_per_beat - rem;
- } else {
- when.ticks = when.ticks - rem;
- }
- }
-}
-
framepos_t
TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
const double beat_at_framepos = beat_at_frame_locked (_metrics, frame);
- BBT_Time bbt (beats_to_bbt_locked (_metrics, beat_at_framepos));
+ BBT_Time bbt (bbt_at_beat_locked (_metrics, beat_at_framepos));
switch (type) {
case Bar:
framepos_t lower, framepos_t upper)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- const int32_t upper_beat = (int32_t) ceil (beat_at_frame_locked (_metrics, upper));
- int32_t cnt = floor (beat_at_frame_locked (_metrics, lower));
+ int32_t cnt = ceil (beat_at_frame_locked (_metrics, lower));
+ framecnt_t pos = 0;
/* although the map handles negative beats, bbt doesn't. */
if (cnt < 0.0) {
cnt = 0.0;
}
- while (cnt <= upper_beat) {
- framecnt_t pos = frame_at_beat_locked (_metrics, cnt);
- const TempoSection tempo = tempo_section_at_locked (pos);
- const MeterSection meter = meter_section_at_locked (pos);
- const BBT_Time bbt = beats_to_bbt (cnt);
- points.push_back (BBTPoint (meter, tempo_at_locked (pos), pos, bbt.bars, bbt.beats, tempo.get_c_func()));
+ while (pos < upper) {
+ pos = frame_at_beat_locked (_metrics, cnt);
+ const TempoSection tempo = tempo_section_at_locked (_metrics, pos);
+ const MeterSection meter = meter_section_at_locked (_metrics, pos);
+ const BBT_Time bbt = bbt_at_beat_locked (_metrics, cnt);
+ points.push_back (BBTPoint (meter, tempo_at_frame_locked (_metrics, pos), pos, bbt.bars, bbt.beats, tempo.c_func()));
++cnt;
}
}
TempoMap::tempo_section_at (framepos_t frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return tempo_section_at_locked (frame);
+ return tempo_section_at_locked (_metrics, frame);
}
const TempoSection&
-TempoMap::tempo_section_at_locked (framepos_t frame) const
+TempoMap::tempo_section_at_locked (const Metrics& metrics, framepos_t frame) const
{
Metrics::const_iterator i;
TempoSection* prev = 0;
- for (i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (i = metrics.begin(); i != metrics.end(); ++i) {
TempoSection* t;
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
if (!t->active()) {
continue;
}
- if (t->frame() > frame) {
+ if (prev && t->frame() > frame) {
break;
}
return *prev;
}
+const TempoSection&
+TempoMap::tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const
+{
+ TempoSection* prev_t = 0;
+ const MeterSection* prev_m = &meter_section_at_beat_locked (metrics, beat);
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (prev_t && ((t->pulse() - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > beat) {
+ break;
+ }
+ prev_t = t;
+ }
+
+ }
+ return *prev_t;
+}
+
+const TempoSection&
+TempoMap::tempo_section_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+{
+ TempoSection* prev_t = 0;
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (prev_t && t->pulse() > pulse) {
+ break;
+ }
+ prev_t = t;
+ }
+
+ }
+ return *prev_t;
+}
/* don't use this to calculate length (the tempo is only correct for this frame).
do that stuff based on the beat_at_frame and frame_at_beat api
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- const TempoSection* ts_at = &tempo_section_at_locked (frame);
+ const TempoSection* ts_at = &tempo_section_at_locked (_metrics, frame);
const TempoSection* ts_after = 0;
Metrics::const_iterator i;
return ts_at->frames_per_beat (_frame_rate);
}
-const Tempo
-TempoMap::tempo_at (const framepos_t& frame) const
+const MeterSection&
+TempoMap::meter_section_at_locked (const Metrics& metrics, framepos_t frame) const
{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return tempo_at_locked (frame);
-}
+ Metrics::const_iterator i;
+ MeterSection* prev = 0;
-const Tempo
-TempoMap::tempo_at_locked (const framepos_t& frame) const
-{
- TempoSection* prev_t = 0;
+ for (i = metrics.begin(); i != metrics.end(); ++i) {
+ MeterSection* m;
- Metrics::const_iterator i;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- for (i = _metrics.begin(); i != _metrics.end(); ++i) {
- TempoSection* t;
- if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
- if (!t->active()) {
- continue;
- }
- if ((prev_t) && t->frame() > frame) {
- /* t is the section past frame */
- const double ret = prev_t->tempo_at_frame (frame, _frame_rate) * prev_t->note_type();
- const Tempo ret_tempo (ret, prev_t->note_type());
- return ret_tempo;
+ if (prev && (*i)->frame() > frame) {
+ break;
}
- prev_t = t;
+
+ prev = m;
}
}
- const double ret = prev_t->beats_per_minute();
- const Tempo ret_tempo (ret, prev_t->note_type ());
+ if (prev == 0) {
+ fatal << endmsg;
+ abort(); /*NOTREACHED*/
+ }
- return ret_tempo;
+ return *prev;
}
+
const MeterSection&
TempoMap::meter_section_at (framepos_t frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return meter_section_at_locked (frame);
+ return meter_section_at_locked (_metrics, frame);
}
const MeterSection&
-TempoMap::meter_section_at_locked (framepos_t frame) const
+TempoMap::meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const
{
- //framepos_t const frame_off = frame + frame_offset_at (_metrics, frame);
- Metrics::const_iterator i;
- MeterSection* prev = 0;
+ MeterSection* prev_m = 0;
- for (i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m;
-
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
-
- if (prev && (*i)->frame() > frame) {
+ if (prev_m && m->beat() > beat) {
break;
}
-
- prev = m;
+ prev_m = m;
}
- }
- if (prev == 0) {
- fatal << endmsg;
- abort(); /*NOTREACHED*/
}
+ return *prev_m;
+}
- return *prev;
+const MeterSection&
+TempoMap::meter_section_at_beat (double beat) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return meter_section_at_beat_locked (_metrics, beat);
}
const Meter&
-TempoMap::meter_at (framepos_t frame) const
+TempoMap::meter_at_frame (framepos_t frame) const
{
TempoMetric m (metric_at (frame));
return m.meter();
}
-const MeterSection&
-TempoMap::meter_section_at (const double& beat) const
+void
+TempoMap::fix_legacy_session ()
{
MeterSection* prev_m = 0;
- Glib::Threads::RWLock::ReaderLock lm (lock);
+ TempoSection* prev_t = 0;
- for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
MeterSection* m;
- if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_m && m->beat() > beat) {
- break;
+ TempoSection* t;
+
+ if ((m = dynamic_cast<MeterSection*>(*i)) != 0) {
+ if (!m->movable()) {
+ pair<double, BBT_Time> bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ m->set_beat (bbt);
+ m->set_pulse (0.0);
+ m->set_frame (0);
+ m->set_position_lock_style (AudioTime);
+ prev_m = m;
+ continue;
+ }
+ if (prev_m) {
+ pair<double, BBT_Time> start = make_pair (((m->bbt().bars - 1) * prev_m->note_divisor())
+ + (m->bbt().beats - 1)
+ + (m->bbt().ticks / BBT_Time::ticks_per_beat)
+ , m->bbt());
+ m->set_beat (start);
+ const double start_beat = ((m->bbt().bars - 1) * prev_m->note_divisor())
+ + (m->bbt().beats - 1)
+ + (m->bbt().ticks / BBT_Time::ticks_per_beat);
+ m->set_pulse (start_beat / prev_m->note_divisor());
}
prev_m = m;
- }
+ } else if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
+
+ if (!t->active()) {
+ continue;
+ }
+
+ if (!t->movable()) {
+ t->set_pulse (0.0);
+ t->set_frame (0);
+ t->set_position_lock_style (AudioTime);
+ prev_t = t;
+ continue;
+ }
+ if (prev_t) {
+ const double beat = ((t->legacy_bbt().bars - 1) * ((prev_m) ? prev_m->note_divisor() : 4.0))
+ + (t->legacy_bbt().beats - 1)
+ + (t->legacy_bbt().ticks / BBT_Time::ticks_per_beat);
+ if (prev_m) {
+ t->set_pulse (beat / prev_m->note_divisor());
+ } else {
+ /* really shouldn't happen but.. */
+ t->set_pulse (beat / 4.0);
+ }
+ }
+ prev_t = t;
+ }
}
- return *prev_m;
}
XMLNode&
MetricSectionSorter cmp;
_metrics.sort (cmp);
}
+
/* check for legacy sessions where bbt was the base musical unit for tempo */
- for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
- MeterSection* m;
+ for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
TempoSection* t;
- MeterSection* prev_m = 0;
- TempoSection* prev_t = 0;
- if ((m = dynamic_cast<MeterSection*>(*i)) != 0) {
- if (prev_m && prev_m->pulse() < 0.0) {
- /*XX we cannot possibly make this work??. */
- pair<double, BBT_Time> start = make_pair (((prev_m->bbt().bars - 1) * prev_m->note_divisor()) + (prev_m->bbt().beats - 1) + (prev_m->bbt().ticks / BBT_Time::ticks_per_beat), prev_m->bbt());
- prev_m->set_beat (start);
- const double start_pulse = ((prev_m->bbt().bars - 1) * prev_m->note_divisor()) + (prev_m->bbt().beats - 1) + (prev_m->bbt().ticks / BBT_Time::ticks_per_beat);
- prev_m->set_pulse (start_pulse);
- }
- prev_m = m;
- } else if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
- if (!t->active()) {
- continue;
- }
- if (prev_t && prev_t->pulse() < 0.0) {
- double const start = ((prev_t->legacy_bbt().bars - 1) * prev_m->note_divisor()) + (prev_t->legacy_bbt().beats - 1) + (prev_t->legacy_bbt().ticks / BBT_Time::ticks_per_beat);
- prev_t->set_pulse (start);
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (t->legacy_bbt().bars != 0) {
+ fix_legacy_session();
+ break;
}
- prev_t = t;
+ break;
}
}
+
/* check for multiple tempo/meters at the same location, which
ardour2 somehow allowed.
*/
continue;
}
const double beat = beat_at_pulse_locked (_metrics, t->pulse());
- pair<double, BBT_Time> start = make_pair (beat, beats_to_bbt_locked (_metrics, beat));
+ pair<double, BBT_Time> start = make_pair (beat, bbt_at_beat_locked (_metrics, beat));
ms->set_beat (start);
ms->set_pulse (t->pulse());
}
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- BBT_Time pos_bbt = beats_to_bbt_locked (_metrics, beat_at_frame_locked (_metrics, pos));
+ BBT_Time pos_bbt = bbt_at_beat_locked (_metrics, beat_at_frame_locked (_metrics, pos));
pos_bbt.ticks += op.ticks;
if (pos_bbt.ticks >= BBT_Time::ticks_per_beat) {
++pos_bbt.beats;
}
pos_bbt.beats += op.beats;
/* the meter in effect will start on the bar */
- double divisions_per_bar = meter_section_at (bbt_to_beats_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
+ double divisions_per_bar = meter_section_at_beat (beat_at_bbt_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
while (pos_bbt.beats >= divisions_per_bar + 1) {
++pos_bbt.bars;
- divisions_per_bar = meter_section_at (bbt_to_beats_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
+ divisions_per_bar = meter_section_at_beat (beat_at_bbt_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
pos_bbt.beats -= divisions_per_bar;
}
pos_bbt.bars += op.bars;
projects / ardour.git / blobdiff