X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Ftempo.cc;h=8c710ad180896a95f7284e9ffb050f37540dc119;hb=a68ff8e5408c5043477c3ec6823dd71486380a44;hp=22e8eaf809980b5d69cbcbc0ef522ad25e628fe2;hpb=8b0a2897b97b2ff61fa5ba5ce112d015645a000b;p=ardour.git diff --git a/libs/ardour/tempo.cc b/libs/ardour/tempo.cc index 22e8eaf809..8c710ad180 100644 --- a/libs/ardour/tempo.cc +++ b/libs/ardour/tempo.cc @@ -77,6 +77,7 @@ TempoSection::TempoSection (const XMLNode& node) , Tempo (TempoMap::default_tempo()) , _c_func (0.0) , _active (true) + , _locked_to_meter (false) { const XMLProperty *prop; LocaleGuard lg; @@ -163,6 +164,12 @@ TempoSection::TempoSection (const XMLNode& node) } 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& @@ -186,6 +193,7 @@ TempoSection::get_state() const 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; } @@ -308,7 +316,7 @@ The integral over t of our Tempo function (the beat function, which is the durat 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 @@ -328,6 +336,13 @@ t = b log (Ta / T0) / (T0 (e^(log (Ta / T0)) - 1)) 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. @@ -365,30 +380,30 @@ TempoSection::compute_c_func_frame (const double& end_bpm, const framepos_t& end 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 */ @@ -639,6 +654,12 @@ TempoMap::TempoMap (framecnt_t fr) TempoMap::~TempoMap () { + Metrics::const_iterator d = _metrics.begin(); + while (d != _metrics.end()) { + delete (*d); + ++d; + } + _metrics.clear(); } void @@ -669,6 +690,7 @@ TempoMap::remove_tempo_locked (const TempoSection& tempo) if (dynamic_cast (*i) != 0) { if (tempo.frame() == (*i)->frame()) { if ((*i)->movable()) { + delete (*i); _metrics.erase (i); return true; } @@ -699,14 +721,28 @@ TempoMap::remove_meter (const MeterSection& tempo, bool complete_operation) } 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 (*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 (*i) != 0) { - if (tempo.frame() == (*i)->frame()) { + if (meter.frame() == (*i)->frame()) { if ((*i)->movable()) { + delete (*i); _metrics.erase (i); return true; } @@ -726,7 +762,6 @@ TempoMap::do_insert (MetricSection* section) */ MeterSection* m = 0; if ((m = dynamic_cast(section)) != 0) { - //assert (m->bbt().ticks == 0); if ((m->bbt().beats != 1) || (m->bbt().ticks != 0)) { @@ -775,6 +810,7 @@ TempoMap::do_insert (MetricSection* section) } need_add = false; } else { + delete (*i); _metrics.erase (i); } break; @@ -799,6 +835,7 @@ TempoMap::do_insert (MetricSection* section) (*i)->set_position_lock_style (AudioTime); need_add = false; } else { + delete (*i); _metrics.erase (i); } @@ -842,7 +879,7 @@ TempoMap::do_insert (MetricSection* section) } _metrics.insert (i, section); - //dump (_metrics, std::cerr); + //dump (_metrics, std::cout); } } @@ -930,6 +967,7 @@ TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, bool recompute, AR if (recompute) { solve_map (_metrics, t, t->pulse()); + recompute_meters (_metrics); } return t; @@ -944,6 +982,7 @@ TempoMap::add_tempo_locked (const Tempo& tempo, framepos_t frame, bool recompute if (recompute) { solve_map (_metrics, t, t->frame()); + recompute_meters (_metrics); } return t; @@ -1045,7 +1084,7 @@ TempoMap::add_meter (const Meter& meter, const framepos_t& frame, const double& } 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 @@ -1054,30 +1093,29 @@ TempoMap::add_meter_locked (const Meter& meter, double beat, BBT_Time where, boo */ - 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); @@ -1252,14 +1290,18 @@ TempoMap::recompute_tempos (Metrics& metrics) 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)); @@ -1273,7 +1315,12 @@ TempoMap::recompute_tempos (Metrics& metrics) 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) { @@ -1285,45 +1332,66 @@ TempoMap::recompute_meters (Metrics& metrics) if (meter->position_lock_style() == AudioTime) { double pulse = 0.0; pair 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()); - if (floor_beats + prev_m->beat() < meter->beat()) { - /* tempo change caused a change in beat (bar). */ - b_bbt = make_pair (floor_beats + prev_m->beat(), BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0)); - const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor()); - const double pulse_off = true_pulse - (beats / prev_m->note_divisor()) - prev_m->pulse(); - pulse = true_pulse - pulse_off; - } else { + TempoSection* meter_locked_tempo = 0; + for (Metrics::const_iterator ii = metrics.begin(); ii != metrics.end(); ++ii) { + TempoSection* t; + if ((t = dynamic_cast (*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 = pulse_at_frame_locked (metrics, meter->frame()); + 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 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()); - new_beat = make_pair (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), meter->bbt()); + 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 (pulse, meter->bbt()); + new_beat = make_pair (meter->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 @@ -1446,7 +1514,7 @@ TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) con MeterSection* m; if ((m = dynamic_cast (*i)) != 0) { if (prev_m && m->pulse() > pulse) { - if ((pulse - prev_m->pulse()) * prev_m->note_divisor() < m->beat()) { + if (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > m->beat()) { break; } } @@ -1454,9 +1522,8 @@ TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) con } } - 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 @@ -1466,6 +1533,7 @@ TempoMap::beat_at_pulse (const double& pulse) const return beat_at_pulse_locked (_metrics, pulse); } +/* tempo section based */ double TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const { @@ -1500,6 +1568,7 @@ TempoMap::pulse_at_frame (const framecnt_t& frame) const return pulse_at_frame_locked (_metrics, frame); } +/* tempo section based */ framecnt_t TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const { @@ -1537,15 +1606,34 @@ TempoMap::frame_at_pulse (const double& pulse) const 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 MeterSection& prev_m = meter_section_at_locked (metrics, frame); const TempoSection& ts = tempo_section_at_locked (metrics, frame); - if (frame < prev_m.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 (*i)) != 0) { + if (prev_m && m->frame() > frame) { + next_m = m; + break; + } + prev_m = m; + } + } + if (frame < prev_m->frame()) { return 0.0; } - return prev_m.beat() + (ts.pulse_at_frame (frame, _frame_rate) - prev_m.pulse()) * prev_m.note_divisor(); + 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 @@ -1555,6 +1643,7 @@ TempoMap::beat_at_frame (const framecnt_t& frame) const return beat_at_frame_locked (_metrics, frame); } +/* meter section based */ framecnt_t TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const { @@ -1745,6 +1834,7 @@ TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt) bbt = beats_to_bbt_locked (_metrics, beat); } +/* meter section based */ framepos_t TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const { @@ -1774,9 +1864,11 @@ bool 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 (*i)) != 0) { if (!t->active()) { continue; @@ -1792,11 +1884,28 @@ TempoMap::check_solved (const Metrics& metrics, bool by_frame) const /* 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 (*i)) != 0) { + if (prev_m && m->position_lock_style() == AudioTime) { + TempoSection* t = const_cast(&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; @@ -1865,7 +1974,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate)); } else { prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate)); - t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate)); + if (!t->locked_to_meter()) { + t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate)); + } } } prev_t = t; @@ -1874,7 +1985,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_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) { @@ -1887,7 +2000,6 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t } if (check_solved (imaginary, true)) { - recompute_meters (imaginary); return true; } @@ -1903,27 +2015,8 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t } 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; } @@ -1957,7 +2050,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu 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; @@ -1978,7 +2073,6 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu } if (check_solved (imaginary, false)) { - recompute_meters (imaginary); return true; } @@ -1994,127 +2088,154 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu } if (check_solved (imaginary, false)) { - recompute_meters (imaginary); return true; } -#if (0) - 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; - } -#endif - //dump (imaginary, std::cerr); return false; } -void +bool TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame) { /* disallow moving first meter past any subsequent one, and any movable meter before the first one */ const MeterSection* other = &meter_section_at_locked (imaginary, frame); if ((!section->movable() && other->movable()) || (!other->movable() && section->movable() && other->frame() >= frame)) { - return; + return false; } - MeterSection* prev_m = 0; 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 (*ii)) != 0) { + if ((t->locked_to_meter() || !t->movable()) && t->frame() == section->frame()) { + meter_locked_tempo = t; + break; + } } } + MeterSection* prev_m = 0; + for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { MeterSection* m; if ((m = dynamic_cast (*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 delta to find the meter's pulse. - */ - double new_pulse = 0.0; - pair 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()); - if (floor_beats + prev_m->beat() < section->beat()) { - /* disallow position change if it will alter out beat + if (prev_m && section->movable()) { + const double beats = (pulse_at_frame_locked (imaginary, frame) - prev_m->pulse()) * prev_m->note_divisor(); + if (beats + prev_m->beat() < section->beat()) { + /* 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. */ - return; - } - b_bbt = make_pair (section->beat(), section->bbt()); - new_pulse = pulse_at_frame_locked (imaginary, frame); - } else { - b_bbt = make_pair (0.0, BBT_Time (1, 1, 0)); - } - section->set_frame (frame); - section->set_beat (b_bbt); - section->set_pulse (new_pulse); - prev_m = m; - 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 new_beat (((new_pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt()); - m->set_beat (new_beat); + 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 (&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 { - pair 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; + /* 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; + } + + 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)); - new_pulse = 0.0; + return false; } - m->set_beat (b_bbt); + pair 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; } } @@ -2129,66 +2250,114 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t } 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 (*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 (*i)) != 0) { - if (m == section){ + pair 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 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 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 (*ii)) != 0) { + if ((t->locked_to_meter() || !t->movable()) && t->frame() == m->frame()) { + meter_locked_tempo = t; + break; + } } - } else { - pair 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 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 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); @@ -2197,55 +2366,60 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pu } 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 (*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 (*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 (*i)) != 0) { + TempoSection* cp = new TempoSection (*t); + copy.push_back (cp); + } + + if ((m = dynamic_cast (*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); } } @@ -2257,15 +2431,18 @@ bool 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()) { @@ -2290,14 +2467,16 @@ 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); - + 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(); @@ -2314,12 +2493,12 @@ 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); + 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(); @@ -2336,9 +2515,10 @@ 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, 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); } } @@ -2357,9 +2537,10 @@ 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, 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); } } @@ -2375,20 +2556,42 @@ TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat) 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 @@ -2401,8 +2604,8 @@ TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm) bool can_solve = false; { Glib::Threads::RWLock::WriterLock lm (lock); - TempoSection* new_section = copy_metrics_and_point (future_map, ts); - new_section->set_beats_per_minute (bpm.beats_per_minute()); + TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts); + tempo_copy->set_beats_per_minute (bpm.beats_per_minute()); recompute_tempos (future_map); if (check_solved (future_map, true)) { @@ -2423,6 +2626,257 @@ TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm) 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(&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(&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(&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(&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 (*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) { @@ -2544,16 +2998,27 @@ TempoMap::round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode 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_beat (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_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar(); if ((double) when.ticks > BBT_Time::ticks_per_beat / 2.0) { @@ -2564,32 +3029,76 @@ TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num) } } 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; + } } } } @@ -2653,7 +3162,6 @@ TempoMap::get_grid (vector& points, framepos_t lower, framepos_t upper) { Glib::Threads::RWLock::ReaderLock lm (lock); - const int32_t upper_beat = (int32_t) floor (beat_at_frame_locked (_metrics, upper)); int32_t cnt = ceil (beat_at_frame_locked (_metrics, lower)); framecnt_t pos = 0; /* although the map handles negative beats, bbt doesn't. */ @@ -2725,6 +3233,24 @@ TempoMap::tempo_section_at_beat_locked (const Metrics& metrics, const double& be 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 (*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 */