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()) - prev_m->pulse();
- pulse = true_pulse - pulse_off;
+ if (floor_beats + prev_m->beat() < meter->beat()) {
+ /* tempo change caused a change in beat (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()) - prev_m->pulse();
+ pulse = true_pulse - pulse_off;
+ } else {
+ b_bbt = make_pair (meter->beat(), meter->bbt());
+ pulse = pulse_at_frame_locked (metrics, meter->frame());
+ }
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (prev_m && m->pulse() > pulse) {
- break;
+ if ((pulse - prev_m->pulse()) * prev_m->note_divisor() < m->beat()) {
+ break;
+ }
}
prev_m = m;
}
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);
+ 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) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->frame() > frame) {
+ next_m = m;
+ break;
+ }
+ 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();
+
+ if (next_m && next_m->beat() < beat) {
+ return next_m->beat();
+ }
+
+ return beat;
}
double
framecnt_t
TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
{
- const framecnt_t frame = frame_at_pulse_locked (metrics, pulse_at_beat_locked (metrics, beat));
- return frame;
+ 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) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->beat() > beat) {
+ break;
+ }
+ prev_m = m;
+ }
+ }
+
+ return prev_t.frame_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse(), _frame_rate);
}
framecnt_t
}
bool
-TempoMap::check_solved (Metrics& metrics, bool by_frame)
+TempoMap::check_solved (const Metrics& metrics, bool by_frame) const
{
TempoSection* prev_t = 0;
TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
{
/* disallow moving first meter past any subsequent one, and any movable meter before the first one */
- const MeterSection* other = &meter_section_at_locked (frame);
+ const MeterSection* other = &meter_section_at_locked (imaginary, frame);
if ((!section->movable() && other->movable()) || (!other->movable() && section->movable() && other->frame() >= frame)) {
return;
}
}
}
- section->set_frame (frame);
-
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
/*
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.
+ and use the delta to find the meter's pulse.
*/
double new_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()) - prev_m->pulse();
- new_pulse = true_pulse - pulse_off;
+ if (floor_beats + prev_m->beat() < section->beat()) {
+ /* disallow position change if it will alter out beat
+ we allow tempo changes to do this in recompute_meters().
+ blocking this is an option, but i'm not convinced that
+ this is what the user would actually want.
+ */
+ return;
+ }
+ b_bbt = make_pair (section->beat(), section->bbt());
+ new_pulse = pulse_at_frame_locked (imaginary, frame);
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
-
+ section->set_frame (frame);
section->set_beat (b_bbt);
section->set_pulse (new_pulse);
prev_m = m;
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();
+ const double bpb = meter_section_at_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
if ((double) when.beats > bpb / 2.0) {
++when.bars;
}
when.ticks = 0;
return;
} else if (sub_num == 0) {
- const double bpb = meter_section_at (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
+ const double bpb = meter_section_at_beat (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) {
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));
+ const int32_t upper_beat = (int32_t) floor (beat_at_frame_locked (_metrics, upper));
+ 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);
+ 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 = beats_to_bbt (cnt);
- points.push_back (BBTPoint (meter, tempo_at_locked (pos), pos, bbt.bars, bbt.beats, tempo.c_func()));
+ points.push_back (BBTPoint (meter, tempo_at_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;
+}
/* 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;
}
const Tempo
-TempoMap::tempo_at (const framepos_t& frame) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return tempo_at_locked (frame);
-}
-
-const Tempo
-TempoMap::tempo_at_locked (const framepos_t& frame) const
+TempoMap::tempo_at_locked (const Metrics& metrics, const framepos_t& frame) const
{
TempoSection* prev_t = 0;
return ret_tempo;
}
-const MeterSection&
-TempoMap::meter_section_at (framepos_t frame) const
+const Tempo
+TempoMap::tempo_at (const framepos_t& frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return meter_section_at_locked (frame);
+ return tempo_at_locked (_metrics, frame);
}
const MeterSection&
-TempoMap::meter_section_at_locked (framepos_t frame) const
+TempoMap::meter_section_at_locked (const Metrics& metrics, framepos_t frame) const
{
Metrics::const_iterator i;
MeterSection* prev = 0;
- for (i = _metrics.begin(); i != _metrics.end(); ++i) {
+ for (i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
return *prev;
}
-const Meter&
-TempoMap::meter_at (framepos_t frame) const
+
+const MeterSection&
+TempoMap::meter_section_at (framepos_t frame) const
{
- TempoMetric m (metric_at (frame));
- return m.meter();
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return meter_section_at_locked (_metrics, frame);
}
const MeterSection&
-TempoMap::meter_section_at (const double& beat) const
+TempoMap::meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const
{
MeterSection* prev_m = 0;
- Glib::Threads::RWLock::ReaderLock lm (lock);
- for (Metrics::const_iterator 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_m && m->beat() > beat) {
return *prev_m;
}
+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
+{
+ TempoMetric m (metric_at (frame));
+ return m.meter();
+}
+
void
TempoMap::fix_legacy_session ()
{
}
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 (bbt_to_beats_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 (bbt_to_beats_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;