X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Ftempo.cc;h=7c4ffd6a104186c6c1ee7a03ef13a11f65294969;hb=a68ff8e5408c5043477c3ec6823dd71486380a44;hp=61389fe7152f276e5eb2ec9c686a5dc69a18237b;hpb=989089a4e997de450f1249bf24755a729f7568db;p=ardour.git diff --git a/libs/ardour/tempo.cc b/libs/ardour/tempo.cc index 61389fe715..8c710ad180 100644 --- a/libs/ardour/tempo.cc +++ b/libs/ardour/tempo.cc @@ -68,20 +68,25 @@ Meter::frames_per_bar (const Tempo& tempo, framecnt_t sr) const return frames_per_grid (tempo, sr) * _divisions_per_bar; } - /***********************************************************************/ const string TempoSection::xml_state_node_name = "Tempo"; TempoSection::TempoSection (const XMLNode& node) - : MetricSection (0.0), Tempo (TempoMap::default_tempo()) + : MetricSection (0.0) + , Tempo (TempoMap::default_tempo()) + , _c_func (0.0) + , _active (true) + , _locked_to_meter (false) { const XMLProperty *prop; LocaleGuard lg; BBT_Time bbt; - double beat; + 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, @@ -89,21 +94,19 @@ TempoSection::TempoSection (const XMLNode& node) &bbt.ticks) == 3) { /* legacy session - start used to be in bbt*/ _legacy_bbt = bbt; - beat = -1.0; - set_beat (beat); + pulse = -1.0; + 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 ("beat")) != 0) { - if (sscanf (prop->value().c_str(), "%lf", &beat) != 1 || beat < 0.0) { - error << _("TempoSection XML node has an illegal \"beat\" value") << endmsg; - } else { - set_beat (beat); + if ((prop = node.property ("pulse")) != 0) { + 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; @@ -139,13 +142,11 @@ TempoSection::TempoSection (const XMLNode& node) set_movable (string_is_affirmative (prop->value())); - if ((prop = node.property ("bar-offset")) == 0) { - _bar_offset = -1.0; + if ((prop = node.property ("active")) == 0) { + warning << _("TempoSection XML node has no \"active\" property") << endmsg; + set_active(true); } else { - if (sscanf (prop->value().c_str(), "%lf", &_bar_offset) != 1 || _bar_offset < 0.0) { - error << _("TempoSection XML node has an illegal \"bar-offset\" value") << endmsg; - throw failed_constructor(); - } + set_active (string_is_affirmative (prop->value())); } if ((prop = node.property ("tempo-type")) == 0) { @@ -155,10 +156,20 @@ TempoSection::TempoSection (const XMLNode& node) } 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& @@ -168,142 +179,112 @@ TempoSection::get_state() const char buf[256]; LocaleGuard lg; - snprintf (buf, sizeof (buf), "%f", beat()); - root->add_property ("beat", buf); + snprintf (buf, sizeof (buf), "%f", pulse()); + root->add_property ("pulse", buf); snprintf (buf, sizeof (buf), "%li", frame()); root->add_property ("frame", buf); snprintf (buf, sizeof (buf), "%f", _beats_per_minute); root->add_property ("beats-per-minute", buf); snprintf (buf, sizeof (buf), "%f", _note_type); root->add_property ("note-type", buf); - // snprintf (buf, sizeof (buf), "%f", _bar_offset); - // root->add_property ("bar-offset", buf); snprintf (buf, sizeof (buf), "%s", movable()?"yes":"no"); root->add_property ("movable", buf); + snprintf (buf, sizeof (buf), "%s", active()?"yes":"no"); + 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; } -void - -TempoSection::update_bar_offset_from_bbt (const Meter& m) -{ - _bar_offset = (beat() * BBT_Time::ticks_per_beat) / - (m.divisions_per_bar() * BBT_Time::ticks_per_beat); - - DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Tempo set bar offset to %1 from %2 w/%3\n", _bar_offset, beat(), m.divisions_per_bar())); -} - void TempoSection::set_type (Type type) { _type = type; } -/** returns the tempo at the zero-based (relative to session) frame. +/** returns the tempo in whole pulses per minute at the zero-based (relative to session) frame. */ double -TempoSection::tempo_at_frame (framepos_t f, framecnt_t frame_rate) const +TempoSection::tempo_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const { - if (_type == Constant) { - return beats_per_minute(); + if (_type == Constant || _c_func == 0.0) { + return pulses_per_minute(); } - return tick_tempo_at_time (frame_to_minute (f - frame(), frame_rate)) / BBT_Time::ticks_per_beat; + return pulse_tempo_at_time (frame_to_minute (f - frame(), frame_rate)); } /** returns the zero-based frame (relative to session) - where the tempo occurs in this section. + where the tempo in whole pulses per minute occurs in this section. beat b is only used for constant tempos. note that the tempo map may have multiple such values. */ framepos_t -TempoSection::frame_at_tempo (double bpm, double b, framecnt_t frame_rate) const +TempoSection::frame_at_tempo (const double& ppm, const double& b, const framecnt_t& frame_rate) const { - if (_type == Constant) { - return ((b - beat()) * frames_per_beat (frame_rate)) + frame(); + if (_type == Constant || _c_func == 0.0) { + return ((b - pulse()) * frames_per_pulse (frame_rate)) + frame(); } - return minute_to_frame (time_at_tick_tempo (bpm * BBT_Time::ticks_per_beat), frame_rate) + frame(); + return minute_to_frame (time_at_pulse_tempo (ppm), frame_rate) + frame(); } -/** returns the tempo at the zero-based (relative to session) beat. +/** returns the tempo in pulses per minute at the zero-based (relative to session) beat. */ double -TempoSection::tempo_at_beat (double b) const +TempoSection::tempo_at_pulse (const double& p) const { - if (_type == Constant) { - return beats_per_minute(); + if (_type == Constant || _c_func == 0.0) { + return pulses_per_minute(); } - - return tick_tempo_at_tick ((b - beat()) * BBT_Time::ticks_per_beat) / BBT_Time::ticks_per_beat; + double const ppm = pulse_tempo_at_pulse (p - pulse()); + return ppm; } /** returns the zero-based beat (relative to session) - where the tempo occurs given frame f. frame f is only used for constant tempos. + where the tempo in whole pulses per minute occurs given frame f. frame f is only used for constant tempos. note that the session tempo map may have multiple beats at a given tempo. */ double -TempoSection::beat_at_tempo (double bpm, framepos_t f, framecnt_t frame_rate) const +TempoSection::pulse_at_tempo (const double& ppm, const framepos_t& f, const framecnt_t& frame_rate) const { - if (_type == Constant) { - double const ticks = (((f - frame()) / frames_per_beat (frame_rate)) * BBT_Time::ticks_per_beat) + tick(); - return ticks / BBT_Time::ticks_per_beat; + if (_type == Constant || _c_func == 0.0) { + double const pulses = ((f - frame()) / frames_per_pulse (frame_rate)) + pulse(); + return pulses; } - - return (tick_at_tick_tempo (bpm * BBT_Time::ticks_per_beat) + tick()) / BBT_Time::ticks_per_beat; + return pulse_at_pulse_tempo (ppm) + pulse(); } -/** returns the zero-based beat (relative to session origin) +/** returns the zero-based pulse (relative to session origin) where the zero-based frame (relative to session) lies. */ double -TempoSection::beat_at_frame (framepos_t frame, framecnt_t frame_rate) const -{ - return tick_at_frame (frame, frame_rate) / BBT_Time::ticks_per_beat; -} - -/** returns the zero-based frame (relative to session start frame) - where the zero-based beat (relative to session start) - falls. -*/ - -framepos_t -TempoSection::frame_at_beat (double beat, framecnt_t frame_rate) const -{ - return frame_at_tick (beat * BBT_Time::ticks_per_beat, frame_rate); -} - -/** returns the zero-based tick (relative to session origin) - where the zero-based frame (relative to tempo section) - lies. -*/ -double -TempoSection::tick_at_frame (framepos_t f, framecnt_t frame_rate) const +TempoSection::pulse_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const { - if (_type == Constant) { - return (((f - frame()) / frames_per_beat (frame_rate)) * BBT_Time::ticks_per_beat) + tick(); + if (_type == Constant || _c_func == 0.0) { + return ((f - frame()) / frames_per_pulse (frame_rate)) + pulse(); } - return tick_at_time (frame_to_minute (f - frame(), frame_rate)) + tick(); + return pulse_at_time (frame_to_minute (f - frame(), frame_rate)) + pulse(); } -/** returns the zero-based frame (relative to session origin) - where the zero-based tick (relative to session) +/** returns the zero-based frame (relative to session start frame) + where the zero-based pulse (relative to session start) falls. */ + framepos_t -TempoSection::frame_at_tick (double t, framecnt_t frame_rate) const +TempoSection::frame_at_pulse (const double& p, const framecnt_t& frame_rate) const { - if (_type == Constant) { - return (framepos_t) floor (((t - tick()) / BBT_Time::ticks_per_beat) * frames_per_beat (frame_rate)) + frame(); + if (_type == Constant || _c_func == 0.0) { + return (framepos_t) floor ((p - pulse()) * frames_per_pulse (frame_rate)) + frame(); } - return minute_to_frame (time_at_tick (t - tick()), frame_rate) + frame(); + return minute_to_frame (time_at_pulse (p - pulse()), frame_rate) + frame(); } /* @@ -335,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 @@ -355,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. @@ -374,140 +362,94 @@ https://www.zhdk.ch/fileadmin/data_subsites/data_icst/Downloads/Timegrid/ICST_Te */ -/* set this ramp's function constant using the end tempo and duration (beats into global start) of some later tempo section*/ -void -TempoSection::set_c_func_from_tempo_and_beat (double end_bpm, double end_beat, framecnt_t frame_rate) +/* + compute this ramp's function constant using the end tempo (in whole pulses per minute) + and duration (pulses into global start) of some later tempo section. +*/ +double +TempoSection::compute_c_func_pulse (const double& end_bpm, const double& end_pulse, const framecnt_t& frame_rate) { - double const log_tempo_ratio = log ((end_bpm * BBT_Time::ticks_per_beat) / ticks_per_minute()); - _c_func = ticks_per_minute() * (exp (log_tempo_ratio) - 1) / ((end_beat - beat()) * BBT_Time::ticks_per_beat); + double const log_tempo_ratio = log (end_bpm / pulses_per_minute()); + return pulses_per_minute() * (expm1 (log_tempo_ratio)) / (end_pulse - pulse()); } -/* compute the function constant from some later tempo section, given tempo (beats/min.) and distance (in frames) from session origin */ +/* compute the function constant from some later tempo section, given tempo (whole pulses/min.) and distance (in frames) from session origin */ double -TempoSection::compute_c_func (double end_bpm, framepos_t end_frame, framecnt_t frame_rate) const +TempoSection::compute_c_func_frame (const double& end_bpm, const framepos_t& end_frame, const framecnt_t& frame_rate) const { - return c_func (end_bpm * BBT_Time::ticks_per_beat, frame_to_minute (end_frame - frame(), frame_rate)); + return c_func (end_bpm, frame_to_minute (end_frame - frame(), frame_rate)); } -framecnt_t -TempoSection::minute_to_frame (double time, framecnt_t frame_rate) const +framepos_t +TempoSection::minute_to_frame (const double& time, const framecnt_t& frame_rate) const { - return (framecnt_t) floor ((time * 60.0 * frame_rate)); + return (framepos_t) floor ((time * 60.0 * frame_rate) + 0.5); } double -TempoSection::frame_to_minute (framecnt_t frame, 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_tpm, double c_func) const +TempoSection::a_func (double end_ppm, double c_func) const { - return log (end_tpm / ticks_per_minute()) / c_func; + return log (end_ppm / pulses_per_minute()) / c_func; } /*function constant*/ double -TempoSection::c_func (double end_tpm, double end_time) const +TempoSection::c_func (double end_ppm, double end_time) const { - return log (end_tpm / ticks_per_minute()) / end_time; + return log (end_ppm / pulses_per_minute()) / end_time; } -/* tempo in tpm at time in minutes */ +/* tempo in ppm at time in minutes */ double -TempoSection::tick_tempo_at_time (double time) const +TempoSection::pulse_tempo_at_time (const double& time) const { - return exp (_c_func * time) * ticks_per_minute(); + return exp (_c_func * time) * pulses_per_minute(); } -/* time in minutes at tempo in tpm */ +/* time in minutes at tempo in ppm */ double -TempoSection::time_at_tick_tempo (double tick_tempo) const +TempoSection::time_at_pulse_tempo (const double& pulse_tempo) const { - return log (tick_tempo / ticks_per_minute()) / _c_func; + return log (pulse_tempo / pulses_per_minute()) / _c_func; } -/* tick at tempo in tpm */ +/* tick at tempo in ppm */ double -TempoSection::tick_at_tick_tempo (double tick_tempo) const +TempoSection::pulse_at_pulse_tempo (const double& pulse_tempo) const { - return (tick_tempo - ticks_per_minute()) / _c_func; + return (pulse_tempo - pulses_per_minute()) / _c_func; } -/* tempo in tpm at tick */ +/* tempo in ppm at tick */ double -TempoSection::tick_tempo_at_tick (double tick) const +TempoSection::pulse_tempo_at_pulse (const double& pulse) const { - return (tick * _c_func) + ticks_per_minute(); + return (pulse * _c_func) + pulses_per_minute(); } -/* tick at time in minutes */ +/* pulse at time in minutes */ double -TempoSection::tick_at_time (double time) const +TempoSection::pulse_at_time (const double& time) const { - return ((exp (_c_func * time)) - 1) * ticks_per_minute() / _c_func; + return expm1 (_c_func * time) * (pulses_per_minute() / _c_func); } -/* time in minutes at tick */ +/* time in minutes at pulse */ double -TempoSection::time_at_tick (double tick) const +TempoSection::time_at_pulse (const double& pulse) const { - return log (((_c_func * tick) / ticks_per_minute()) + 1) / _c_func; -} - -/* beat at time in minutes */ -double -TempoSection::beat_at_time (double time) const -{ - return tick_at_time (time) / BBT_Time::ticks_per_beat; -} - -/* time in munutes at beat */ -double -TempoSection::time_at_beat (double beat) const -{ - return time_at_tick (beat * BBT_Time::ticks_per_beat); -} - -void -TempoSection::update_bbt_time_from_bar_offset (const Meter& meter) -{ - double new_beat; - - if (_bar_offset < 0.0) { - /* not set yet */ - return; - } - - new_beat = beat(); - - double ticks = BBT_Time::ticks_per_beat * meter.divisions_per_bar() * _bar_offset; - new_beat = ticks / BBT_Time::ticks_per_beat; - - DEBUG_TRACE (DEBUG::TempoMath, string_compose ("from bar offset %1 and dpb %2, ticks = %3->%4 beats = %5\n", - _bar_offset, meter.divisions_per_bar(), ticks, new_beat, new_beat)); - - set_beat (new_beat); + return log1p ((_c_func * pulse) / pulses_per_minute()) / _c_func; } /***********************************************************************/ -/* -if a meter section is position locked to frames, then it can only be at 1|1|0. -thus we can have multiple 1|1|0s in the session tempo map. - -like this: - -BBT 1|1|0 2|1|0 3|1|0 1|1|0 -beat 0 4 8 12 - -all other meter sections are locked to beats. - -the beat of a meter section is used to find its position rather than the stored bbt. -*/ - const string MeterSection::xml_state_node_name = "Meter"; MeterSection::MeterSection (const XMLNode& node) @@ -518,6 +460,7 @@ MeterSection::MeterSection (const XMLNode& node) LocaleGuard lg; const XMLProperty *prop; BBT_Time bbt; + double pulse = 0.0; double beat = 0.0; framepos_t frame = 0; pair start; @@ -530,14 +473,20 @@ MeterSection::MeterSection (const XMLNode& node) error << _("MeterSection XML node has an illegal \"start\" value") << endmsg; } else { /* legacy session - start used to be in bbt*/ - beat = -1.0; + info << _("Legacy session detected - MeterSection XML node will be altered.") << endmsg; + pulse = -1.0; + } + } + + if ((prop = node.property ("pulse")) != 0) { + if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1) { + error << _("MeterSection XML node has an illegal \"pulse\" value") << endmsg; } - } else { - error << _("MeterSection XML node has no \"start\" property") << endmsg; } + set_pulse (pulse); if ((prop = node.property ("beat")) != 0) { - if (sscanf (prop->value().c_str(), "%lf", &beat) != 1 || beat < 0.0) { + if (sscanf (prop->value().c_str(), "%lf", &beat) != 1) { error << _("MeterSection XML node has an illegal \"beat\" value") << endmsg; } } @@ -545,17 +494,16 @@ MeterSection::MeterSection (const XMLNode& node) 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; - set_beat (start); if ((prop = node.property ("frame")) != 0) { @@ -588,19 +536,23 @@ MeterSection::MeterSection (const XMLNode& node) 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& @@ -610,6 +562,8 @@ MeterSection::get_state() const char buf[256]; LocaleGuard lg; + snprintf (buf, sizeof (buf), "%lf", pulse()); + root->add_property ("pulse", buf); snprintf (buf, sizeof (buf), "%" PRIu32 "|%" PRIu32 "|%" PRIu32, bbt().bars, bbt().beats, @@ -631,10 +585,46 @@ MeterSection::get_state() const } /***********************************************************************/ +/* + Tempo Map Overview + + Tempo can be thought of as a source of the musical pulse. + Meters divide that pulse into measures and beats. + Tempo pulses can be divided to be in sympathy with the meter, but this does not affect the beat + at any particular time. + Note that Tempo::beats_per_minute() has nothing to do with musical beats. + It should rather be thought of as tempo note divisions per minute. + TempoSections, which are nice to think of in whole pulses per minute, + and MeterSecions which divide tempo pulses into measures (via divisions_per_bar) + and beats (via note_divisor) are used to form a tempo map. + TempoSections and MeterSections may be locked to either audio or music (position lock style). + We construct the tempo map by first using the frame or pulse position (depending on position lock style) of each tempo. + We then use this pulse/frame layout to find the beat & pulse or frame position of each meter (again depending on lock style). + + Having done this, we can now find any one of tempo, beat, frame or pulse if a beat, frame, pulse or tempo is known. + + The first tempo and first meter are special. they must move together, and must be locked to audio. + Audio locked tempos which lie before the first meter are made inactive. + They will be re-activated if the first meter is again placed before them. + + Both tempos and meters have a pulse position and a frame position. + Meters also have a beat position, which is always 0.0 for the first meter. + + A tempo locked to music is locked to musical pulses. + A meter locked to music is locked to beats. + + Recomputing the tempo map is the process where the 'missing' position + (tempo pulse or meter pulse & beat in the case of AudioTime, frame for MusicTime) is calculated. + + It is important to keep the _metrics in an order that makes sense. + Because ramped MusicTime and AudioTime tempos can interact with each other, + reordering is frequent. Care must be taken to keep _metrics in a solved state. + Solved means ordered by frame or pulse with frame-accurate precision (see check_solved()). +*/ struct MetricSectionSorter { bool operator() (const MetricSection* a, const MetricSection* b) { - return a->beat() < b->beat(); + return a->pulse() < b->pulse(); } }; @@ -649,21 +639,27 @@ TempoMap::TempoMap (framecnt_t fr) _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, 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); /* note: frame time is correct (zero) for both of these */ - metrics.push_back (t); - metrics.push_back (m); + _metrics.push_back (t); + _metrics.push_back (m); } TempoMap::~TempoMap () { + Metrics::const_iterator d = _metrics.begin(); + while (d != _metrics.end()) { + delete (*d); + ++d; + } + _metrics.clear(); } void @@ -675,7 +671,7 @@ TempoMap::remove_tempo (const TempoSection& tempo, bool complete_operation) Glib::Threads::RWLock::WriterLock lm (lock); if ((removed = remove_tempo_locked (tempo))) { if (complete_operation) { - recompute_map (true); + recompute_map (_metrics); } } } @@ -690,11 +686,12 @@ TempoMap::remove_tempo_locked (const TempoSection& tempo) { Metrics::iterator i; - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { if (dynamic_cast (*i) != 0) { if (tempo.frame() == (*i)->frame()) { if ((*i)->movable()) { - metrics.erase (i); + delete (*i); + _metrics.erase (i); return true; } } @@ -713,7 +710,7 @@ TempoMap::remove_meter (const MeterSection& tempo, bool complete_operation) Glib::Threads::RWLock::WriterLock lm (lock); if ((removed = remove_meter_locked (tempo))) { if (complete_operation) { - recompute_map (true); + recompute_map (_metrics); } } } @@ -724,15 +721,29 @@ 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) { + 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()) { - metrics.erase (i); + delete (*i); + _metrics.erase (i); return true; } } @@ -746,23 +757,21 @@ void TempoMap::do_insert (MetricSection* section) { bool need_add = true; - /* we only allow new meters to be inserted on beat 1 of an existing * measure. */ MeterSection* m = 0; if ((m = dynamic_cast(section)) != 0) { - assert (m->bbt().ticks == 0); if ((m->bbt().beats != 1) || (m->bbt().ticks != 0)) { - pair corrected = make_pair (m->beat(), m->bbt()); + pair corrected = make_pair (m->pulse(), m->bbt()); corrected.second.beats = 1; corrected.second.ticks = 0; - corrected.first = bbt_to_beats_locked (corrected.second); + corrected.first = bbt_to_beats_locked (_metrics, corrected.second); warning << string_compose (_("Meter changes can only be positioned on the first beat of a bar. Moving from %1 to %2"), m->bbt(), corrected.second) << endmsg; - m->set_beat (corrected); + //m->set_pulse (corrected); } } @@ -773,16 +782,18 @@ TempoMap::do_insert (MetricSection* section) guaranteed that there is only one such match. */ - for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) { TempoSection* const tempo = dynamic_cast (*i); TempoSection* const insert_tempo = dynamic_cast (section); + MeterSection* const meter = dynamic_cast (*i); + MeterSection* const insert_meter = dynamic_cast (section); if (tempo && insert_tempo) { /* Tempo sections */ - PositionLockStyle const ipl = insert_tempo->position_lock_style(); - if ((ipl == MusicTime && tempo->beat() == insert_tempo->beat()) || (ipl == AudioTime && tempo->frame() == insert_tempo->frame())) { + bool const ipm = insert_tempo->position_lock_style() == MusicTime; + if ((ipm && tempo->pulse() == insert_tempo->pulse()) || (!ipm && tempo->frame() == insert_tempo->frame())) { if (!tempo->movable()) { @@ -792,21 +803,26 @@ TempoMap::do_insert (MetricSection* section) */ *(dynamic_cast(*i)) = *(dynamic_cast(insert_tempo)); + (*i)->set_position_lock_style (AudioTime); + TempoSection* t; + if ((t = dynamic_cast(*i)) != 0) { + t->set_type (insert_tempo->type()); + } need_add = false; } else { - metrics.erase (i); + delete (*i); + _metrics.erase (i); } break; } - } else if (!tempo && !insert_tempo) { + } else if (meter && insert_meter) { /* Meter Sections */ - MeterSection* const meter = dynamic_cast (*i); - MeterSection* const insert_meter = dynamic_cast (section); - PositionLockStyle const ipl = insert_meter->position_lock_style(); - if ((ipl == MusicTime && meter->beat() == insert_meter->beat()) || (ipl == AudioTime && meter->frame() == insert_meter->frame())) { + bool const ipm = insert_meter->position_lock_style() == MusicTime; + + if ((ipm && meter->beat() == insert_meter->beat()) || (!ipm && meter->frame() == insert_meter->frame())) { if (!meter->movable()) { @@ -816,10 +832,11 @@ TempoMap::do_insert (MetricSection* section) */ *(dynamic_cast(*i)) = *(dynamic_cast(insert_meter)); + (*i)->set_position_lock_style (AudioTime); need_add = false; } else { - metrics.erase (i); - + delete (*i); + _metrics.erase (i); } break; @@ -836,52 +853,51 @@ TempoMap::do_insert (MetricSection* section) if (need_add) { MeterSection* const insert_meter = dynamic_cast (section); TempoSection* const insert_tempo = dynamic_cast (section); - Metrics::iterator i; if (insert_meter) { - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { MeterSection* const meter = dynamic_cast (*i); if (meter) { - PositionLockStyle const ipl = insert_meter->position_lock_style(); - if ((ipl == MusicTime && meter->beat() > insert_meter->beat()) || (ipl == AudioTime && meter->frame() > insert_meter->frame())) { + bool const ipm = insert_meter->position_lock_style() == MusicTime; + if ((ipm && meter->beat() > insert_meter->beat()) || (!ipm && meter->frame() > insert_meter->frame())) { break; } } } } else if (insert_tempo) { - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { TempoSection* const tempo = dynamic_cast (*i); if (tempo) { - PositionLockStyle const ipl = insert_tempo->position_lock_style(); - if ((ipl == MusicTime && tempo->beat() > insert_tempo->beat()) || (ipl == AudioTime && tempo->frame() > insert_tempo->frame())) { + bool const ipm = insert_tempo->position_lock_style() == MusicTime; + if ((ipm && tempo->pulse() > insert_tempo->pulse()) || (!ipm && tempo->frame() > insert_tempo->frame())) { break; } } } } - metrics.insert (i, section); - //dump (std::cerr); + _metrics.insert (i, section); + //dump (_metrics, std::cout); } } void -TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const double& where, TempoSection::Type type) +TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const double& pulse, TempoSection::Type type) { { Glib::Threads::RWLock::WriterLock lm (lock); TempoSection& first (first_tempo()); - if (ts.beat() != first.beat()) { + if (ts.pulse() != first.pulse()) { remove_tempo_locked (ts); - add_tempo_locked (tempo, where, true, type); + add_tempo_locked (tempo, pulse, true, type); } else { first.set_type (type); { /* cannot move the first tempo section */ *static_cast(&first) = tempo; - recompute_map (false); + recompute_map (_metrics); } } } @@ -895,15 +911,17 @@ TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const frame { Glib::Threads::RWLock::WriterLock lm (lock); TempoSection& first (first_tempo()); - if (ts.beat() != first.beat()) { + if (ts.frame() != first.frame()) { remove_tempo_locked (ts); add_tempo_locked (tempo, frame, true, type); } else { first.set_type (type); + first.set_pulse (0.0); + first.set_position_lock_style (AudioTime); { /* cannot move the first tempo section */ *static_cast(&first) = tempo; - recompute_map (false); + recompute_map (_metrics); } } } @@ -911,279 +929,63 @@ TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const frame PropertyChanged (PropertyChange ()); } -Metrics -TempoMap::get_new_order (TempoSection* section, const Tempo& bpm, const framepos_t& frame) -{ - Metrics imaginary (metrics); - - TempoSection* prev_ts = 0; - TempoSection* t; - - /*set frame and sort */ - section->set_frame (frame); - MetricSectionFrameSorter fcmp; - imaginary.sort (fcmp); - - /* recompute tempos */ - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts) { - if (t == section) { - /* we have already set the frame - set the beat */ - prev_ts->set_c_func (prev_ts->compute_c_func (bpm.beats_per_minute(), frame, _frame_rate)); - section->set_beat (prev_ts->beat_at_tempo (bpm.beats_per_minute(), frame, _frame_rate)); - prev_ts = t; - continue; - } - if (t->position_lock_style() == MusicTime) { - prev_ts->set_c_func_from_tempo_and_beat (t->beats_per_minute(), t->beat(), _frame_rate); - t->set_frame (prev_ts->frame_at_tempo (t->beats_per_minute(), t->beat(), _frame_rate)); - } else { - prev_ts->set_c_func (prev_ts->compute_c_func (t->beats_per_minute(), t->frame(), _frame_rate)); - t->set_beat (prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame(), _frame_rate)); - } - } - prev_ts = t; - } - } - MetricSectionSorter cmp; - imaginary.sort (cmp); -/* - prev_ts = 0; - std::cerr << "dumping imaginary order ------" << std::endl;; - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts) { - - std::cerr << t->beats_per_minute() << " | " << t->beat() << " | " << t->frame() << std::endl; - std::cerr << prev_ts->beats_per_minute() << " | " << prev_ts->beat() << " | " << prev_ts->frame() << std::endl; - std::cerr << t->beats_per_minute() << " | " << prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame, _frame_rate) << " | " << prev_ts->tempo_at_beat(t->beat()) << " | " << prev_ts->frame_at_tempo(t->beats_per_minute(), t->beat(), _frame_rate) << std::endl; - std::cerr << " ------" << std::endl;; - - } - prev_ts = t; - } - } - std::cerr << "end dump ------"; -*/ - return imaginary; -} - -Metrics -TempoMap::get_new_order (TempoSection* section, const Tempo& bpm, const double& beat) -{ - Metrics imaginary (metrics); - - TempoSection* prev_ts = 0; - TempoSection* t; - - /*set beat and sort */ - section->set_beat (beat); - MetricSectionSorter cmp; - imaginary.sort (cmp); - - /* recompute tempo positions */ - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts) { - if (t == section) { - /* we've already set the beat - set the frame */ - prev_ts->set_c_func_from_tempo_and_beat (bpm.beats_per_minute(), beat, _frame_rate); - section->set_frame (prev_ts->frame_at_tempo (bpm.beats_per_minute(), beat, _frame_rate)); - prev_ts = t; - continue; - } - if (t->position_lock_style() == MusicTime) { - prev_ts->set_c_func_from_tempo_and_beat (t->beats_per_minute(), t->beat(), _frame_rate); - t->set_frame (prev_ts->frame_at_tempo (t->beats_per_minute(), t->beat(), _frame_rate)); - } else { - prev_ts->set_c_func (prev_ts->compute_c_func (t->beats_per_minute(), t->frame(), _frame_rate)); - t->set_beat (prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame(), _frame_rate)); - } - } - prev_ts = t; - } - } - - MetricSectionFrameSorter fcmp; - imaginary.sort (fcmp); -/* - prev_ts = 0; - std::cerr << "dumping imaginary order ------" << std::endl;; - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts) { - - std::cerr << t->beats_per_minute() << " | " << t->beat() << " | " << t->frame() << std::endl; - std::cerr << "prev : " << prev_ts->beats_per_minute() << " | " << prev_ts->beat() << " | " << prev_ts->frame() << std::endl; - std::cerr << "calculated : " << t->beats_per_minute() << " | " << prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame(), _frame_rate) << " | " << prev_ts->tempo_at_beat(t->beat()) << " | " << prev_ts->frame_at_tempo(t->beats_per_minute(), t->frame(), _frame_rate) << std::endl; - std::cerr << " ------" << std::endl;; - - } - prev_ts = t; - } - } - std::cerr << "end dump ------"; -*/ - return imaginary; -} - -Metrics -TempoMap::get_new_order(MeterSection* section, const Meter& mt, const framepos_t& frame, const double& beat) -{ - /* incomplete */ - Metrics imaginary (metrics); - - MeterSection* prev_ms = 0; - MeterSection* m; - MeterSection* our_section = 0; - framepos_t ret = 0; - MetricSectionSorter cmp; - - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((m = dynamic_cast (*i)) != 0) { - if (prev_ms) { - if (section->beat() == m->beat()) { - our_section = m; - continue; - } - if (beat < m->beat()){ - pair b_bbt = make_pair (beat, BBT_Time (1, 1, 0)); - our_section->set_beat (b_bbt); - our_section->set_frame (frame_at_beat_locked (beat)); - break; - } - - if (m->position_lock_style() == MusicTime) { - m->set_frame (frame_at_beat_locked (m->beat())); - } else { - pair b_bbt = make_pair (beat_at_frame_locked (m->frame()), BBT_Time (1, 1, 0)); - m->set_beat (b_bbt); - } - } - prev_ms = m; - } - } - /* now we do the whole thing again because audio-locked sections will have caused a re-order */ - prev_ms = 0; - metrics.sort (cmp); - - for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { - if ((m = dynamic_cast (*i)) != 0) { - if (prev_ms) { - if (section->beat() == m->beat()) { - continue; - } - if (beat < m->beat()){ - ret = frame_at_beat (beat); - section->set_frame (ret); - prev_ms = section; - break; - } - if (m->position_lock_style() == MusicTime) { - m->set_frame (frame_at_beat (m->beat())); - } else { - pair b_bbt = make_pair (beat_at_frame_locked (m->frame()), BBT_Time (1, 1, 0)); - m->set_beat (b_bbt); - } - } - prev_ms = m; - } - } - - if (!ret) { - pair b_bbt = make_pair (beat, BBT_Time (1, 1, 0)); - section->set_beat (b_bbt); - section->set_frame (frame_at_beat_locked (beat)); - } - return imaginary; -} - -/** -* This is for a gui that needs to know the frame of a beat if a tempo section were to be moved or altered. -* It actually reorders and partially recomputes tha ramps, so calling this commits you to replacing the section immediately. -* It will not emit a signal as you probably want to replace the tempo or do somethig else before that happens. -* @param section - the section you want to alter -* @param bpm - the new tempo -* @param beat - the beat where the altered tempo will fall -* @return returns - the position in frames where the new tempo section will lie. -*/ -framepos_t -TempoMap::compute_new_tempo_frame (TempoSection* section, const Tempo& bpm, const double& beat) -{ - Glib::Threads::RWLock::WriterLock lm (lock); - Metrics new_order = get_new_order (section, bpm, beat); - - return section->frame(); -} - -void -TempoMap::gui_move_tempo (TempoSection* ts, const Tempo& bpm, const framepos_t& frame) -{ - { - Glib::Threads::RWLock::WriterLock lm (lock); - Metrics new_order = get_new_order (ts, bpm, frame); - - metrics.clear(); - metrics = new_order; - recompute_map (false); - } - - MetricPositionChanged (); // Emit Signal -} - -void -TempoMap::gui_move_meter (MeterSection* ms, const Meter& mt, const framepos_t& frame, const double& beat_where) -{ - Glib::Threads::RWLock::WriterLock lm (lock); - Metrics imaginary = get_new_order (ms, mt, frame, beat_where); -} - -void -TempoMap::add_tempo (const Tempo& tempo, double where, ARDOUR::TempoSection::Type type) +TempoSection* +TempoMap::add_tempo (const Tempo& tempo, const double& pulse, ARDOUR::TempoSection::Type type) { + TempoSection* ts = 0; { Glib::Threads::RWLock::WriterLock lm (lock); - add_tempo_locked (tempo, where, true, type); + ts = add_tempo_locked (tempo, pulse, true, type); } PropertyChanged (PropertyChange ()); + + return ts; } -void -TempoMap::add_tempo (const Tempo& tempo, framepos_t frame, ARDOUR::TempoSection::Type type) +TempoSection* +TempoMap::add_tempo (const Tempo& tempo, const framepos_t& frame, ARDOUR::TempoSection::Type type) { + TempoSection* ts = 0; { Glib::Threads::RWLock::WriterLock lm (lock); - add_tempo_locked (tempo, frame, true, type); + ts = add_tempo_locked (tempo, frame, true, type); } PropertyChanged (PropertyChange ()); + + return ts; } -void -TempoMap::add_tempo_locked (const Tempo& tempo, double where, bool recompute, ARDOUR::TempoSection::Type type) +TempoSection* +TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, bool recompute, ARDOUR::TempoSection::Type type) { - TempoSection* ts = new TempoSection (where, tempo.beats_per_minute(), tempo.note_type(), type); + TempoSection* t = new TempoSection (pulse, tempo.beats_per_minute(), tempo.note_type(), type); - do_insert (ts); + do_insert (t); if (recompute) { - recompute_map (false); + solve_map (_metrics, t, t->pulse()); + recompute_meters (_metrics); } + + return t; } -void +TempoSection* TempoMap::add_tempo_locked (const Tempo& tempo, framepos_t frame, bool recompute, ARDOUR::TempoSection::Type type) { - TempoSection* ts = new TempoSection (frame, tempo.beats_per_minute(), tempo.note_type(), type); + TempoSection* t = new TempoSection (frame, tempo.beats_per_minute(), tempo.note_type(), type); - do_insert (ts); + do_insert (t); if (recompute) { - recompute_map (false); + solve_map (_metrics, t, t->frame()); + recompute_meters (_metrics); } + + return t; } void @@ -1191,15 +993,17 @@ TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const BBT_T { { Glib::Threads::RWLock::WriterLock lm (lock); - MeterSection& first (first_meter()); - if (ms.beat() != first.beat()) { + + if (ms.movable()) { remove_meter_locked (ms); - add_meter_locked (meter, bbt_to_beats_locked (where), where, true); + add_meter_locked (meter, bbt_to_beats_locked (_metrics, where), where, true); } else { + MeterSection& first (first_meter()); /* cannot move the first meter section */ *static_cast(&first) = meter; - recompute_map (true); + first.set_position_lock_style (AudioTime); } + recompute_map (_metrics); } PropertyChanged (PropertyChange ()); @@ -1210,59 +1014,77 @@ TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const frame { { Glib::Threads::RWLock::WriterLock lm (lock); - MeterSection& first (first_meter()); - if (ms.beat() != first.beat()) { + + const double beat = ms.beat(); + const BBT_Time bbt = ms.bbt(); + + if (ms.movable()) { remove_meter_locked (ms); - add_meter_locked (meter, frame, true); + add_meter_locked (meter, frame, beat, bbt, true); } else { + MeterSection& first (first_meter()); + TempoSection& first_t (first_tempo()); /* cannot move the first meter section */ *static_cast(&first) = meter; - recompute_map (true); + first.set_position_lock_style (AudioTime); + first.set_pulse (0.0); + first.set_frame (frame); + pair beat = make_pair (0.0, BBT_Time (1, 1, 0)); + first.set_beat (beat); + first_t.set_frame (first.frame()); + first_t.set_pulse (0.0); + first_t.set_position_lock_style (AudioTime); } + recompute_map (_metrics); } - PropertyChanged (PropertyChange ()); } -void -TempoMap::add_meter (const Meter& meter, double beat, BBT_Time where) +MeterSection* +TempoMap::add_meter (const Meter& meter, const double& beat, const BBT_Time& where) { + MeterSection* m = 0; { Glib::Threads::RWLock::WriterLock lm (lock); - add_meter_locked (meter, beat, where, true); + m = add_meter_locked (meter, beat, where, true); } #ifndef NDEBUG if (DEBUG_ENABLED(DEBUG::TempoMap)) { - dump (std::cerr); + dump (_metrics, std::cerr); } #endif PropertyChanged (PropertyChange ()); + + return m; } -void -TempoMap::add_meter (const Meter& meter, framepos_t frame) +MeterSection* +TempoMap::add_meter (const Meter& meter, const framepos_t& frame, const double& beat, const Timecode::BBT_Time& where) { + MeterSection* m = 0; { Glib::Threads::RWLock::WriterLock lm (lock); - add_meter_locked (meter, frame, true); + m = add_meter_locked (meter, frame, beat, where, true); } #ifndef NDEBUG if (DEBUG_ENABLED(DEBUG::TempoMap)) { - dump (std::cerr); + dump (_metrics, std::cerr); } #endif PropertyChanged (PropertyChange ()); + + return m; } -void -TempoMap::add_meter_locked (const Meter& meter, double beat, BBT_Time where, bool recompute) +MeterSection* +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 @@ -1271,33 +1093,37 @@ 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 MeterSection (beat, where, meter.divisions_per_bar(), meter.note_divisor())); + do_insert (new_meter); if (recompute) { - recompute_map (true); + solve_map (_metrics, new_meter, where); } + return new_meter; } -void -TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, bool recompute) +MeterSection* +TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, double beat, const Timecode::BBT_Time& where, bool recompute) { + /* 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); + } + + 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)); - /* MusicTime meters always start on 1|1|0. */ - do_insert (new MeterSection (frame, meter.divisions_per_bar(), meter.note_divisor())); + do_insert (new_meter); if (recompute) { - recompute_map (true); + solve_map (_metrics, new_meter, frame); } + return new_meter; } void @@ -1306,12 +1132,15 @@ TempoMap::change_initial_tempo (double beats_per_minute, double note_type) Tempo newtempo (beats_per_minute, note_type); TempoSection* t; - for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((t = dynamic_cast (*i)) != 0) { + if (!t->active()) { + continue; + } { Glib::Threads::RWLock::WriterLock lm (lock); *((Tempo*) t) = newtempo; - recompute_map (false); + recompute_map (_metrics); } PropertyChanged (PropertyChange ()); break; @@ -1331,7 +1160,7 @@ TempoMap::change_existing_tempo_at (framepos_t where, double beats_per_minute, d /* find the TempoSection immediately preceding "where" */ - for (first = 0, i = metrics.begin(), prev = 0; i != metrics.end(); ++i) { + for (first = 0, i = _metrics.begin(), prev = 0; i != _metrics.end(); ++i) { if ((*i)->frame() > where) { break; @@ -1340,6 +1169,9 @@ TempoMap::change_existing_tempo_at (framepos_t where, double beats_per_minute, d TempoSection* t; if ((t = dynamic_cast(*i)) != 0) { + if (!t->active()) { + continue; + } if (!first) { first = t; } @@ -1362,7 +1194,7 @@ TempoMap::change_existing_tempo_at (framepos_t where, double beats_per_minute, d Glib::Threads::RWLock::WriterLock lm (lock); /* cannot move the first tempo section */ *((Tempo*)prev) = newtempo; - recompute_map (false); + recompute_map (_metrics); } PropertyChanged (PropertyChange ()); @@ -1373,13 +1205,13 @@ TempoMap::first_meter () const { const MeterSection *m = 0; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((m = dynamic_cast (*i)) != 0) { return *m; } } - fatal << _("programming error: no tempo section in tempo map!") << endmsg; + fatal << _("programming error: no meter section in tempo map!") << endmsg; abort(); /*NOTREACHED*/ return *m; } @@ -1391,7 +1223,7 @@ TempoMap::first_meter () /* CALLER MUST HOLD LOCK */ - for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((m = dynamic_cast (*i)) != 0) { return *m; } @@ -1409,9 +1241,14 @@ TempoMap::first_tempo () const /* CALLER MUST HOLD LOCK */ - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((t = dynamic_cast (*i)) != 0) { - return *t; + if (!t->active()) { + continue; + } + if (!t->movable()) { + return *t; + } } } @@ -1425,9 +1262,14 @@ TempoMap::first_tempo () { TempoSection *t = 0; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((t = dynamic_cast (*i)) != 0) { - return *t; + if (!t->active()) { + continue; + } + if (!t->movable()) { + return *t; + } } } @@ -1436,71 +1278,124 @@ TempoMap::first_tempo () return *t; } void -TempoMap::recompute_tempos () +TempoMap::recompute_tempos (Metrics& metrics) { - TempoSection* prev_ts = 0; + TempoSection* prev_t = 0; for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { TempoSection* t; if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts) { + if (!t->active()) { + continue; + } + if (!t->movable()) { + if (!prev_t) { + t->set_pulse (0.0); + prev_t = t; + continue; + } + } + if (prev_t) { if (t->position_lock_style() == AudioTime) { - if (prev_ts->type() == TempoSection::Ramp) { - prev_ts->set_c_func (prev_ts->compute_c_func (t->beats_per_minute(), t->frame(), _frame_rate)); - //t->set_beat (prev_ts->beat_at_frame (t->frame(), _frame_rate)); - t->set_beat (prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame(), _frame_rate)); - } else { - prev_ts->set_c_func (0.0); - //t->set_beat (prev_ts->beat_at_frame (t->frame(), _frame_rate)); - t->set_beat (prev_ts->beat_at_tempo (t->beats_per_minute(), t->frame(), _frame_rate)); + prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate)); + if (!t->locked_to_meter()) { + t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate)); } + } else { - if (prev_ts->type() == TempoSection::Ramp) { - prev_ts->set_c_func_from_tempo_and_beat (t->beats_per_minute(), t->beat(), _frame_rate); - //t->set_frame (prev_ts->frame_at_beat (t->beat(), _frame_rate)); - t->set_frame (prev_ts->frame_at_tempo (t->beats_per_minute(), t->beat(), _frame_rate)); - } else { - prev_ts->set_c_func (0.0); - //t->set_frame (prev_ts->frame_at_beat (t->beat(), _frame_rate)); - t->set_frame (prev_ts->frame_at_tempo (t->beats_per_minute(), t->beat(), _frame_rate)); - } + prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate)); + t->set_frame (prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate)); + } } - prev_ts = t; + prev_t = t; } } + prev_t->set_c_func (0.0); } +/* 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 () +TempoMap::recompute_meters (Metrics& metrics) { MeterSection* meter = 0; + MeterSection* prev_m = 0; for (Metrics::const_iterator mi = metrics.begin(); mi != metrics.end(); ++mi) { - /* Now we have the tempos mapped to position, set meter positions.*/ if ((meter = dynamic_cast (*mi)) != 0) { if (meter->position_lock_style() == AudioTime) { - /* a frame based meter has to have a 1|1|0 bbt */ - pair pr; - BBT_Time where; + double pulse = 0.0; + pair b_bbt; + 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; + } + } + } - where.bars = 1; - where.beats = 1; - where.ticks = 0; + 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); - pr.first = beat_at_frame_locked (meter->frame()); - pr.second = where; - meter->set_beat (pr); } else { - meter->set_frame (frame_at_tick_locked (meter->tick())); + /* MusicTime */ + double pulse = 0.0; + pair new_beat; + 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 */ + 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()); + } + + meter->set_beat (new_beat); + meter->set_pulse (pulse); + meter->set_frame (frame_at_pulse_locked (metrics, pulse)); } + + prev_m = meter; } } } void -TempoMap::recompute_map (bool reassign_tempo_bbt, framepos_t end) +TempoMap::recompute_map (Metrics& metrics, framepos_t end) { /* CALLER MUST HOLD WRITE LOCK */ @@ -1521,11 +1416,10 @@ TempoMap::recompute_map (bool reassign_tempo_bbt, framepos_t end) return; } - recompute_tempos(); - recompute_meters(); + recompute_tempos (metrics); + recompute_meters (metrics); } - TempoMetric TempoMap::metric_at (framepos_t frame, Metrics::const_iterator* last) const { @@ -1539,7 +1433,7 @@ TempoMap::metric_at (framepos_t frame, Metrics::const_iterator* last) const now see if we can find better candidates. */ - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((*i)->frame() > frame) { break; @@ -1554,6 +1448,7 @@ TempoMap::metric_at (framepos_t frame, Metrics::const_iterator* last) const return m; } + /* XX meters only */ TempoMetric TempoMap::metric_at (BBT_Time bbt) const @@ -1568,7 +1463,7 @@ TempoMap::metric_at (BBT_Time bbt) const now see if we can find better candidates. */ - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { MeterSection* mw; if ((mw = dynamic_cast (*i)) != 0) { BBT_Time section_start (mw->bbt()); @@ -1584,100 +1479,261 @@ TempoMap::metric_at (BBT_Time bbt) const return m; } -void -TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt) +double +TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const +{ + MeterSection* prev_m = 0; + + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + if (prev_m && m->beat() > beat) { + break; + } + prev_m = m; + } + + } + double const ret = prev_m->pulse() + ((beat - prev_m->beat()) / prev_m->note_divisor()); + return ret; +} + +double +TempoMap::pulse_at_beat (const double& beat) const { Glib::Threads::RWLock::ReaderLock lm (lock); + return pulse_at_beat_locked (_metrics, beat); +} - if (frame < 0) { - bbt.bars = 1; - bbt.beats = 1; - bbt.ticks = 0; - warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg; - return; +double +TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const +{ + MeterSection* prev_m = 0; + + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + if (prev_m && m->pulse() > pulse) { + if (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > m->beat()) { + break; + } + } + prev_m = m; + } } - bbt = beats_to_bbt_locked (beat_at_frame_locked (frame)); + + double const ret = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(); + return ret; } double -TempoMap::bbt_to_beats (Timecode::BBT_Time bbt) +TempoMap::beat_at_pulse (const double& pulse) const { Glib::Threads::RWLock::ReaderLock lm (lock); - return bbt_to_beats_locked (bbt); + return beat_at_pulse_locked (_metrics, pulse); } +/* tempo section based */ double -TempoMap::bbt_to_beats_locked (Timecode::BBT_Time bbt) +TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const { - /* CALLER HOLDS READ LOCK */ + /* 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 (*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 +{ + /* HOLD THE READER LOCK */ + + const TempoSection* prev_t = 0; + + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + TempoSection* t; + + if ((t = dynamic_cast (*i)) != 0) { + if (!t->active()) { + continue; + } + if (prev_t && t->pulse() > pulse) { + return prev_t->frame_at_pulse (pulse, _frame_rate); + } + + prev_t = t; + } + } + /* must be treated as constant, irrespective of _type */ + double const pulses_in_section = pulse - prev_t->pulse(); + double const dtime = pulses_in_section * prev_t->frames_per_pulse (_frame_rate); + + framecnt_t const ret = (framecnt_t) floor (dtime) + prev_t->frame(); + + return ret; +} + +framecnt_t +TempoMap::frame_at_pulse (const double& pulse) const +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + return frame_at_pulse_locked (_metrics, pulse); +} - double accumulated_beats = 0.0; - double accumulated_bars = 0.0; - MeterSection* prev_ms = 0; +/* meter section based */ +double +TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const +{ + const TempoSection& ts = tempo_section_at_locked (metrics, frame); + MeterSection* prev_m = 0; + MeterSection* next_m = 0; for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { MeterSection* m; if ((m = dynamic_cast (*i)) != 0) { - double bars_to_m = 0.0; - if (prev_ms) { - bars_to_m = (m->beat() - prev_ms->beat()) / prev_ms->divisions_per_bar(); + if (prev_m && m->frame() > frame) { + next_m = m; + break; } - if ((bars_to_m + accumulated_bars) > (bbt.bars - 1)) { + 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 +TempoMap::beat_at_frame (const framecnt_t& frame) const +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + 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 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 (*i)) != 0) { + if (prev_m && m->beat() > beat) { break; } - if (prev_ms) { - accumulated_beats += m->beat() - prev_ms->beat(); - accumulated_bars += bars_to_m; + prev_m = m; + } + } + + return prev_t.frame_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse(), _frame_rate); +} + +framecnt_t +TempoMap::frame_at_beat (const double& beat) const +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + return frame_at_beat_locked (_metrics, beat); +} + +double +TempoMap::bbt_to_beats_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const +{ + /* CALLER HOLDS READ LOCK */ + + MeterSection* prev_m = 0; + + /* because audio-locked meters have 'fake' integral beats, + there is no pulse offset here. + */ + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + if (prev_m) { + const double bars_to_m = (m->beat() - prev_m->beat()) / prev_m->divisions_per_bar(); + if ((bars_to_m + (prev_m->bbt().bars - 1)) > (bbt.bars - 1)) { + break; + } } - prev_ms = m; + prev_m = m; } } - double const remaining_bars = (bbt.bars - 1) - accumulated_bars; - double const remaining_bars_in_beats = remaining_bars * prev_ms->divisions_per_bar(); - double const ret = remaining_bars_in_beats + accumulated_beats + (bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat); + const double remaining_bars = bbt.bars - prev_m->bbt().bars; + const double remaining_bars_in_beats = remaining_bars * prev_m->divisions_per_bar(); + const double ret = remaining_bars_in_beats + prev_m->beat() + (bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat); + return ret; } -Timecode::BBT_Time -TempoMap::beats_to_bbt (double beats) +double +TempoMap::bbt_to_beats (const Timecode::BBT_Time& bbt) { Glib::Threads::RWLock::ReaderLock lm (lock); - return beats_to_bbt_locked (beats); + return bbt_to_beats_locked (_metrics, bbt); } Timecode::BBT_Time -TempoMap::beats_to_bbt_locked (double beats) +TempoMap::beats_to_bbt_locked (const Metrics& metrics, const double& b) const { /* CALLER HOLDS READ LOCK */ - - MeterSection* prev_ms = 0; - uint32_t accumulated_bars = 0; + MeterSection* prev_m = 0; + const double beats = (b < 0.0) ? 0.0 : b; for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { MeterSection* m = 0; if ((m = dynamic_cast (*i)) != 0) { - - if (beats < m->beat()) { - /* this is the meter after the one our beat is on*/ - break; - } - - if (prev_ms) { - /* we need a whole number of bars. */ - accumulated_bars += ((m->beat() - prev_ms->beat()) + 1) / prev_ms->divisions_per_bar(); + if (prev_m) { + if (m->beat() > beats) { + /* this is the meter after the one our beat is on*/ + break; + } } - prev_ms = m; + prev_m = m; } } - double const beats_in_ms = beats - prev_ms->beat(); - uint32_t const bars_in_ms = (uint32_t) floor (beats_in_ms / prev_ms->divisions_per_bar()); - uint32_t const total_bars = bars_in_ms + accumulated_bars; - double const remaining_beats = beats_in_ms - (bars_in_ms * prev_ms->divisions_per_bar()); - double const remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat; + const double beats_in_ms = beats - prev_m->beat(); + const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar()); + const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1); + const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar()); + const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat; BBT_Time ret; @@ -1694,7 +1750,7 @@ TempoMap::beats_to_bbt_locked (double beats) ret.ticks -= BBT_Time::ticks_per_beat; } - if (ret.beats > prev_ms->divisions_per_bar()) { + if (ret.beats >= prev_m->divisions_per_bar() + 1) { ++ret.bars; ret.beats = 1; } @@ -1702,88 +1758,90 @@ TempoMap::beats_to_bbt_locked (double beats) return ret; } -double -TempoMap::tick_at_frame_locked (framecnt_t frame) const +Timecode::BBT_Time +TempoMap::beats_to_bbt (const double& beats) { - /* HOLD (at least) THE READER LOCK */ + Glib::Threads::RWLock::ReaderLock lm (lock); + return beats_to_bbt_locked (_metrics, beats); +} - TempoSection* prev_ts = 0; - double accumulated_ticks = 0.0; +Timecode::BBT_Time +TempoMap::pulse_to_bbt (const double& pulse) +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + MeterSection* prev_m = 0; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { - TempoSection* t; - if ((t = dynamic_cast (*i)) != 0) { - if ((prev_ts) && frame < t->frame()) { - /*the previous ts is the one containing the frame */ - return prev_ts->tick_at_frame (frame, _frame_rate); + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { + MeterSection* m = 0; + + if ((m = dynamic_cast (*i)) != 0) { + + if (prev_m) { + double const pulses_to_m = m->pulse() - prev_m->pulse(); + if (prev_m->pulse() + pulses_to_m > pulse) { + /* this is the meter after the one our beat is on*/ + break; + } } - accumulated_ticks = t->tick(); - prev_ts = t; + prev_m = m; } } - /* treated as constant for this ts */ - double const ticks_in_section = ((frame - prev_ts->frame()) / prev_ts->frames_per_beat (_frame_rate)) * Timecode::BBT_Time::ticks_per_beat; - - return ticks_in_section + accumulated_ticks; - -} + const double beats_in_ms = (pulse - prev_m->pulse()) * prev_m->note_divisor(); + const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar()); + const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1); + const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar()); + const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat; -framecnt_t -TempoMap::frame_at_tick_locked (double tick) const -{ - /* HOLD THE READER LOCK */ + BBT_Time ret; - const TempoSection* prev_ts = 0; - double accumulated_ticks = 0.0; + ret.ticks = (uint32_t) floor (remaining_ticks + 0.5); + ret.beats = (uint32_t) floor (remaining_beats); + ret.bars = total_bars; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { - TempoSection* t; - if ((t = dynamic_cast (*i)) != 0) { - if (prev_ts && tick < t->tick()) { - /* prev_ts is the one affecting us. */ - return prev_ts->frame_at_tick (tick, _frame_rate); - } + /* 0 0 0 to 1 1 0 mapping*/ + ++ret.bars; + ++ret.beats; - accumulated_ticks = t->tick(); - prev_ts = t; - } + if (ret.ticks >= BBT_Time::ticks_per_beat) { + ++ret.beats; + ret.ticks -= BBT_Time::ticks_per_beat; } - /* must be treated as constant, irrespective of _type */ - double const ticks_in_section = tick - accumulated_ticks; - double const dtime = (ticks_in_section / BBT_Time::ticks_per_beat) * prev_ts->frames_per_beat (_frame_rate); - framecnt_t const ret = ((framecnt_t) floor (dtime)) + prev_ts->frame(); + if (ret.beats >= prev_m->divisions_per_bar() + 1) { + ++ret.bars; + ret.beats = 1; + } return ret; } -double -TempoMap::beat_at_frame (framecnt_t frame) const -{ - Glib::Threads::RWLock::ReaderLock lm (lock); - return tick_at_frame_locked (frame) / BBT_Time::ticks_per_beat; -} - -double -TempoMap::beat_at_frame_locked (framecnt_t frame) const +void +TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt) { - return tick_at_frame_locked (frame) / BBT_Time::ticks_per_beat; -} -framecnt_t -TempoMap::frame_at_beat (double beat) const -{ + if (frame < 0) { + bbt.bars = 1; + bbt.beats = 1; + bbt.ticks = 0; + warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg; + return; + } Glib::Threads::RWLock::ReaderLock lm (lock); - return frame_at_tick_locked (beat * BBT_Time::ticks_per_beat); + const double beat = beat_at_frame_locked (_metrics, frame); + + bbt = beats_to_bbt_locked (_metrics, beat); } -framecnt_t -TempoMap::frame_at_beat_locked (double beat) const +/* meter section based */ +framepos_t +TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const { + /* HOLD THE READER LOCK */ - return frame_at_tick_locked (beat * BBT_Time::ticks_per_beat); + const framepos_t ret = frame_at_beat_locked (metrics, bbt_to_beats_locked (metrics, bbt)); + return ret; } framepos_t @@ -1799,52 +1857,1036 @@ TempoMap::frame_time (const BBT_Time& bbt) } Glib::Threads::RWLock::ReaderLock lm (lock); - return frame_time_locked (bbt);; + return frame_time_locked (_metrics, bbt); } -framepos_t -TempoMap::frame_time_locked (const BBT_Time& bbt) +bool +TempoMap::check_solved (const Metrics& metrics, bool by_frame) const { - /* HOLD THE READER LOCK */ + TempoSection* prev_t = 0; + MeterSection* prev_m = 0; - framepos_t const ret = frame_at_beat_locked (bbt_to_beats_locked (bbt)); + 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; + } + if (prev_t) { + if ((by_frame && t->frame() < prev_t->frame()) || (!by_frame && t->pulse() < prev_t->pulse())) { + return false; + } - return ret; + if (t->frame() == prev_t->frame()) { + return false; + } + + /* precision check ensures pulses and frames align.*/ + if (t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) { + 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; } +bool +TempoMap::set_active_tempos (const Metrics& metrics, const framepos_t& frame) +{ + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + TempoSection* t; + if ((t = dynamic_cast (*i)) != 0) { + if (!t->movable()) { + t->set_active (true); + continue; + } + if (t->movable() && t->active () && t->position_lock_style() == AudioTime && t->frame() < frame) { + t->set_active (false); + t->set_pulse (0.0); + } else if (t->movable() && t->position_lock_style() == AudioTime && t->frame() > frame) { + t->set_active (true); + } else if (t->movable() && t->position_lock_style() == AudioTime && t->frame() == frame) { + return false; + } + } + } + return true; +} -framecnt_t -TempoMap::bbt_duration_at (framepos_t pos, const BBT_Time& bbt, int dir) +bool +TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t& frame) { - Glib::Threads::RWLock::ReaderLock lm (lock); + TempoSection* prev_t = 0; + TempoSection* section_prev = 0; + framepos_t first_m_frame = 0; - Metrics::const_iterator i; - TempoSection* first = 0; - TempoSection* second = 0; + for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + if (!m->movable()) { + first_m_frame = m->frame(); + break; + } + } + } + if (section->movable() && frame <= first_m_frame) { + return false; + } - for (i = metrics.begin(); i != metrics.end(); ++i) { + section->set_active (true); + section->set_frame (frame); + + for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { TempoSection* t; + if ((t = dynamic_cast (*i)) != 0) { + if (!t->active()) { + continue; + } + if (prev_t) { + if (t == section) { + section_prev = prev_t; + continue; + } + if (t->position_lock_style() == MusicTime) { + prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate)); + t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate)); + } else { + prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), 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)); + if (!section->locked_to_meter()) { + section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate)); + } + } + + if (section->position_lock_style() == MusicTime) { + /* we're setting the frame */ + section->set_position_lock_style (AudioTime); + recompute_tempos (imaginary); + section->set_position_lock_style (MusicTime); + } else { + recompute_tempos (imaginary); + } + + if (check_solved (imaginary, true)) { + return true; + } + + MetricSectionFrameSorter fcmp; + imaginary.sort (fcmp); + if (section->position_lock_style() == MusicTime) { + /* we're setting the frame */ + section->set_position_lock_style (AudioTime); + recompute_tempos (imaginary); + section->set_position_lock_style (MusicTime); + } else { + recompute_tempos (imaginary); + } + + if (check_solved (imaginary, true)) { + return true; + } + + return false; +} + +bool +TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pulse) +{ + TempoSection* prev_t = 0; + TempoSection* section_prev = 0; + + section->set_pulse (pulse); + + for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { + TempoSection* t; if ((t = dynamic_cast (*i)) != 0) { + if (!t->active()) { + continue; + } + if (!t->movable()) { + t->set_pulse (0.0); + prev_t = t; + continue; + } + if (prev_t) { + if (t == section) { + section_prev = prev_t; + continue; + } + if (t->position_lock_style() == MusicTime) { + prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate)); + t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate)); + } else { + prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate)); + if (!t->locked_to_meter()) { + t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate)); + } + } + } + prev_t = t; + } + } + if (section_prev) { + section_prev->set_c_func (section_prev->compute_c_func_pulse (section->pulses_per_minute(), pulse, _frame_rate)); + section->set_frame (section_prev->frame_at_pulse (pulse, _frame_rate)); + } + + if (section->position_lock_style() == AudioTime) { + /* we're setting the pulse */ + section->set_position_lock_style (MusicTime); + recompute_tempos (imaginary); + section->set_position_lock_style (AudioTime); + } else { + recompute_tempos (imaginary); + } + + if (check_solved (imaginary, false)) { + return true; + } + + MetricSectionSorter cmp; + imaginary.sort (cmp); + if (section->position_lock_style() == AudioTime) { + /* we're setting the pulse */ + section->set_position_lock_style (MusicTime); + recompute_tempos (imaginary); + section->set_position_lock_style (AudioTime); + } else { + recompute_tempos (imaginary); + } + + if (check_solved (imaginary, false)) { + return true; + } + + return false; +} + +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 false; + } + + if (!section->movable()) { + /* lock the first tempo to our first meter */ + if (!set_active_tempos (imaginary, frame)) { + return false; + } + } + + /* 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){ + 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 (&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 { + /* 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 { + return false; + } + pair b_bbt = make_pair (0.0, BBT_Time (1, 1, 0)); + section->set_beat (b_bbt); + section->set_pulse (0.0); - if ((*i)->frame() > pos) { - second = t; + } break; } - first = t; + prev_m = m; + } + } + + MetricSectionFrameSorter fcmp; + imaginary.sort (fcmp); + if (section->position_lock_style() == MusicTime) { + /* we're setting the frame */ + section->set_position_lock_style (AudioTime); + recompute_meters (imaginary); + section->set_position_lock_style (MusicTime); + } else { + recompute_meters (imaginary); + } + + return true; +} + +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; + + for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + 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 (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; + } + } + } + + 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()); + } + } 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 = (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); + recompute_meters (imaginary); + section->set_position_lock_style (AudioTime); + } 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 (const Metrics& metrics, Metrics& copy, TempoSection* section) +{ + TempoSection* ret = 0; + + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + TempoSection* t; + MeterSection* m; + if ((t = dynamic_cast (*i)) != 0) { + if (t == section) { + ret = new TempoSection (*t); + copy.push_back (ret); + continue; + } + + TempoSection* cp = new TempoSection (*t); + copy.push_back (cp); + } + if ((m = dynamic_cast (*i)) != 0) { + 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; + } + MeterSection* cp = new MeterSection (*m); + copy.push_back (cp); + } + } + + return ret; +} + +bool +TempoMap::can_solve_bbt (TempoSection* ts, const BBT_Time& bbt) +{ + Metrics copy; + TempoSection* tempo_copy = 0; + + { + Glib::Threads::RWLock::ReaderLock lm (lock); + tempo_copy = copy_metrics_and_point (_metrics, copy, ts); + if (!tempo_copy) { + return false; + } + } + + 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()) { + delete (*d); + ++d; + } + + return ret; +} + +/** +* This is for a gui that needs to know the frame of a tempo section if it were to be moved to some bbt time, +* taking any possible reordering as a consequence of this into account. +* @param section - the section to be altered +* @param bpm - the new Tempo +* @param bbt - the bbt where the altered tempo will fall +* @return returns - the position in frames where the new tempo section will lie. +*/ +framepos_t +TempoMap::predict_tempo_frame (TempoSection* section, const BBT_Time& bbt) +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + Metrics future_map; + framepos_t ret = 0; + 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, tempo_copy, pulse_at_beat_locked (future_map, beat))) { + ret = tempo_copy->frame(); + } else { + ret = section->frame(); + } + + Metrics::const_iterator d = future_map.begin(); + while (d != future_map.end()) { + delete (*d); + ++d; + } + return ret; +} + +double +TempoMap::predict_tempo_pulse (TempoSection* section, const framepos_t& frame) +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + Metrics future_map; + double ret = 0.0; + TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, section); + + if (solve_map (future_map, tempo_copy, frame)) { + ret = tempo_copy->pulse(); + } else { + ret = section->pulse(); + } + + Metrics::const_iterator d = future_map.begin(); + while (d != future_map.end()) { + delete (*d); + ++d; + } + return ret; +} + +void +TempoMap::gui_move_tempo_frame (TempoSection* ts, const framepos_t& frame) +{ + Metrics future_map; + { + Glib::Threads::RWLock::WriterLock lm (lock); + 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::const_iterator d = future_map.begin(); + while (d != future_map.end()) { + delete (*d); + ++d; + } + + MetricPositionChanged (); // Emit Signal +} + +void +TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat) +{ + Metrics future_map; + { + Glib::Threads::RWLock::WriterLock lm (lock); + 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); + } + } + + 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 framepos_t& frame) +{ + Metrics future_map; + { + Glib::Threads::RWLock::WriterLock lm (lock); + 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 Timecode::BBT_Time& bbt) +{ + Metrics future_map; + { + Glib::Threads::RWLock::WriterLock lm (lock); + 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 +TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm) +{ + Metrics future_map; + bool can_solve = false; + { + Glib::Threads::RWLock::WriterLock lm (lock); + 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)) { + ts->set_beats_per_minute (bpm.beats_per_minute()); + recompute_map (_metrics); + can_solve = true; + } + } + + Metrics::const_iterator d = future_map.begin(); + while (d != future_map.end()) { + delete (*d); + ++d; + } + if (can_solve) { + MetricPositionChanged (); // Emit Signal + } + 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); } } - if (first && second) { - double const tick_at_time = first->tick_at_frame (pos, _frame_rate); - double const bbt_ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat); - double const time_at_bbt = first->frame_at_tick (tick_at_time + bbt_ticks, _frame_rate); - return time_at_bbt - pos; - } - double const ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat); + 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) +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + + const double tick_at_time = beat_at_frame_locked (_metrics, pos) * BBT_Time::ticks_per_beat; + const double bbt_ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat); + const double total_beats = (tick_at_time + bbt_ticks) / BBT_Time::ticks_per_beat; - return (framecnt_t) floor ((ticks / BBT_Time::ticks_per_beat) * first->frames_per_beat(_frame_rate)); + return frame_at_beat_locked (_metrics, total_beats); } framepos_t @@ -1863,10 +2905,9 @@ framepos_t TempoMap::round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir) { Glib::Threads::RWLock::ReaderLock lm (lock); - - uint32_t ticks = (uint32_t) floor (tick_at_frame_locked (fr) + 0.5); + uint32_t ticks = (uint32_t) floor (beat_at_frame_locked (_metrics, fr) * BBT_Time::ticks_per_beat); uint32_t beats = (uint32_t) floor (ticks / BBT_Time::ticks_per_beat); - uint32_t ticks_one_subdivisions_worth = (uint32_t)BBT_Time::ticks_per_beat / sub_num; + uint32_t ticks_one_subdivisions_worth = (uint32_t) BBT_Time::ticks_per_beat / sub_num; ticks -= beats * BBT_Time::ticks_per_beat; @@ -1950,7 +2991,116 @@ TempoMap::round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir) /* on the subdivision, do nothing */ } } - return frame_at_tick_locked ((beats * BBT_Time::ticks_per_beat) + ticks); + + const framepos_t ret_frame = frame_at_beat_locked (_metrics, beats + (ticks / BBT_Time::ticks_per_beat)); + + return ret_frame; +} + +void +TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num, RoundMode dir) +{ + if (sub_num == -1) { + 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; + } + + 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) { + ++when.beats; + while ((double) when.beats > bpb) { + ++when.bars; + when.beats -= (uint32_t) floor (bpb); + } + } + when.ticks = 0; + + return; + } + + const uint32_t ticks_one_subdivisions_worth = BBT_Time::ticks_per_beat / sub_num; + + if (dir > 0) { + /* round to next (or same iff dir == RoundUpMaybe) */ + + 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; + } + + if (when.ticks >= BBT_Time::ticks_per_beat) { + when.ticks -= BBT_Time::ticks_per_beat; + } + + } 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 -= 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 @@ -1958,9 +3108,8 @@ TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type) { Glib::Threads::RWLock::ReaderLock lm (lock); - double const beat_at_framepos = beat_at_frame_locked (frame); - - BBT_Time bbt (beats_to_bbt_locked (beat_at_framepos)); + const double beat_at_framepos = beat_at_frame_locked (_metrics, frame); + BBT_Time bbt (beats_to_bbt_locked (_metrics, beat_at_framepos)); switch (type) { case Bar: @@ -1968,22 +3117,22 @@ TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type) /* find bar previous to 'frame' */ bbt.beats = 1; bbt.ticks = 0; - return frame_time (bbt); + return frame_time_locked (_metrics, bbt); } else if (dir > 0) { /* find bar following 'frame' */ ++bbt.bars; bbt.beats = 1; bbt.ticks = 0; - return frame_time (bbt); + return frame_time_locked (_metrics, bbt); } else { /* true rounding: find nearest bar */ - framepos_t raw_ft = frame_time (bbt); + framepos_t raw_ft = frame_time_locked (_metrics, bbt); bbt.beats = 1; bbt.ticks = 0; - framepos_t prev_ft = frame_time (bbt); + framepos_t prev_ft = frame_time_locked (_metrics, bbt); ++bbt.bars; - framepos_t next_ft = frame_time (bbt); + framepos_t next_ft = frame_time_locked (_metrics, bbt); if ((raw_ft - prev_ft) > (next_ft - prev_ft) / 2) { return next_ft; @@ -1996,11 +3145,11 @@ TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type) case Beat: if (dir < 0) { - return frame_at_beat_locked (floor (beat_at_framepos)); + return frame_at_beat_locked (_metrics, floor (beat_at_framepos)); } else if (dir > 0) { - return frame_at_beat_locked (ceil (beat_at_framepos)); + return frame_at_beat_locked (_metrics, ceil (beat_at_framepos)); } else { - return frame_at_beat_locked (floor (beat_at_framepos + 0.5)); + return frame_at_beat_locked (_metrics, floor (beat_at_framepos + 0.5)); } break; } @@ -2013,16 +3162,18 @@ TempoMap::get_grid (vector& points, framepos_t lower, framepos_t upper) { Glib::Threads::RWLock::ReaderLock lm (lock); - uint32_t const upper_beat = (uint32_t) floor (beat_at_frame_locked (upper)); - uint32_t cnt = (uint32_t) ceil (beat_at_frame_locked (lower)); - - while (cnt <= upper_beat) { - framecnt_t const pos = frame_at_beat (cnt); - MeterSection const meter = meter_section_at (pos); - Tempo const tempo = tempo_at (pos); - BBT_Time const bbt = beats_to_bbt_locked ((double) cnt); - - points.push_back (BBTPoint (meter, tempo, pos, bbt.bars, bbt.beats)); + 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 (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 (_metrics, pos), pos, bbt.bars, bbt.beats, tempo.c_func())); ++cnt; } } @@ -2031,7 +3182,12 @@ const TempoSection& TempoMap::tempo_section_at (framepos_t frame) const { Glib::Threads::RWLock::ReaderLock lm (lock); + return tempo_section_at_locked (_metrics, frame); +} +const TempoSection& +TempoMap::tempo_section_at_locked (const Metrics& metrics, framepos_t frame) const +{ Metrics::const_iterator i; TempoSection* prev = 0; @@ -2039,8 +3195,10 @@ TempoMap::tempo_section_at (framepos_t frame) const TempoSection* t; if ((t = dynamic_cast (*i)) != 0) { - - if ((*i)->frame() > frame) { + if (!t->active()) { + continue; + } + if (prev && t->frame() > frame) { break; } @@ -2056,23 +3214,62 @@ TempoMap::tempo_section_at (framepos_t frame) const 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 (*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 (*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 */ double -TempoMap::frames_per_beat_at (framepos_t frame, framecnt_t sr) const +TempoMap::frames_per_beat_at (const framepos_t& frame, const framecnt_t& sr) const { Glib::Threads::RWLock::ReaderLock lm (lock); - const TempoSection* ts_at = &tempo_section_at (frame); + const TempoSection* ts_at = &tempo_section_at_locked (_metrics, frame); const TempoSection* ts_after = 0; Metrics::const_iterator i; - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { TempoSection* t; if ((t = dynamic_cast (*i)) != 0) { - + if (!t->active()) { + continue; + } if ((*i)->frame() > frame) { ts_after = t; break; @@ -2088,49 +3285,57 @@ TempoMap::frames_per_beat_at (framepos_t frame, framecnt_t sr) const } const Tempo -TempoMap::tempo_at (framepos_t frame) const +TempoMap::tempo_at_locked (const Metrics& metrics, const framepos_t& frame) const { - Glib::Threads::RWLock::ReaderLock lm (lock); - - TempoMetric m (metric_at (frame)); - TempoSection* prev_ts = 0; + TempoSection* prev_t = 0; Metrics::const_iterator i; - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { TempoSection* t; if ((t = dynamic_cast (*i)) != 0) { - if ((prev_ts) && t->frame() > frame) { - /* this is the one past frame */ - double const ret = prev_ts->tempo_at_frame (frame, _frame_rate); - Tempo const ret_tempo (ret, m.tempo().note_type ()); + if (!t->active()) { + continue; + } + if ((prev_t) && t->frame() > frame) { + /* t is the section past frame */ + const double ret_bpm = prev_t->tempo_at_frame (frame, _frame_rate) * prev_t->note_type(); + const Tempo ret_tempo (ret_bpm, prev_t->note_type()); return ret_tempo; } - prev_ts = t; + prev_t = t; } } - return m.tempo(); + const double ret = prev_t->beats_per_minute(); + const Tempo ret_tempo (ret, prev_t->note_type ()); + + return ret_tempo; } -const MeterSection& -TempoMap::meter_section_at (framepos_t frame) const +const Tempo +TempoMap::tempo_at (const framepos_t& frame) const { Glib::Threads::RWLock::ReaderLock lm (lock); + return tempo_at_locked (_metrics, frame); +} +const MeterSection& +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) { - MeterSection* t; + MeterSection* m; - if ((t = dynamic_cast (*i)) != 0) { + if ((m = dynamic_cast (*i)) != 0) { - if ((*i)->frame() > frame) { + if (prev && (*i)->frame() > frame) { break; } - prev = t; + prev = m; } } @@ -2142,6 +3347,39 @@ TempoMap::meter_section_at (framepos_t frame) const return *prev; } + +const MeterSection& +TempoMap::meter_section_at (framepos_t frame) const +{ + Glib::Threads::RWLock::ReaderLock lm (lock); + return meter_section_at_locked (_metrics, frame); +} + +const MeterSection& +TempoMap::meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const +{ + MeterSection* prev_m = 0; + + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + MeterSection* m; + if ((m = dynamic_cast (*i)) != 0) { + if (prev_m && m->beat() > beat) { + break; + } + prev_m = m; + } + + } + 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 { @@ -2149,6 +3387,68 @@ TempoMap::meter_at (framepos_t frame) const 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(*i)) != 0) { + if (!m->movable()) { + pair 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 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(*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 () { @@ -2157,7 +3457,7 @@ TempoMap::get_state () { Glib::Threads::RWLock::ReaderLock lm (lock); - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { root->add_child_nocopy ((*i)->get_state()); } } @@ -2173,9 +3473,8 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) XMLNodeList nlist; XMLNodeConstIterator niter; - Metrics old_metrics (metrics); - MeterSection* last_meter = 0; - metrics.clear(); + Metrics old_metrics (_metrics); + _metrics.clear(); nlist = node.children(); @@ -2186,18 +3485,12 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) try { TempoSection* ts = new TempoSection (*child); - metrics.push_back (ts); - - if (ts->bar_offset() < 0.0) { - if (last_meter) { - //ts->update_bar_offset_from_bbt (*last_meter); - } - } + _metrics.push_back (ts); } catch (failed_constructor& err){ error << _("Tempo map: could not set new state, restoring old one.") << endmsg; - metrics = old_metrics; + _metrics = old_metrics; break; } @@ -2205,13 +3498,12 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) try { MeterSection* ms = new MeterSection (*child); - metrics.push_back (ms); - last_meter = ms; + _metrics.push_back (ms); } catch (failed_constructor& err) { error << _("Tempo map: could not set new state, restoring old one.") << endmsg; - metrics = old_metrics; + _metrics = old_metrics; break; } } @@ -2219,47 +3511,42 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) if (niter == nlist.end()) { MetricSectionSorter cmp; - metrics.sort (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* prev_ms; - TempoSection* prev_ts; - if ((prev_ms = dynamic_cast(*i)) != 0) { - if (prev_ms->beat() < 0.0) { - /*XX we cannot possibly make this work??. */ - pair start = make_pair (((prev_ms->bbt().bars - 1) * 4.0) + (prev_ms->bbt().beats - 1) + (prev_ms->bbt().ticks / BBT_Time::ticks_per_beat), prev_ms->bbt()); - prev_ms->set_beat (start); - } - } else if ((prev_ts = dynamic_cast(*i)) != 0) { - if (prev_ts->beat() < 0.0) { - double const start = ((prev_ts->legacy_bbt().bars - 1) * 4.0) + (prev_ts->legacy_bbt().beats - 1) + (prev_ts->legacy_bbt().ticks / BBT_Time::ticks_per_beat); - prev_ts->set_beat (start); + /* check for legacy sessions where bbt was the base musical unit for tempo */ + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { + TempoSection* t; + if ((t = dynamic_cast (*i)) != 0) { + if (t->legacy_bbt().bars != 0) { + fix_legacy_session(); + break; } + break; } } + /* check for multiple tempo/meters at the same location, which ardour2 somehow allowed. */ - Metrics::iterator prev = metrics.end(); - for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) { - if (prev != metrics.end()) { + Metrics::iterator prev = _metrics.end(); + for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) { + if (prev != _metrics.end()) { MeterSection* ms; - MeterSection* prev_ms; + MeterSection* prev_m; TempoSection* ts; - TempoSection* prev_ts; - if ((prev_ms = dynamic_cast(*prev)) != 0 && (ms = dynamic_cast(*i)) != 0) { - if (prev_ms->beat() == ms->beat()) { - cerr << string_compose (_("Multiple meter definitions found at %1"), prev_ms->beat()) << endmsg; - error << string_compose (_("Multiple meter definitions found at %1"), prev_ms->beat()) << endmsg; + TempoSection* prev_t; + if ((prev_m = dynamic_cast(*prev)) != 0 && (ms = dynamic_cast(*i)) != 0) { + if (prev_m->pulse() == ms->pulse()) { + cerr << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg; + error << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg; return -1; } - } else if ((prev_ts = dynamic_cast(*prev)) != 0 && (ts = dynamic_cast(*i)) != 0) { - if (prev_ts->beat() == ts->beat()) { - cerr << string_compose (_("Multiple tempo definitions found at %1"), prev_ts->beat()) << endmsg; - error << string_compose (_("Multiple tempo definitions found at %1"), prev_ts->beat()) << endmsg; + } else if ((prev_t = dynamic_cast(*prev)) != 0 && (ts = dynamic_cast(*i)) != 0) { + if (prev_t->pulse() == ts->pulse()) { + cerr << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg; + error << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg; return -1; } } @@ -2267,7 +3554,7 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) prev = i; } - recompute_map (true, -1); + recompute_map (_metrics); } PropertyChanged (PropertyChange ()); @@ -2276,22 +3563,30 @@ TempoMap::set_state (const XMLNode& node, int /*version*/) } void -TempoMap::dump (std::ostream& o) const +TempoMap::dump (const Metrics& metrics, std::ostream& o) const { Glib::Threads::RWLock::ReaderLock lm (lock, Glib::Threads::TRY_LOCK); const MeterSection* m; const TempoSection* t; + const TempoSection* prev_t = 0; for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { if ((t = dynamic_cast(*i)) != 0) { - o << "Tempo @ " << *i << " (Bar-offset: " << t->bar_offset() << ") " << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->beat() << " frame= " << t->frame() << " (movable? " - << t->movable() << ')' << endl; + o << "Tempo @ " << *i << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->pulse() << " frame= " << t->frame() << " (movable? " + << t->movable() << ')' << " pos lock: " << enum_2_string (t->position_lock_style()) << std::endl; + o << "current : " << t->beats_per_minute() << " | " << t->pulse() << " | " << t->frame() << std::endl; + if (prev_t) { + o << "previous : " << prev_t->beats_per_minute() << " | " << prev_t->pulse() << " | " << prev_t->frame() << std::endl; + o << "calculated : " << prev_t->tempo_at_pulse (t->pulse()) * prev_t->note_type() << " | " << prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate) << " | " << prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate) << std::endl; + } + prev_t = t; } else if ((m = dynamic_cast(*i)) != 0) { o << "Meter @ " << *i << ' ' << m->divisions_per_bar() << '/' << m->note_divisor() << " at " << m->bbt() << " frame= " << m->frame() - << " (movable? " << m->movable() << ')' << endl; + << " pulse: " << m->pulse() << " beat : " << m->beat() << " pos lock: " << enum_2_string (m->position_lock_style()) << " (movable? " << m->movable() << ')' << endl; } } + o << "------" << std::endl; } int @@ -2300,7 +3595,7 @@ TempoMap::n_tempos() const Glib::Threads::RWLock::ReaderLock lm (lock); int cnt = 0; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if (dynamic_cast(*i) != 0) { cnt++; } @@ -2315,7 +3610,7 @@ TempoMap::n_meters() const Glib::Threads::RWLock::ReaderLock lm (lock); int cnt = 0; - for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if (dynamic_cast(*i) != 0) { cnt++; } @@ -2329,7 +3624,7 @@ TempoMap::insert_time (framepos_t where, framecnt_t amount) { { Glib::Threads::RWLock::WriterLock lm (lock); - for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) { + for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) { if ((*i)->frame() >= where && (*i)->movable ()) { (*i)->set_frame ((*i)->frame() + amount); } @@ -2357,7 +3652,7 @@ TempoMap::insert_time (framepos_t where, framecnt_t amount) bool first = true; MetricSection* prev = 0; - for (i = metrics.begin(); i != metrics.end(); ++i) { + for (i = _metrics.begin(); i != _metrics.end(); ++i) { BBT_Time bbt; //TempoMetric metric (*meter, *tempo); @@ -2366,10 +3661,13 @@ TempoMap::insert_time (framepos_t where, framecnt_t amount) if (prev) { if (ts){ if ((t = dynamic_cast(prev)) != 0) { - ts->set_beat (t->beat()); + if (!t->active()) { + continue; + } + ts->set_pulse (t->pulse()); } if ((m = dynamic_cast(prev)) != 0) { - ts->set_beat (m->beat()); + ts->set_pulse (m->pulse()); } ts->set_frame (prev->frame()); @@ -2378,10 +3676,16 @@ TempoMap::insert_time (framepos_t where, framecnt_t amount) if ((m = dynamic_cast(prev)) != 0) { pair start = make_pair (m->beat(), m->bbt()); ms->set_beat (start); + ms->set_pulse (m->pulse()); } if ((t = dynamic_cast(prev)) != 0) { - pair start = make_pair (t->beat(), beats_to_bbt_locked (t->beat())); + if (!t->active()) { + continue; + } + const double beat = beat_at_pulse_locked (_metrics, t->pulse()); + pair start = make_pair (beat, beats_to_bbt_locked (_metrics, beat)); ms->set_beat (start); + ms->set_pulse (t->pulse()); } ms->set_frame (prev->frame()); } @@ -2394,9 +3698,12 @@ TempoMap::insert_time (framepos_t where, framecnt_t amount) // cerr << bbt << endl; if ((t = dynamic_cast(*i)) != 0) { - t->set_beat (beat_at_frame_locked (m->frame())); + if (!t->active()) { + continue; + } + t->set_pulse (pulse_at_frame_locked (_metrics, m->frame())); tempo = t; - // cerr << "NEW TEMPO, frame = " << (*i)->frame() << " beat = " << (*i)->beat() <frame() >= where && (*i)->frame() < where+amount) { metric_kill_list.push_back(*i); TempoSection *lt = dynamic_cast (*i); @@ -2486,12 +3794,12 @@ TempoMap::remove_time (framepos_t where, framecnt_t amount) //remove all the remaining metrics for (std::list::iterator i = metric_kill_list.begin(); i != metric_kill_list.end(); ++i) { - metrics.remove(*i); + _metrics.remove(*i); moved = true; } if (moved) { - recompute_map (true); + recompute_map (_metrics); } } PropertyChanged (PropertyChange ()); @@ -2518,169 +3826,25 @@ TempoMap::framepos_minus_beats (framepos_t pos, Evoral::Beats beats) const framepos_t TempoMap::framepos_plus_bbt (framepos_t pos, BBT_Time op) const { - cerr << "framepos_plus_bbt - untested" << endl; Glib::Threads::RWLock::ReaderLock lm (lock); - Metrics::const_iterator i; - const MeterSection* meter; - const MeterSection* m; - const TempoSection* tempo; - const TempoSection* next_tempo = 0; - const TempoSection* t; - double frames_per_beat; - framepos_t effective_pos = max (pos, (framepos_t) 0); - - meter = &first_meter (); - tempo = &first_tempo (); - - assert (meter); - assert (tempo); - - /* find the starting metrics for tempo & meter */ - - for (i = metrics.begin(); i != metrics.end(); ++i) { - - if ((*i)->frame() > effective_pos) { - break; - } - - if ((t = dynamic_cast(*i)) != 0) { - tempo = t; - } else if ((m = dynamic_cast(*i)) != 0) { - meter = m; - } - } - - for (i = metrics.begin(); i != metrics.end(); ++i) { - if ((*i)->frame() > effective_pos) { - if ((t = dynamic_cast(*i)) != 0) { - next_tempo = t; - } - break; - } - } - - /* We now have: - - meter -> the Meter for "pos" - tempo -> the Tempo for "pos" - next_tempo -> the Tempo after "pos" or 0 - i -> for first new metric after "pos", possibly metrics.end() - */ - - /* now comes the complicated part. we have to add one beat a time, - checking for a new metric on every beat. - */ - - uint64_t bars = 0; - /* fpb is used for constant tempo */ - frames_per_beat = tempo->frames_per_beat (_frame_rate); - - while (op.bars) { - - bars++; - op.bars--; - - /* check if we need to use a new metric section: has adding frames moved us - to or after the start of the next metric section? in which case, use it. - */ - - if (i != metrics.end()) { - if ((*i)->frame() <= pos) { - - /* about to change tempo or meter, so add the - * number of frames for the bars we've just - * traversed before we change the - * frames_per_beat value. - */ - - if ((t = dynamic_cast(*i)) != 0) { - next_tempo = t; - } - - if (next_tempo) { - pos += tempo->frame_at_beat (bars * meter->divisions_per_bar(), _frame_rate); - } else { - pos += llrint (frames_per_beat * (bars * meter->divisions_per_bar())); - } - - bars = 0; - - if ((t = dynamic_cast(*i)) != 0) { - tempo = t; - } else if ((m = dynamic_cast(*i)) != 0) { - meter = m; - } - ++i; - frames_per_beat = tempo->frames_per_beat (_frame_rate); - } - } - - } - - if (next_tempo) { - pos += tempo->frame_at_beat (bars * meter->divisions_per_bar(), _frame_rate); - } else { - pos += llrint (frames_per_beat * (bars * meter->divisions_per_bar())); - } - - uint64_t beats = 0; - - while (op.beats) { - - /* given the current meter, have we gone past the end of the bar ? */ - - beats++; - op.beats--; - - /* check if we need to use a new metric section: has adding frames moved us - to or after the start of the next metric section? in which case, use it. - */ - - if (i != metrics.end()) { - if ((*i)->frame() <= pos) { - - /* about to change tempo or meter, so add the - * number of frames for the beats we've just - * traversed before we change the - * frames_per_beat value. - */ - - if ((t = dynamic_cast(*i)) != 0) { - next_tempo = t; - } - - if (next_tempo) { - pos += tempo->frame_at_beat (beats, _frame_rate); - } else { - pos += llrint (beats * frames_per_beat); - } - - beats = 0; - - if ((t = dynamic_cast(*i)) != 0) { - tempo = t; - } else if ((m = dynamic_cast(*i)) != 0) { - meter = m; - } - ++i; - frames_per_beat = tempo->frames_per_beat (_frame_rate); - } - } - } - - if (next_tempo) { - pos += tempo->frame_at_beat (beats, _frame_rate); - } else { - pos += llrint (beats * frames_per_beat); + BBT_Time pos_bbt = beats_to_bbt_locked (_metrics, beat_at_frame_locked (_metrics, pos)); + pos_bbt.ticks += op.ticks; + if (pos_bbt.ticks >= BBT_Time::ticks_per_beat) { + ++pos_bbt.beats; + pos_bbt.ticks -= BBT_Time::ticks_per_beat; } - - if (op.ticks) { - pos += tempo->frame_at_tick (op.ticks, _frame_rate); + pos_bbt.beats += op.beats; + /* the meter in effect will start on the 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_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; - return pos; - + return frame_time_locked (_metrics, pos_bbt); } /** Count the number of beats that are equivalent to distance when going forward, @@ -2689,7 +3853,7 @@ TempoMap::framepos_plus_bbt (framepos_t pos, BBT_Time op) const Evoral::Beats TempoMap::framewalk_to_beats (framepos_t pos, framecnt_t distance) const { - return Evoral::Beats(beat_at_frame (pos + distance) - beat_at_frame (pos)); + return Evoral::Beats (beat_at_frame (pos + distance) - beat_at_frame (pos)); } struct bbtcmp { @@ -2719,7 +3883,7 @@ operator<< (std::ostream& o, const MetricSection& section) { if ((ts = dynamic_cast (§ion)) != 0) { o << *((const Tempo*) ts); } else if ((ms = dynamic_cast (§ion)) != 0) { - //o << *((const Meter*) ms); + o << *((const Meter*) ms); } return o;