, Tempo (TempoMap::default_tempo())
, _c_func (0.0)
, _active (true)
+ , _locked_to_meter (false)
{
const XMLProperty *prop;
LocaleGuard lg;
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;
}
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 */
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&
_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 ((framepos_t) 0, _default_tempo.beats_per_minute(), _default_tempo.note_type(), TempoSection::Constant);
+ 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);
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)) {
}
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);
}
}
if (recompute) {
solve_map (_metrics, t, t->pulse());
+ recompute_meters (_metrics);
}
return t;
if (recompute) {
solve_map (_metrics, t, t->frame());
+ recompute_meters (_metrics);
}
return t;
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);
+ first.set_position_lock_style (AudioTime);
}
recompute_map (_metrics);
}
}
MeterSection*
-TempoMap::add_meter_locked (const Meter& meter, double beat, BBT_Time where, bool recompute)
+TempoMap::add_meter_locked (const Meter& meter, double beat, const 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
*/
- 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);
+ solve_map (_metrics, new_meter, where);
}
return new_meter;
}
MeterSection*
-TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, double beat, Timecode::BBT_Time where, bool recompute)
+TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, double beat, const Timecode::BBT_Time& where, bool recompute)
{
- MeterSection* new_meter = new MeterSection (frame, beat, where, meter.divisions_per_bar(), meter.note_divisor());
+ /* add meter-locked tempo */
+ TempoSection* t = add_tempo_locked (tempo_at_locked (_metrics, frame), frame, true, TempoSection::Ramp);
+ if (t) {
+ t->set_locked_to_meter (true);
+ }
- double pulse = pulse_at_frame_locked (_metrics, frame);
- new_meter->set_pulse (pulse);
+ MeterSection* new_meter = new MeterSection (frame, beat, where, meter.divisions_per_bar(), meter.note_divisor());
+ new_meter->set_pulse (pulse_at_frame_locked (_metrics, frame));
do_insert (new_meter);
continue;
}
if (!t->movable()) {
- t->set_pulse (0.0);
- prev_t = t;
- continue;
+ 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.
+ this means that a meter's beat may change, but its bbt may not.
+ 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()) - prev_m->pulse();
- 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> new_beat;
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 */
+ new_beat = make_pair (beats + prev_m->beat()
+ , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
+ } else {
+ new_beat = 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());
+ new_beat = 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_pulse (pulse);
+ meter->set_frame (frame_at_pulse_locked (metrics, pulse));
}
prev_m = meter;
}
}
- //dump (_metrics, std::cerr;
}
void
return m;
}
-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();
-}
-
double
TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
{
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()) + prev_m->beat() > m->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 = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat();
+ return ret;
}
double
return beat_at_pulse_locked (_metrics, pulse);
}
+/* 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();
+}
+
+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 */
framecnt_t
TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const
{
return ret;
}
+framecnt_t
+TempoMap::frame_at_pulse (const double& pulse) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+ return frame_at_pulse_locked (_metrics, pulse);
+}
+
+/* meter section based */
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
return beat_at_frame_locked (_metrics, frame);
}
+/* meter section based */
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
}
}
- 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);
bbt = beats_to_bbt_locked (_metrics, beat);
}
+/* meter section based */
framepos_t
TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
{
}
bool
-TempoMap::check_solved (Metrics& metrics, bool by_frame)
+TempoMap::check_solved (const Metrics& metrics, bool by_frame) 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;
/* precision check ensures pulses and frames align.*/
if (t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) {
- return false;
+ 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);
+
+ if (t && (nascent_m_frame > m->frame() || nascent_m_frame < 0)) {
+ return false;
+ }
+ }
+
+ prev_m = m;
+ }
+
}
return true;
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) {
}
if (check_solved (imaginary, true)) {
- recompute_meters (imaginary);
return true;
}
}
if (check_solved (imaginary, true)) {
- recompute_meters (imaginary);
- return true;
- }
-#if (0)
- 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);
return true;
}
-#endif
- //dump (imaginary, std::cerr);
return false;
}
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 (check_solved (imaginary, false)) {
- recompute_meters (imaginary);
return true;
}
}
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);
return true;
}
- //dump (imaginary, std::cerr);
-
return false;
}
-void
+bool
TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
{
- MeterSection* prev_m = 0;
+ /* 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);
+ MeterSection* prev_m = 0;
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (m == section){
- /*
- 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 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 (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()) {
+ /* disallow position change if it will alter our 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.
+ here we set the frame/pulse corresponding to its musical position.
+ */
+
+ if (meter_locked_tempo) {
+ Metrics future_map;
+ bool solved = false;
+ TempoSection* tempo_copy = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+ 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 (future_map, tempo_copy, smallest_frame))) {
+ meter_locked_tempo->set_pulse (new_pulse);
+ solve_map (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;
+ }
+ }
+ return false;
+ } else {
+ if (meter_locked_tempo) {
+ Metrics future_map;
+ bool solved = false;
+
+ TempoSection* tempo_copy = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+ MeterSection* meter_copy = const_cast<MeterSection*> (&meter_section_at_locked (future_map, section->frame()));
+ meter_copy->set_frame (frame);
+
+ if ((solved = solve_map (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 (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 {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- }
+ /* not movable (first meter atm) */
+ if (meter_locked_tempo) {
+ Metrics future_map;
+ bool solved = false;
+ TempoSection* tempo_copy = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+
+ tempo_copy->set_frame (frame);
+ tempo_copy->set_pulse (0.0);
+
+ if ((solved = solve_map (future_map, tempo_copy, frame))) {
+ section->set_frame (frame);
+ meter_locked_tempo->set_frame (frame);
+ meter_locked_tempo->set_pulse (0.0);
+ solve_map (imaginary, meter_locked_tempo, frame);
+ } else {
+ solved = false;
+ }
- section->set_beat (b_bbt);
- section->set_pulse (new_pulse);
- prev_m = m;
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
- continue;
- }
- if (prev_m) {
- double new_pulse = 0.0;
- if (m->position_lock_style() == MusicTime) {
- 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);
+ if (!solved) {
+ return false;
+ }
+
+ } else {
+ 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()) - prev_m->pulse();
- new_pulse = true_pulse - pulse_off;
- } else {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
- new_pulse = 0.0;
- }
- m->set_beat (b_bbt);
+ 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 (new_pulse);
+ break;
}
+
prev_m = m;
}
}
} else {
recompute_meters (imaginary);
}
- //dump (imaginary, std::cerr);
+
+ return true;
}
-void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pulse)
+bool
+TempoMap::solve_map (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 new_pulse = 0.0;
- if (m->position_lock_style() == MusicTime) {
- 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);
+
+ 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()) - prev_m->pulse();
- new_pulse = true_pulse - pulse_off;
- } else {
- b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ }
+
+ 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));
+ }
+ if (meter_locked_tempo) {
+ meter_locked_tempo->set_pulse (new_pulse);
+ recompute_tempos (imaginary);
}
+ 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);
} else {
recompute_meters (imaginary);
}
+
+ return true;
}
/** places a copy of _metrics into copy and returns a pointer
* 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;
- MeterSection* m;
TempoSection* ret = 0;
- 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());
- 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());
+ 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());
- 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());
+
+ 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);
}
}
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 double beat = bbt_to_beats_locked (copy, bbt);
+ const bool ret = solve_map (copy, tempo_copy, pulse_at_beat_locked (copy, beat));
Metrics::const_iterator d = copy.begin();
while (d != copy.end()) {
Glib::Threads::RWLock::ReaderLock lm (lock);
Metrics future_map;
framepos_t ret = 0;
- TempoSection* new_section = copy_metrics_and_point (future_map, section);
-
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, section);
+ if (!tempo_copy) {
+ return 0;
+ }
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();
+ if (solve_map (future_map, tempo_copy, pulse_at_beat_locked (future_map, beat))) {
+ ret = tempo_copy->frame();
} else {
- ret = frame_at_beat_locked (_metrics, beat);
+ ret = section->frame();
}
Metrics::const_iterator d = future_map.begin();
Glib::Threads::RWLock::ReaderLock lm (lock);
Metrics future_map;
double ret = 0.0;
- TempoSection* new_section = copy_metrics_and_point (future_map, section);
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, section);
- if (solve_map (future_map, new_section, frame)) {
- ret = new_section->pulse();
+ if (solve_map (future_map, tempo_copy, frame)) {
+ ret = tempo_copy->pulse();
} else {
- ret = pulse_at_frame_locked (_metrics, frame);
+ ret = section->pulse();
}
Metrics::const_iterator d = future_map.begin();
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)) {
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
+ if (solve_map (future_map, tempo_copy, frame)) {
solve_map (_metrics, ts, frame);
+ recompute_meters (_metrics);
}
}
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))) {
+ TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
+ if (solve_map (future_map, tempo_copy, pulse_at_beat_locked (future_map, beat))) {
solve_map (_metrics, ts, pulse_at_beat_locked (_metrics, beat));
+ recompute_meters (_metrics);
}
}
void
TempoMap::gui_move_meter (MeterSection* ms, const framepos_t& frame)
{
+ Metrics future_map;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, frame);
+ MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
+ if (solve_map (future_map, copy, frame)) {
+ solve_map (_metrics, ms, frame);
+ recompute_tempos (_metrics);
+ }
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
}
MetricPositionChanged (); // Emit Signal
}
void
-TempoMap::gui_move_meter (MeterSection* ms, const double& beat)
+TempoMap::gui_move_meter (MeterSection* ms, const Timecode::BBT_Time& bbt)
{
+ Metrics future_map;
{
Glib::Threads::RWLock::WriterLock lm (lock);
- solve_map (_metrics, ms, pulse_at_beat_locked (_metrics, beat));
+ MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
+ if (solve_map (future_map, copy, bbt)) {
+ solve_map (_metrics, ms, bbt);
+ recompute_tempos (_metrics);
+ }
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
}
MetricPositionChanged (); // Emit Signal
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)) {
return can_solve;
}
+void
+TempoMap::gui_dilate_tempo (MeterSection* ms, const framepos_t& frame)
+{
+ Metrics future_map;
+ TempoSection* ts = 0;
+
+ if (frame <= first_meter().frame()) {
+ return;
+ }
+
+ if (ms->position_lock_style() == AudioTime) {
+ /* disabled for now due to faked tempo locked to meter pulse */
+ return;
+ }
+
+ {
+ Glib::Threads::RWLock::WriterLock lm (lock);
+ ts = const_cast<TempoSection*>(&tempo_section_at_locked (_metrics, ms->frame() - 1));
+ 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 = frame - ms->frame();
+ double new_bpm = 0.0;
+
+ 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));
+ }
+
+ /* 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;
+ frameoffset_t frame_contribution = 0;
+ frameoffset_t prev_t_frame_contribution = fr_off;
+
+ if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+ /* prev to prev_t's position will remain constant in terms of frame and pulse. lets use frames. */
+ contribution = (prev_t->frame() - prev_to_prev_t->frame()) / (double) (ms->frame() - prev_to_prev_t->frame());
+ frame_contribution = contribution * (double) fr_off;
+ prev_t_frame_contribution = fr_off - frame_contribution;
+ }
+
+ 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() * ((ms->frame() - prev_t->frame())
+ / (double) (ms->frame() + prev_t_frame_contribution - prev_t->frame()));
+
+ } else {
+ /* prev to prev is irrelevant */
+ const double meter_pulse = prev_t->pulse_at_frame (ms->frame(), _frame_rate);
+ const double frame_pulse = prev_t->pulse_at_frame (frame, _frame_rate);
+
+ if (frame_pulse != prev_t->pulse()) {
+ new_bpm = prev_t->beats_per_minute() * ((meter_pulse - prev_t->pulse()) / (frame_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() * ((ms->frame() - prev_t->frame())
+ / (double) (ms->frame() + prev_t_frame_contribution - prev_t->frame()));
+ } else {
+ /* prev_to_prev_t is irrelevant */
+
+ if (frame != prev_t->frame()) {
+ new_bpm = prev_t->beats_per_minute() * ((ms->frame() - prev_t->frame()) / (double) (frame - prev_t->frame()));
+ } else {
+ new_bpm = prev_t->beats_per_minute();
+ }
+ }
+ }
+ } else if (prev_t->c_func() < 0.0) {
+ if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+ new_bpm = prev_t->tempo_at_frame (prev_t->frame() + frame_contribution, _frame_rate) * (double) prev_t->note_type();
+ } else {
+ /* prev_to_prev_t is irrelevant */
+ new_bpm = prev_t->tempo_at_frame (prev_t->frame() + fr_off, _frame_rate) * (double) prev_t->note_type();
+ }
+
+ } else if (prev_t->c_func() > 0.0) {
+ if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
+ new_bpm = prev_t->tempo_at_frame (prev_t->frame() - frame_contribution, _frame_rate) * (double) prev_t->note_type();
+ } else {
+ /* prev_to_prev_t is irrelevant */
+ new_bpm = prev_t->tempo_at_frame (prev_t->frame() - fr_off, _frame_rate) * (double) prev_t->note_type();
+ }
+ }
+
+ /* limits - a bit clunky, but meh */
+ const double diff = (prev_t->tempo_at_frame (frame, _frame_rate) * prev_t->note_type()) - prev_t->beats_per_minute();
+ if (diff > -1.0 && diff < 1.0) {
+ new_bpm = prev_t->beats_per_minute() * ((ms->frame() - prev_t->frame())
+ / (double) ((ms->frame() + prev_t_frame_contribution) - prev_t->frame()));
+ }
+
+ prev_t->set_beats_per_minute (new_bpm);
+ recompute_tempos (future_map);
+ recompute_meters (future_map);
+
+ if (check_solved (future_map, true)) {
+
+ prev_t = const_cast<TempoSection*>(&tempo_section_at_locked (_metrics, ms->frame() - 1));
+ prev_t->set_beats_per_minute (new_bpm);
+ recompute_tempos (_metrics);
+
+ if (ms->position_lock_style() == AudioTime) {
+ ms->set_frame (frame);
+ }
+
+ recompute_meters (_metrics);
+ }
+ }
+
+ Metrics::const_iterator d = future_map.begin();
+ while (d != future_map.end()) {
+ delete (*d);
+ ++d;
+ }
+
+ MetricPositionChanged (); // Emit Signal
+}
+
+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, true)) {
+ 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)
{
}
void
-TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num)
+TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num, RoundMode dir)
{
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) {
+ if (dir > 0) {
++when.bars;
+ when.beats = 1;
+ when.ticks = 0;
+ } else if (dir < 0) {
+ when.beats = 1;
+ when.ticks = 0;
+ } else {
+ 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.beats = 1;
+ when.ticks = 0;
}
- 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();
+ 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) {
}
}
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 (dir > 0) {
+ /* round to next (or same iff dir == RoundUpMaybe) */
- if (when.ticks > Timecode::BBT_Time::ticks_per_beat) {
- ++when.beats;
- when.ticks -= Timecode::BBT_Time::ticks_per_beat;
+ uint32_t mod = when.ticks % ticks_one_subdivisions_worth;
+
+ if (mod == 0 && dir == RoundUpMaybe) {
+ /* right on the subdivision, which is fine, so do nothing */
+
+ } else if (mod == 0) {
+ /* right on the subdivision, so the difference is just the subdivision ticks */
+ when.ticks += ticks_one_subdivisions_worth;
+
+ } else {
+ /* not on subdivision, compute distance to next subdivision */
+
+ when.ticks += ticks_one_subdivisions_worth - mod;
}
- } else if (rem > 0) {
- /* closer to previous subdivision, so shift backward */
+ if (when.ticks >= BBT_Time::ticks_per_beat) {
+ when.ticks -= BBT_Time::ticks_per_beat;
+ }
- 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 if (dir < 0) {
+ /* round to previous (or same iff dir == RoundDownMaybe) */
+
+ uint32_t difference = when.ticks % ticks_one_subdivisions_worth;
+
+ if (difference == 0 && dir == RoundDownAlways) {
+ /* right on the subdivision, but force-rounding down,
+ so the difference is just the subdivision ticks */
+ difference = ticks_one_subdivisions_worth;
+ }
+
+ if (when.ticks < difference) {
+ when.ticks = BBT_Time::ticks_per_beat - when.ticks;
} else {
- when.ticks = when.ticks - rem;
+ when.ticks -= difference;
+ }
+
+ } else {
+ /* round to nearest */ 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 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);
+ 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.get_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;
+}
+
+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;
}
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 ()
+{
+ 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&
TempoMap::get_state ()
{
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.
*/
}
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;
projects / ardour.git / blobdiff