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())));
}
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) {
- double const beats = ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
- return beats;
+ if (_type == Constant || _c_func == 0.0) {
+ double const pulses = ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
+ return pulses;
}
-
return pulse_at_pulse_tempo (ppm) + pulse();
}
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();
}
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&
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());
+ MeterSection *m = new MeterSection ((framepos_t) 0, 0.0, start, _default_meter.divisions_per_bar(), _default_meter.note_divisor());
t->set_movable (false);
m->set_movable (false);
*(dynamic_cast<Tempo*>(*i)) = *(dynamic_cast<Tempo*>(insert_tempo));
(*i)->set_position_lock_style (AudioTime);
+ TempoSection* t;
+ if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
+ t->set_type (insert_tempo->type());
+ }
need_add = false;
} else {
_metrics.erase (i);
bool const ipm = insert_meter->position_lock_style() == MusicTime;
- if ((ipm && meter->pulse() == insert_meter->pulse()) || (!ipm && meter->frame() == insert_meter->frame())) {
+ if ((ipm && meter->beat() == insert_meter->beat()) || (!ipm && meter->frame() == insert_meter->frame())) {
if (!meter->movable()) {
*/
*(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 {
_metrics.erase (i);
-
}
break;
if (meter) {
bool const ipm = insert_meter->position_lock_style() == MusicTime;
- if ((ipm && meter->pulse() > insert_meter->pulse()) || (!ipm && meter->frame() > insert_meter->frame())) {
+ if ((ipm && meter->beat() > insert_meter->beat()) || (!ipm && meter->frame() > insert_meter->frame())) {
break;
}
}
PropertyChanged (PropertyChange ());
}
-void
+TempoSection*
TempoMap::add_tempo (const Tempo& tempo, const double& pulse, ARDOUR::TempoSection::Type type)
{
+ TempoSection* ts = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- add_tempo_locked (tempo, pulse, true, type);
+ ts = add_tempo_locked (tempo, pulse, true, type);
}
PropertyChanged (PropertyChange ());
+
+ return ts;
}
-void
+TempoSection*
TempoMap::add_tempo (const Tempo& tempo, const framepos_t& frame, ARDOUR::TempoSection::Type type)
{
+ TempoSection* ts = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- add_tempo_locked (tempo, frame, true, type);
+ ts = add_tempo_locked (tempo, frame, true, type);
}
PropertyChanged (PropertyChange ());
+
+ return ts;
}
-void
+TempoSection*
TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, bool recompute, ARDOUR::TempoSection::Type type)
{
- TempoSection* ts = new TempoSection (pulse, tempo.beats_per_minute(), tempo.note_type(), type);
+ TempoSection* t = new TempoSection (pulse, tempo.beats_per_minute(), tempo.note_type(), type);
- do_insert (ts);
+ do_insert (t);
if (recompute) {
- solve_map (_metrics, ts, Tempo (ts->beats_per_minute(), ts->note_type()), ts->pulse());
+ solve_map (_metrics, t, t->pulse());
}
+
+ return t;
}
-void
+TempoSection*
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);
+ TempoSection* t = new TempoSection (frame, tempo.beats_per_minute(), tempo.note_type(), type);
- do_insert (ts);
+ do_insert (t);
if (recompute) {
- solve_map (_metrics, ts, Tempo (ts->beats_per_minute(), ts->note_type()), ts->frame());
+ solve_map (_metrics, t, t->frame());
}
+
+ return t;
}
void
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
- MeterSection& first (first_meter());
if (ms.movable()) {
remove_meter_locked (ms);
add_meter_locked (meter, bbt_to_beats_locked (_metrics, where), where, true);
} else {
- const PositionLockStyle pl = ms.position_lock_style();
+ MeterSection& first (first_meter());
/* cannot move the first meter section */
*static_cast<Meter*>(&first) = meter;
- first.set_position_lock_style (pl);
- recompute_map (_metrics);
+ first.set_position_lock_style (AudioTime);
}
+ recompute_map (_metrics);
}
PropertyChanged (PropertyChange ());
const double beat = ms.beat();
const BBT_Time bbt = ms.bbt();
+
if (ms.movable()) {
remove_meter_locked (ms);
add_meter_locked (meter, frame, beat, bbt, true);
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 ());
}
-void
+MeterSection*
TempoMap::add_meter (const Meter& meter, const double& beat, const BBT_Time& where)
{
+ MeterSection* m = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- add_meter_locked (meter, beat, where, true);
+ m = add_meter_locked (meter, beat, where, true);
}
#endif
PropertyChanged (PropertyChange ());
+
+ return m;
}
-void
+MeterSection*
TempoMap::add_meter (const Meter& meter, const framepos_t& frame, const double& beat, const Timecode::BBT_Time& where)
{
+ MeterSection* m = 0;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- add_meter_locked (meter, frame, beat, where, true);
+ m = add_meter_locked (meter, frame, beat, where, true);
}
#endif
PropertyChanged (PropertyChange ());
+
+ return m;
}
-void
+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
}
/* new meters *always* start on a beat. */
where.ticks = 0;
- double pulse = pulse_at_beat_locked (_metrics, beat);
-
+ 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, Meter (meter.divisions_per_bar(), meter.note_divisor()), pulse);
+ solve_map (_metrics, new_meter, pulse);
}
+ return new_meter;
}
-void
+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);
do_insert (new_meter);
if (recompute) {
- solve_map (_metrics, new_meter, Meter (new_meter->divisions_per_bar(), new_meter->note_divisor()), frame);
+ solve_map (_metrics, new_meter, frame);
}
+ return new_meter;
}
void
void
TempoMap::recompute_tempos (Metrics& metrics)
{
- TempoSection* prev_ts = 0;
+ TempoSection* prev_t = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
TempoSection* t;
if (!t->active()) {
continue;
}
- if (prev_ts) {
+ if (!t->movable()) {
+ t->set_pulse (0.0);
+ prev_t = t;
+ continue;
+ }
+ if (prev_t) {
if (t->position_lock_style() == AudioTime) {
- prev_ts->set_c_func (prev_ts->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_ts->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
+ 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));
} else {
- prev_ts->set_c_func (prev_ts->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
- t->set_frame (prev_ts->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
+ t->set_frame (prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate));
}
}
- prev_ts = t;
+ prev_t = t;
}
}
- prev_ts->set_c_func (0.0);
+ prev_t->set_c_func (0.0);
}
/* tempos must be positioned correctly */
{
MeterSection* meter = 0;
MeterSection* prev_m = 0;
- uint32_t accumulated_bars = 0;
for (Metrics::const_iterator mi = metrics.begin(); mi != metrics.end(); ++mi) {
if ((meter = dynamic_cast<MeterSection*> (*mi)) != 0) {
- if (prev_m) {
- const double beats_in_m = (meter->pulse() - prev_m->pulse()) * prev_m->note_divisor();
- accumulated_bars += (beats_in_m + 1) / prev_m->divisions_per_bar();
- }
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()) - prev_m->beat();
- b_bbt = make_pair (ceil (beats), BBT_Time (accumulated_bars + 1, 1, 0));
- const double true_pulse = prev_m->pulse() + (ceil (beats) - prev_m->beat()) / prev_m->note_divisor();
- const double pulse_off = true_pulse - ((beats - prev_m->beat()) / prev_m->note_divisor());
+ 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;
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
meter->set_pulse (pulse);
} else {
double pulse = 0.0;
+ pair<double, BBT_Time> new_beat;
if (prev_m) {
- pulse = prev_m->pulse() + (meter->beat() - prev_m->beat()) / prev_m->note_divisor();
+ pulse = prev_m->pulse() + ((meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar() / prev_m->note_divisor());
+ new_beat = make_pair (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), meter->bbt());
} else {
+ /* shouldn't happen - the first is audio-locked */
pulse = pulse_at_beat_locked (metrics, meter->beat());
+ new_beat = make_pair (pulse, meter->bbt());
}
+
+ meter->set_beat (new_beat);
meter->set_frame (frame_at_pulse_locked (metrics, pulse));
meter->set_pulse (pulse);
}
prev_m = meter;
}
}
+ //dump (_metrics, std::cerr;
}
void
recompute_meters (metrics);
}
-double
-TempoMap::pulse_at_beat (const double& beat) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return pulse_at_beat_locked (_metrics, beat);
-}
-
-double
-TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
-{
- MeterSection* prev_ms = 0;
- double accumulated_beats = 0.0;
-
- for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
- MeterSection* m;
- if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_ms && m->beat() > beat) {
- break;
- }
- accumulated_beats = m->beat();
- prev_ms = m;
- }
-
- }
- double const ret = prev_ms->pulse() + ((beat - accumulated_beats) / prev_ms->note_divisor());
- return ret;
-}
-
-double
-TempoMap::beat_at_pulse (const double& pulse) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return beat_at_pulse_locked (_metrics, pulse);
-}
-
-double
-TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const
-{
- MeterSection* prev_ms = 0;
- double accumulated_beats = 0.0;
-
- for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
- MeterSection* m;
- if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_ms && m->pulse() > pulse) {
- break;
- }
- accumulated_beats = m->beat();
- prev_ms = m;
- }
- }
-
- double const beats_in_section = (pulse - prev_ms->pulse()) * prev_ms->note_divisor();
-
- return beats_in_section + accumulated_beats;
-}
-
TempoMetric
TempoMap::metric_at (framepos_t frame, Metrics::const_iterator* last) const
{
return m;
}
-void
-TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt)
+double
+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->beat() > beat) {
+ break;
+ }
+ prev_m = m;
+ }
- if (frame < 0) {
- bbt.bars = 1;
- bbt.beats = 1;
- bbt.ticks = 0;
- warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg;
- return;
}
+ double const ret = prev_m->pulse() + ((beat - prev_m->beat()) / prev_m->note_divisor());
+ return ret;
+}
+
+double
+TempoMap::pulse_at_beat (const double& beat) const
+{
Glib::Threads::RWLock::ReaderLock lm (lock);
- double const beat = beat_at_frame_locked (_metrics, frame);
+ return pulse_at_beat_locked (_metrics, beat);
+}
- bbt = beats_to_bbt_locked (_metrics, beat);
+double
+TempoMap::beat_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) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_m && m->pulse() > pulse) {
+ 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
-TempoMap::bbt_to_beats (const Timecode::BBT_Time& bbt)
+TempoMap::beat_at_pulse (const double& pulse) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
+ return beat_at_pulse_locked (_metrics, pulse);
+}
- return bbt_to_beats_locked (_metrics, bbt);
+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_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()) {
+ continue;
+ }
+ if (prev_t && t->pulse() > pulse) {
+ return prev_t->frame_at_pulse (pulse, _frame_rate);
+ }
+
+ prev_t = t;
+ }
+ }
+ /* must be treated as constant, irrespective of _type */
+ double const pulses_in_section = pulse - prev_t->pulse();
+ double const dtime = pulses_in_section * prev_t->frames_per_pulse (_frame_rate);
+
+ framecnt_t const ret = (framecnt_t) floor (dtime) + prev_t->frame();
+
+ 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
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return beat_at_frame_locked (_metrics, frame);
+}
+
+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;
+}
+
+framecnt_t
+TempoMap::frame_at_beat (const double& beat) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return frame_at_beat_locked (_metrics, beat);
}
double
{
/* CALLER HOLDS READ LOCK */
- double accumulated_beats = 0.0;
- double accumulated_bars = 0.0;
- MeterSection* prev_ms = 0;
+ 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) {
- double bars_to_m = 0.0;
- if (prev_ms) {
- bars_to_m = (m->beat() - prev_ms->beat()) / prev_ms->divisions_per_bar();
- if ((bars_to_m + accumulated_bars) > (bbt.bars - 1)) {
+ if (prev_m) {
+ const double bars_to_m = (m->beat() - prev_m->beat()) / prev_m->divisions_per_bar();
+ if ((bars_to_m + (prev_m->bbt().bars - 1)) > (bbt.bars - 1)) {
break;
}
- accumulated_beats = m->beat();
- accumulated_bars += bars_to_m;
}
- prev_ms = m;
+ prev_m = m;
}
}
- double const remaining_bars = (bbt.bars - 1) - accumulated_bars;
- double const remaining_bars_in_beats = remaining_bars * prev_ms->divisions_per_bar();
- double const ret = remaining_bars_in_beats + accumulated_beats + (bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat);
+ 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;
}
-Timecode::BBT_Time
-TempoMap::beats_to_bbt (const double& beats)
+double
+TempoMap::bbt_to_beats (const Timecode::BBT_Time& bbt)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
-
- return beats_to_bbt_locked (_metrics, beats);
+ return bbt_to_beats_locked (_metrics, bbt);
}
Timecode::BBT_Time
TempoMap::beats_to_bbt_locked (const Metrics& metrics, const double& b) const
{
/* CALLER HOLDS READ LOCK */
- MeterSection* prev_ms = 0;
+ MeterSection* prev_m = 0;
const double beats = (b < 0.0) ? 0.0 : b;
- uint32_t accumulated_bars = 0;
- double accumulated_beats = 0.0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
MeterSection* m = 0;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
-
- if (prev_ms) {
- double const beats_to_m = m->beat() - prev_ms->beat();
- if (accumulated_beats + beats_to_m > beats) {
+ if (prev_m) {
+ if (m->beat() > beats) {
/* this is the meter after the one our beat is on*/
break;
}
-
- /* we need a whole number of bars. */
- accumulated_bars += (beats_to_m + 1) / prev_ms->divisions_per_bar();
- accumulated_beats += beats_to_m;
}
- prev_ms = m;
+ prev_m = m;
}
}
- double const beats_in_ms = beats - accumulated_beats;
- uint32_t const bars_in_ms = (uint32_t) floor (beats_in_ms / prev_ms->divisions_per_bar());
- uint32_t const total_bars = bars_in_ms + accumulated_bars;
- double const remaining_beats = beats_in_ms - (bars_in_ms * prev_ms->divisions_per_bar());
- double const remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
+ const double beats_in_ms = beats - prev_m->beat();
+ const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar());
+ const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1);
+ const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar());
+ const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
BBT_Time ret;
ret.ticks -= BBT_Time::ticks_per_beat;
}
- if (ret.beats >= prev_ms->divisions_per_bar() + 1) {
+ if (ret.beats >= prev_m->divisions_per_bar() + 1) {
++ret.bars;
ret.beats = 1;
}
return ret;
}
+Timecode::BBT_Time
+TempoMap::beats_to_bbt (const double& beats)
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return beats_to_bbt_locked (_metrics, beats);
+}
+
Timecode::BBT_Time
TempoMap::pulse_to_bbt (const double& pulse)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- MeterSection* prev_ms = 0;
- uint32_t accumulated_bars = 0;
- double accumulated_pulses = 0.0;
+ MeterSection* prev_m = 0;
for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
MeterSection* m = 0;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_ms) {
- double const pulses_to_m = m->pulse() - prev_ms->pulse();
- if (accumulated_pulses + pulses_to_m > pulse) {
+ if (prev_m) {
+ double const pulses_to_m = m->pulse() - prev_m->pulse();
+ if (prev_m->pulse() + pulses_to_m > pulse) {
/* this is the meter after the one our beat is on*/
break;
}
-
- /* we need a whole number of bars. */
- accumulated_pulses += pulses_to_m;
- accumulated_bars += ((pulses_to_m * prev_ms->note_divisor()) + 1) / prev_ms->divisions_per_bar();
}
- prev_ms = m;
+ prev_m = m;
}
}
- double const beats_in_ms = (pulse - prev_ms->pulse()) * prev_ms->note_divisor();
- uint32_t const bars_in_ms = (uint32_t) floor (beats_in_ms / prev_ms->divisions_per_bar());
- uint32_t const total_bars = bars_in_ms + accumulated_bars;
- double const remaining_beats = beats_in_ms - (bars_in_ms * prev_ms->divisions_per_bar());
- double const remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
+
+ const double beats_in_ms = (pulse - prev_m->pulse()) * prev_m->note_divisor();
+ const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar());
+ const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1);
+ const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar());
+ const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
BBT_Time ret;
ret.ticks -= BBT_Time::ticks_per_beat;
}
- if (ret.beats >= prev_ms->divisions_per_bar() + 1) {
+ if (ret.beats >= prev_m->divisions_per_bar() + 1) {
++ret.bars;
ret.beats = 1;
}
return ret;
}
-double
-TempoMap::beat_at_frame (const framecnt_t& frame) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return beat_at_frame_locked (_metrics, frame);
-}
-
-double
-TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
-{
- //framecnt_t const offset_frame = frame + frame_offset_at (metrics, frame);
- double const pulse = pulse_at_frame_locked (metrics, frame);
-
- return beat_at_pulse_locked (metrics, pulse);
-}
-
-double
-TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
+void
+TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt)
{
- /* HOLD (at least) THE READER LOCK */
- TempoSection* prev_ts = 0;
- double accumulated_pulses = 0.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_ts && t->frame() > frame) {
- /*the previous ts is the one containing the frame */
- double const ret = prev_ts->pulse_at_frame (frame, _frame_rate);
- return ret;
- }
- accumulated_pulses = t->pulse();
- prev_ts = t;
- }
+ if (frame < 0) {
+ bbt.bars = 1;
+ bbt.beats = 1;
+ bbt.ticks = 0;
+ warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg;
+ return;
}
-
- /* treated as constant for this ts */
- double const pulses_in_section = (frame - prev_ts->frame()) / prev_ts->frames_per_pulse (_frame_rate);
-
- return pulses_in_section + accumulated_pulses;
-}
-
-framecnt_t
-TempoMap::frame_at_beat (const double& beat) const
-{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return frame_at_beat_locked (_metrics, beat);
-}
+ const double beat = beat_at_frame_locked (_metrics, frame);
-framecnt_t
-TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
-{
- framecnt_t const frame = frame_at_pulse_locked (metrics, pulse_at_beat_locked (metrics, beat));
- //frameoffset_t const frame_off = frame_offset_at (metrics, frame);
- return frame;
+ bbt = beats_to_bbt_locked (_metrics, beat);
}
-framecnt_t
-TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const
+framepos_t
+TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
{
/* HOLD THE READER LOCK */
- const TempoSection* prev_ts = 0;
- double accumulated_pulses = 0.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_ts && t->pulse() > pulse) {
- return prev_ts->frame_at_pulse (pulse, _frame_rate);
- }
-
- accumulated_pulses = t->pulse();
- prev_ts = t;
- }
- }
- /* must be treated as constant, irrespective of _type */
- double const pulses_in_section = pulse - accumulated_pulses;
- double const dtime = pulses_in_section * prev_ts->frames_per_pulse (_frame_rate);
-
- framecnt_t const ret = (framecnt_t) floor (dtime) + prev_ts->frame();
-
+ const framepos_t ret = frame_at_beat_locked (metrics, bbt_to_beats_locked (metrics, bbt));
return ret;
}
throw std::logic_error ("beats are counted from one");
}
Glib::Threads::RWLock::ReaderLock lm (lock);
- double const beat = bbt_to_beats_locked (_metrics, bbt);
- framecnt_t const frame = frame_at_beat_locked (_metrics, beat);
- return frame;
-}
-
-framepos_t
-TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
-{
- /* HOLD THE READER LOCK */
-
- framepos_t const ret = frame_at_pulse_locked (metrics, pulse_at_beat_locked (metrics, bbt_to_beats_locked (metrics, bbt)));
- return ret;
+ return frame_time_locked (_metrics, bbt);
}
bool
TempoMap::check_solved (Metrics& metrics, bool by_frame)
{
- TempoSection* prev_ts = 0;
+ TempoSection* prev_t = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
TempoSection* t;
if (!t->active()) {
continue;
}
- if (prev_ts) {
- if ((by_frame && t->frame() < prev_ts->frame()) || (!by_frame && t->pulse() < prev_ts->pulse())) {
+ if (prev_t) {
+ if ((by_frame && t->frame() < prev_t->frame()) || (!by_frame && t->pulse() < prev_t->pulse())) {
return false;
}
- if (t->frame() == prev_ts->frame()) {
+ if (t->frame() == prev_t->frame()) {
return false;
}
- /* precision check ensures pulses and frames align independent of lock style.*/
- if (by_frame && t->frame() != prev_ts->frame_at_pulse (t->pulse(), _frame_rate)) {
+ /* precision check ensures pulses and frames align.*/
+ if (t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) {
return false;
}
}
- prev_ts = t;
+ prev_t = t;
}
}
}
bool
-TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const Tempo& bpm, const framepos_t& frame)
+TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t& frame)
{
- TempoSection* prev_ts = 0;
+ TempoSection* prev_t = 0;
TempoSection* section_prev = 0;
framepos_t first_m_frame = 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) {
if (!t->active()) {
continue;
}
- if (prev_ts) {
+ if (prev_t) {
if (t == section) {
- section_prev = prev_ts;
+ section_prev = prev_t;
continue;
}
if (t->position_lock_style() == MusicTime) {
- prev_ts->set_c_func (prev_ts->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
- t->set_frame (prev_ts->frame_at_pulse (t->pulse(), _frame_rate));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
+ t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
} else {
- prev_ts->set_c_func (prev_ts->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_ts->pulse_at_frame (t->frame(), _frame_rate));
+ 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));
}
}
- prev_ts = t;
+ prev_t = t;
}
}
} else {
recompute_tempos (imaginary);
}
+
if (check_solved (imaginary, true)) {
recompute_meters (imaginary);
return true;
}
-
+#if (0)
MetricSectionSorter cmp;
imaginary.sort (cmp);
if (section->position_lock_style() == MusicTime) {
} else {
recompute_tempos (imaginary);
}
+
if (check_solved (imaginary, true)) {
recompute_meters (imaginary);
return true;
}
+#endif
//dump (imaginary, std::cerr);
return false;
}
bool
-TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const Tempo& bpm, const double& pulse)
+TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pulse)
{
- TempoSection* prev_ts = 0;
+ TempoSection* prev_t = 0;
TempoSection* section_prev = 0;
section->set_pulse (pulse);
if (!t->active()) {
continue;
}
- if (prev_ts) {
+ if (!t->movable()) {
+ t->set_pulse (0.0);
+ prev_t = t;
+ continue;
+ }
+ if (prev_t) {
if (t == section) {
- section_prev = prev_ts;
+ section_prev = prev_t;
continue;
}
if (t->position_lock_style() == MusicTime) {
- prev_ts->set_c_func (prev_ts->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
- t->set_frame (prev_ts->frame_at_pulse (t->pulse(), _frame_rate));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
+ t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
} else {
- prev_ts->set_c_func (prev_ts->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
- t->set_pulse (prev_ts->pulse_at_frame (t->frame(), _frame_rate));
+ 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));
}
}
- prev_ts = t;
+ prev_t = t;
}
}
if (section_prev) {
} else {
recompute_tempos (imaginary);
}
+
if (check_solved (imaginary, false)) {
recompute_meters (imaginary);
return true;
recompute_meters (imaginary);
return true;
}
-
+#if (0)
MetricSectionFrameSorter fcmp;
imaginary.sort (fcmp);
if (section->position_lock_style() == AudioTime) {
recompute_meters (imaginary);
return true;
}
-
+#endif
//dump (imaginary, std::cerr);
return false;
}
void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const framepos_t& frame)
+TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
{
- MeterSection* prev_ms = 0;
+ MeterSection* prev_m = 0;
if (!section->movable()) {
/* lock the first tempo to our first meter */
new_section->set_pulse (0.0);
new_section->set_active (true);
- if (solve_map (future_map, new_section, Tempo (new_section->beats_per_minute(), new_section->note_type()), frame)) {
+ 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, Tempo (first_t->beats_per_minute(), first_t->note_type()), frame);
+ solve_map (imaginary, first_t, frame);
} else {
return;
}
}
- uint32_t accumulated_bars = 0;
-
section->set_frame (frame);
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_ms) {
- const double beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
- accumulated_bars += (beats_in_m + 1) / prev_ms->divisions_per_bar();
- }
if (m == section){
/*
here we set the beat for this frame.
- we're going to set it 'incorrectly' to the next integer and use this difference
- to find the meter's pulse.
- (meters should fall on integral beats to keep us sane)
- XXX do it to the bar, you fool, not the beat! - and don't forget to recompute_meters that way too.
+ 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;
+ double new_pulse = 0.0;
pair<double, BBT_Time> b_bbt;
- if (m->movable()) {
- double beats = ((pulse_at_frame_locked (imaginary, frame) - prev_ms->pulse()) * prev_ms->note_divisor()) - prev_ms->beat();
- b_bbt = make_pair (ceil (beats), BBT_Time (accumulated_bars + 1, 1, 0));
- const double true_pulse = prev_ms->pulse() + ((ceil (beats) - prev_ms->beat()) / prev_ms->note_divisor());
- const double pulse_off = true_pulse - ((beats - prev_ms->beat()) / prev_ms->note_divisor());
- pulse = true_pulse - pulse_off;
+
+ 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;
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
- m->set_beat (b_bbt);
- m->set_pulse (pulse);
- prev_ms = m;
+
+ section->set_beat (b_bbt);
+ section->set_pulse (new_pulse);
+ prev_m = m;
+
continue;
}
- if (prev_ms) {
+ if (prev_m) {
+ double new_pulse = 0.0;
if (m->position_lock_style() == MusicTime) {
- const double pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
- m->set_frame (frame_at_pulse_locked (imaginary, pulse));
- m->set_pulse (pulse);
+ new_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, new_pulse));
+ if (m->frame() > section->frame()) {
+ /* moving 'section' will affect later meters' beat (but not bbt).*/
+ pair<double, BBT_Time> new_beat (((new_pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt());
+ m->set_beat (new_beat);
+ }
} else {
- double pulse = 0.0;
pair<double, BBT_Time> b_bbt;
if (m->movable()) {
- const double beats = ((pulse_at_frame_locked (imaginary, m->frame()) - prev_ms->pulse()) * prev_ms->note_divisor()) - prev_ms->beat();
- const double true_pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
- const double pulse_off = true_pulse - ((beats - prev_ms->beat()) / prev_ms->note_divisor());
- b_bbt = make_pair (ceil (beats), BBT_Time (accumulated_bars + 1, 1, 0));
- pulse = true_pulse - pulse_off;
+ 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()) - prev_m->pulse();
+ new_pulse = true_pulse - pulse_off;
} else {
b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- pulse = 0.0;
+ new_pulse = 0.0;
}
m->set_beat (b_bbt);
- m->set_pulse (pulse);
}
+ m->set_pulse (new_pulse);
}
- prev_ms = m;
+ prev_m = m;
}
}
+ MetricSectionFrameSorter fcmp;
+ imaginary.sort (fcmp);
if (section->position_lock_style() == MusicTime) {
/* we're setting the frame */
section->set_position_lock_style (AudioTime);
}
void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const double& pulse)
+TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pulse)
{
- MeterSection* prev_ms = 0;
- double accumulated_beats = 0.0;
- uint32_t accumulated_bars = 0;
+ 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 (prev_ms) {
- double const beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
- accumulated_beats += beats_in_m;
- accumulated_bars += (beats_in_m + 1) / prev_ms->divisions_per_bar();
- }
if (m == section){
- section->set_frame (frame_at_pulse_locked (imaginary, pulse));
- pair<double, BBT_Time> b_bbt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- section->set_beat (b_bbt);
- prev_ms = section;
+ section_prev = prev_m;
continue;
}
- if (prev_ms) {
+ if (prev_m) {
+ double new_pulse = 0.0;
if (m->position_lock_style() == MusicTime) {
- const double pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
- m->set_frame (frame_at_pulse_locked (imaginary, pulse));
- m->set_pulse (pulse);
+ new_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, new_pulse));
+
+ if (new_pulse > section->pulse()) {
+ /* moving 'section' will affect later meters' beat (but not bbt).*/
+ pair<double, BBT_Time> new_beat (((new_pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt());
+ m->set_beat (new_beat);
+ }
} else {
- if (!m->movable()) {
- pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- m->set_beat (b_bbt);
+ 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()) - prev_m->pulse();
+ new_pulse = true_pulse - pulse_off;
+ } else {
+ b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
- const double pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
- m->set_pulse (pulse);
+ m->set_beat (b_bbt);
}
+ m->set_pulse (new_pulse);
}
- prev_ms = m;
+ 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));
+ section->set_beat (b_bbt);
+ 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);
}
/** 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)
{
TempoSection* t;
- TempoSection* ret = 0;
MeterSection* m;
+ TempoSection* ret = 0;
for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
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());
+ ret->set_frame (t->frame());
} else {
ret = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
+ ret->set_pulse (t->pulse());
}
ret->set_active (t->active());
ret->set_movable (t->movable());
TempoSection* cp = 0;
if (t->position_lock_style() == MusicTime) {
cp = new TempoSection (t->pulse(), t->beats_per_minute(), t->note_type(), t->type());
+ cp->set_frame (t->frame());
} else {
cp = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
+ cp->set_pulse (t->pulse());
}
cp->set_active (t->active());
cp->set_movable (t->movable());
copy.push_back (cp);
}
}
- //recompute_map (copy);
+
return ret;
}
bool
-TempoMap::can_solve_bbt (TempoSection* ts, const Tempo& bpm, const BBT_Time& bbt)
+TempoMap::can_solve_bbt (TempoSection* ts, const BBT_Time& bbt)
{
Metrics copy;
TempoSection* new_section = 0;
}
double const beat = bbt_to_beats_locked (copy, bbt);
- bool ret = solve_map (copy, new_section, bpm, pulse_at_beat_locked (copy, beat));
+ bool ret = solve_map (copy, new_section, pulse_at_beat_locked (copy, beat));
Metrics::const_iterator d = copy.begin();
while (d != copy.end()) {
* @return returns - the position in frames where the new tempo section will lie.
*/
framepos_t
-TempoMap::predict_tempo_frame (TempoSection* section, const Tempo& bpm, const BBT_Time& bbt)
+TempoMap::predict_tempo_frame (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);
- double const beat = bbt_to_beats_locked (future_map, bbt);
- if (solve_map (future_map, new_section, bpm, pulse_at_beat_locked (future_map, beat))) {
+ 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);
}
double
-TempoMap::predict_tempo_pulse (TempoSection* section, const Tempo& bpm, const framepos_t& frame)
+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, bpm, frame)) {
+ if (solve_map (future_map, new_section, frame)) {
ret = new_section->pulse();
} else {
ret = pulse_at_frame_locked (_metrics, frame);
}
void
-TempoMap::gui_move_tempo_frame (TempoSection* ts, const Tempo& bpm, const framepos_t& frame)
+TempoMap::gui_move_tempo_frame (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, bpm, frame)) {
- solve_map (_metrics, ts, bpm, frame);
+ if (solve_map (future_map, new_section, frame)) {
+ solve_map (_metrics, ts, frame);
}
}
}
void
-TempoMap::gui_move_tempo_beat (TempoSection* ts, const Tempo& bpm, const double& beat)
+TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat)
{
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, bpm, pulse_at_beat_locked (future_map, beat))) {
- solve_map (_metrics, ts, bpm, pulse_at_beat_locked (_metrics, beat));
+ if (solve_map (future_map, new_section, pulse_at_beat_locked (future_map, beat))) {
+ solve_map (_metrics, ts, pulse_at_beat_locked (_metrics, beat));
}
}
}
void
-TempoMap::gui_move_meter (MeterSection* ms, const Meter& mt, const framepos_t& frame)
+TempoMap::gui_move_meter (MeterSection* ms, const framepos_t& frame)
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, mt, frame);
+ solve_map (_metrics, ms, frame);
}
MetricPositionChanged (); // Emit Signal
}
void
-TempoMap::gui_move_meter (MeterSection* ms, const Meter& mt, const double& beat)
+TempoMap::gui_move_meter (MeterSection* ms, const double& beat)
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, mt, pulse_at_beat_locked (_metrics, beat));
+ solve_map (_metrics, ms, pulse_at_beat_locked (_metrics, beat));
}
MetricPositionChanged (); // Emit Signal
}
bool
-TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm)
+TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm)
{
Metrics future_map;
bool can_solve = false;
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- double const tick_at_time = beat_at_frame_locked (_metrics, pos) * BBT_Time::ticks_per_beat;
- double const bbt_ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat);
- double const total_beats = (tick_at_time + bbt_ticks) / BBT_Time::ticks_per_beat;
- framecnt_t const time_at_bbt = frame_at_beat_locked (_metrics, total_beats);
- framecnt_t const ret = time_at_bbt;
+ 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;
- return ret;
+ return frame_at_beat_locked (_metrics, total_beats);
}
framepos_t
}
}
- framepos_t const ret_frame = frame_at_beat_locked (_metrics, beats + (ticks / BBT_Time::ticks_per_beat));
+ const framepos_t ret_frame = frame_at_beat_locked (_metrics, beats + (ticks / BBT_Time::ticks_per_beat));
return ret_frame;
}
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- double const beat_at_framepos = beat_at_frame_locked (_metrics, frame);
+ const double beat_at_framepos = beat_at_frame_locked (_metrics, frame);
BBT_Time bbt (beats_to_bbt_locked (_metrics, beat_at_framepos));
switch (type) {
/* find bar previous to 'frame' */
bbt.beats = 1;
bbt.ticks = 0;
- return frame_time (bbt);
+ return frame_time_locked (_metrics, bbt);
} else if (dir > 0) {
/* find bar following 'frame' */
++bbt.bars;
bbt.beats = 1;
bbt.ticks = 0;
- return frame_time (bbt);
+ return frame_time_locked (_metrics, bbt);
} else {
/* true rounding: find nearest bar */
- framepos_t raw_ft = frame_time (bbt);
+ framepos_t raw_ft = frame_time_locked (_metrics, bbt);
bbt.beats = 1;
bbt.ticks = 0;
- framepos_t prev_ft = frame_time (bbt);
+ framepos_t prev_ft = frame_time_locked (_metrics, bbt);
++bbt.bars;
- framepos_t next_ft = frame_time (bbt);
+ framepos_t next_ft = frame_time_locked (_metrics, bbt);
if ((raw_ft - prev_ft) > (next_ft - prev_ft) / 2) {
return next_ft;
framepos_t lower, framepos_t upper)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- int32_t const upper_beat = (int32_t) ceil (beat_at_frame_locked (_metrics, upper));
+ const int32_t upper_beat = (int32_t) ceil (beat_at_frame_locked (_metrics, upper));
int32_t cnt = floor (beat_at_frame_locked (_metrics, lower));
/* although the map handles negative beats, bbt doesn't. */
if (cnt < 0.0) {
}
while (cnt <= upper_beat) {
framecnt_t pos = frame_at_beat_locked (_metrics, cnt);
- TempoSection const tempo = tempo_section_at_locked (pos);
- MeterSection const meter = meter_section_at_locked (pos);
- BBT_Time const bbt = beats_to_bbt (cnt);
- BBTPoint point = BBTPoint (meter, tempo_at_locked (pos), pos, bbt.bars, bbt.beats, tempo.get_c_func());
- points.push_back (point);
+ 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.c_func()));
++cnt;
}
}
const Tempo
TempoMap::tempo_at_locked (const framepos_t& frame) const
{
- TempoSection* prev_ts = 0;
+ TempoSection* prev_t = 0;
Metrics::const_iterator i;
if (!t->active()) {
continue;
}
- if ((prev_ts) && t->frame() > frame) {
+ if ((prev_t) && t->frame() > frame) {
/* t is the section past frame */
- double const ret = prev_ts->tempo_at_frame (frame, _frame_rate) * prev_ts->note_type();
- Tempo const ret_tempo (ret, prev_ts->note_type());
+ 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_ts = t;
+ prev_t = t;
}
}
- double const ret = prev_ts->beats_per_minute();
- Tempo const ret_tempo (ret, prev_ts->note_type ());
+ const double ret = prev_t->beats_per_minute();
+ const Tempo ret_tempo (ret, prev_t->note_type ());
return ret_tempo;
}
const MeterSection&
TempoMap::meter_section_at_locked (framepos_t frame) const
{
- //framepos_t const frame_off = frame + frame_offset_at (_metrics, frame);
Metrics::const_iterator i;
MeterSection* prev = 0;
const MeterSection&
TempoMap::meter_section_at (const double& beat) const
{
- MeterSection* prev_ms = 0;
+ MeterSection* prev_m = 0;
Glib::Threads::RWLock::ReaderLock lm (lock);
for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
- if (prev_ms && m->beat() > beat) {
+ if (prev_m && m->beat() > beat) {
break;
}
- prev_ms = m;
+ prev_m = m;
}
}
- return *prev_ms;
+ return *prev_m;
+}
+
+void
+TempoMap::fix_legacy_session ()
+{
+ MeterSection* prev_m = 0;
+ TempoSection* prev_t = 0;
+
+ for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+ MeterSection* m;
+ 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;
+ }
+ }
}
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_ms = 0;
- TempoSection* prev_ts = 0;
- if ((m = dynamic_cast<MeterSection*>(*i)) != 0) {
- if (prev_ms && prev_ms->pulse() < 0.0) {
- /*XX we cannot possibly make this work??. */
- pair<double, BBT_Time> start = make_pair (((prev_ms->bbt().bars - 1) * prev_ms->note_divisor()) + (prev_ms->bbt().beats - 1) + (prev_ms->bbt().ticks / BBT_Time::ticks_per_beat), prev_ms->bbt());
- prev_ms->set_beat (start);
- const double start_pulse = ((prev_ms->bbt().bars - 1) * prev_ms->note_divisor()) + (prev_ms->bbt().beats - 1) + (prev_ms->bbt().ticks / BBT_Time::ticks_per_beat);
- prev_ms->set_pulse (start_pulse);
- }
- prev_ms = m;
- } else if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
- if (!t->active()) {
- continue;
- }
- if (prev_ts && prev_ts->pulse() < 0.0) {
- double const start = ((prev_ts->legacy_bbt().bars - 1) * prev_ms->note_divisor()) + (prev_ts->legacy_bbt().beats - 1) + (prev_ts->legacy_bbt().ticks / BBT_Time::ticks_per_beat);
- prev_ts->set_pulse (start);
+ if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+ if (t->legacy_bbt().bars != 0) {
+ fix_legacy_session();
+ break;
}
- prev_ts = t;
+ break;
}
}
+
/* check for multiple tempo/meters at the same location, which
ardour2 somehow allowed.
*/
for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
if (prev != _metrics.end()) {
MeterSection* ms;
- MeterSection* prev_ms;
+ MeterSection* prev_m;
TempoSection* ts;
- TempoSection* prev_ts;
- if ((prev_ms = dynamic_cast<MeterSection*>(*prev)) != 0 && (ms = dynamic_cast<MeterSection*>(*i)) != 0) {
- if (prev_ms->pulse() == ms->pulse()) {
- cerr << string_compose (_("Multiple meter definitions found at %1"), prev_ms->pulse()) << endmsg;
- error << string_compose (_("Multiple meter definitions found at %1"), prev_ms->pulse()) << endmsg;
+ TempoSection* prev_t;
+ if ((prev_m = dynamic_cast<MeterSection*>(*prev)) != 0 && (ms = dynamic_cast<MeterSection*>(*i)) != 0) {
+ if (prev_m->pulse() == ms->pulse()) {
+ cerr << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg;
+ error << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg;
return -1;
}
- } else if ((prev_ts = dynamic_cast<TempoSection*>(*prev)) != 0 && (ts = dynamic_cast<TempoSection*>(*i)) != 0) {
- if (prev_ts->pulse() == ts->pulse()) {
- cerr << string_compose (_("Multiple tempo definitions found at %1"), prev_ts->pulse()) << endmsg;
- error << string_compose (_("Multiple tempo definitions found at %1"), prev_ts->pulse()) << endmsg;
+ } else if ((prev_t = dynamic_cast<TempoSection*>(*prev)) != 0 && (ts = dynamic_cast<TempoSection*>(*i)) != 0) {
+ if (prev_t->pulse() == ts->pulse()) {
+ cerr << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg;
+ error << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg;
return -1;
}
}
Glib::Threads::RWLock::ReaderLock lm (lock, Glib::Threads::TRY_LOCK);
const MeterSection* m;
const TempoSection* t;
- const TempoSection* prev_ts = 0;
+ const TempoSection* prev_t = 0;
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
o << "Tempo @ " << *i << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->pulse() << " frame= " << t->frame() << " (movable? "
<< t->movable() << ')' << " pos lock: " << enum_2_string (t->position_lock_style()) << std::endl;
o << "current : " << t->beats_per_minute() << " | " << t->pulse() << " | " << t->frame() << std::endl;
- if (prev_ts) {
- o << "previous : " << prev_ts->beats_per_minute() << " | " << prev_ts->pulse() << " | " << prev_ts->frame() << std::endl;
- o << "calculated : " << prev_ts->tempo_at_pulse (t->pulse()) * prev_ts->note_type() << " | " << prev_ts->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate) << " | " << prev_ts->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate) << std::endl;
+ if (prev_t) {
+ o << "previous : " << prev_t->beats_per_minute() << " | " << prev_t->pulse() << " | " << prev_t->frame() << std::endl;
+ o << "calculated : " << prev_t->tempo_at_pulse (t->pulse()) * prev_t->note_type() << " | " << prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate) << " | " << prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate) << std::endl;
}
- prev_ts = t;
+ prev_t = t;
} else if ((m = dynamic_cast<const MeterSection*>(*i)) != 0) {
o << "Meter @ " << *i << ' ' << m->divisions_per_bar() << '/' << m->note_divisor() << " at " << m->bbt() << " frame= " << m->frame()
<< " pulse: " << m->pulse() << " beat : " << m->beat() << " pos lock: " << enum_2_string (m->position_lock_style()) << " (movable? " << m->movable() << ')' << endl;