/* _default tempo is 4/4 qtr=120 */
Meter TempoMap::_default_meter (4.0, 4.0);
-Tempo TempoMap::_default_tempo (120.0);
+Tempo TempoMap::_default_tempo (120.0, 4.0);
framepos_t
MetricSection::frame_at_minute (const double& time) const
The return value IS NOT interpretable in terms of "beats".
*/
- return (60.0 * sr) / (tempo.beats_per_minute() * (_note_type/tempo.note_type()));
+ return (60.0 * sr) / (tempo.note_types_per_minute() * (_note_type/tempo.note_type()));
}
double
BBT_Time bbt;
double pulse;
uint32_t frame;
- double minute;
_legacy_bbt = BBT_Time (0, 0, 0);
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;
+ throw failed_constructor();
} else {
set_minute (minute_at_frame (frame));
}
}
- if ((prop = node.property ("minute")) != 0) {
- if (sscanf (prop->value().c_str(), "%lf", &minute) != 1) {
- error << _("TempoSection XML node has an illegal \"minute\" value") << endmsg;
- } else {
- set_minute (minute);
+ /* XX replace old beats-per-minute name with note-types-per-minute */
+ if ((prop = node.property ("beats-per-minute")) != 0) {
+ if (sscanf (prop->value().c_str(), "%lf", &_note_types_per_minute) != 1 || _note_types_per_minute < 0.0) {
+ error << _("TempoSection XML node has an illegal \"beats-per-minute\" value") << endmsg;
+ throw failed_constructor();
}
}
- if ((prop = node.property ("beats-per-minute")) == 0) {
- error << _("TempoSection XML node has no \"beats-per-minute\" property") << endmsg;
- throw failed_constructor();
- }
-
- if (sscanf (prop->value().c_str(), "%lf", &_beats_per_minute) != 1 || _beats_per_minute < 0.0) {
- error << _("TempoSection XML node has an illegal \"beats_per_minute\" value") << endmsg;
- throw failed_constructor();
- }
-
if ((prop = node.property ("note-type")) == 0) {
/* older session, make note type be quarter by default */
_note_type = 4.0;
root->add_property ("pulse", buf);
snprintf (buf, sizeof (buf), "%li", frame());
root->add_property ("frame", buf);
- snprintf (buf, sizeof (buf), "%lf", minute());
- root->add_property ("minute", buf);
- snprintf (buf, sizeof (buf), "%lf", _beats_per_minute);
+ snprintf (buf, sizeof (buf), "%lf", _note_types_per_minute);
root->add_property ("beats-per-minute", buf);
snprintf (buf, sizeof (buf), "%lf", _note_type);
root->add_property ("note-type", buf);
_type = type;
}
-/** returns the tempo in beats per minute at the zero-based (relative to session) minute.
+/** returns the Tempo at the session-relative minute.
*/
-double
+Tempo
TempoSection::tempo_at_minute (const double& m) const
{
if (_type == Constant || _c_func == 0.0) {
- return beats_per_minute();
+ return Tempo (note_types_per_minute(), note_type());
}
- return _tempo_at_time (m - minute());
+ return Tempo (_tempo_at_time (m - minute()), _note_type);
}
-/** returns the zero-based minute (relative to session)
- where the tempo in beats per minute occurs in this section.
- pulse p is only used for constant tempi.
- note that the tempo map may have multiple such values.
+/** returns the session relative minute where the supplied tempo in note types per minute occurs.
+ * @param ntpm the tempo in mote types per minute used to calculate the returned minute
+ * @param p the pulse used to calculate the returned minute for constant tempi
+ * @return the minute at the supplied tempo
+ *
+ * note that the note_type is currently ignored in this function. see below.
+ *
+*/
+
+/** if tempoA (120, 4.0) precedes tempoB (120, 8.0),
+ * there should be no ramp between the two even if we are ramped.
+ * in other words a ramp should only place a curve on note_types_per_minute.
+ * we should be able to use Tempo note type here, but the above
+ * complicates things a bit.
*/
double
-TempoSection::minute_at_tempo (const double& bpm, const double& p) const
+TempoSection::minute_at_ntpm (const double& ntpm, const double& p) const
{
if (_type == Constant || _c_func == 0.0) {
- return (((p - pulse()) * note_type()) / beats_per_minute()) + minute();
+ return ((p - pulse()) / pulses_per_minute()) + minute();
}
- return _time_at_tempo (bpm) + minute();
+ return _time_at_tempo (ntpm) + minute();
}
-/** returns the tempo in beats per minute at the zero-based (relative to session) pulse.
-*/
-double
+
+/** returns the Tempo at the supplied whole-note pulse.
+ */
+Tempo
TempoSection::tempo_at_pulse (const double& p) const
{
if (_type == Constant || _c_func == 0.0) {
- return beats_per_minute();
+ return Tempo (note_types_per_minute(), note_type());
}
- return _tempo_at_pulse (p - pulse());
+ return Tempo (_tempo_at_pulse (p - pulse()), _note_type);
}
-/** returns the zero-based pulse (relative to session)
- where the tempo in qn beats per minute occurs given frame f. frame f is only used for constant tempi.
- note that the session tempo map may have multiple beats at a given tempo.
+/** returns the whole-note pulse where a tempo in note types per minute occurs.
+ * constant tempi require minute m.
+ * @param ntpm the note types per minute value used to calculate the returned pulse
+ * @param m the minute used to calculate the returned pulse if the tempo is constant
+ * @return the whole-note pulse at the supplied tempo
+ *
+ * note that note_type is currently ignored in this function. see minute_at_tempo().
+ *
+ * for constant tempi, this is anaologous to pulse_at_minute().
*/
double
-TempoSection::pulse_at_tempo (const double& bpm, const double& m) const
+TempoSection::pulse_at_ntpm (const double& ntpm, const double& m) const
{
if (_type == Constant || _c_func == 0.0) {
- const double pulses = (((m - minute()) * beats_per_minute()) / note_type()) + pulse();
- return pulses;
+ return ((m - minute()) * pulses_per_minute()) + pulse();
}
- return _pulse_at_tempo (bpm) + pulse();
+ return _pulse_at_tempo (ntpm) + pulse();
}
-/** returns the zero-based pulse (relative to session origin)
- where the zero-based frame (relative to session)
- lies.
+/** returns the whole-note pulse at the supplied session-relative minute.
*/
double
-TempoSection::pulse_at_frame (const framepos_t& f) const
+TempoSection::pulse_at_minute (const double& m) const
{
- return pulse_at_minute (minute_at_frame (f));
+ if (_type == Constant || _c_func == 0.0) {
+ return ((m - minute()) * pulses_per_minute()) + pulse();
+ }
+
+ return _pulse_at_time (m - minute()) + pulse();
}
+/** returns the session-relative minute at the supplied whole-note pulse.
+*/
double
-TempoSection::pulse_at_minute (const double& m) const
+TempoSection::minute_at_pulse (const double& p) const
{
if (_type == Constant || _c_func == 0.0) {
- return (((m - minute()) * beats_per_minute()) / _note_type) + pulse();
+ return ((p - pulse()) / pulses_per_minute()) + minute();
}
- return _pulse_at_time (m - minute()) + pulse();
+ return _time_at_pulse (p - pulse()) + minute();
}
-/** returns the zero-based frame (relative to session start frame)
- where the zero-based pulse (relative to session start)
- falls.
+/** returns thw whole-note pulse at session frame position f.
+ * @param f the frame position.
+ * @return the position in whole-note pulses corresponding to f
+ *
+ * for use with musical units whose granularity is coarser than frames (e.g. ticks)
*/
-
-framepos_t
-TempoSection::frame_at_pulse (const double& p) const
+double
+TempoSection::pulse_at_frame (const framepos_t& f) const
{
- return frame_at_minute (minute_at_pulse (p));
+ if (_type == Constant || _c_func == 0.0) {
+ return (minute_at_frame (f - frame()) * pulses_per_minute()) + pulse();
+ }
+
+ return _pulse_at_time (minute_at_frame (f - frame())) + pulse();
}
-double
-TempoSection::minute_at_pulse (const double& p) const
+framepos_t
+TempoSection::frame_at_pulse (const double& p) const
{
if (_type == Constant || _c_func == 0.0) {
- return (((p - pulse()) * note_type()) / beats_per_minute()) + minute();
+ return frame_at_minute (((p - pulse()) / pulses_per_minute()) + minute());
}
- return _time_at_pulse (p - pulse()) + minute();
+ return frame_at_minute (_time_at_pulse (p - pulse()) + minute());
}
/*
*/
-/*
- compute this ramp's function constant using the end tempo (in qn beats per minute)
- and duration (pulses into global start) of some later tempo section.
+/** compute this ramp's function constant from some tempo-pulse point
+ * @param end_npm end tempo (in note types per minute)
+ * @param end_pulse duration (pulses into global start) of some other position.
+ * @return the calculated function constant
*/
double
-TempoSection::compute_c_func_pulse (const double& end_bpm, const double& end_pulse) const
+TempoSection::compute_c_func_pulse (const double& end_npm, const double& end_pulse) const
{
- double const log_tempo_ratio = log (end_bpm / beats_per_minute());
- return (beats_per_minute() * expm1 (log_tempo_ratio)) / ((end_pulse - pulse()) * _note_type);
+ double const log_tempo_ratio = log (end_npm / note_types_per_minute());
+ return (note_types_per_minute() * expm1 (log_tempo_ratio)) / ((end_pulse - pulse()) * _note_type);
}
-/* compute the function constant from some later tempo section, given tempo (quarter notes/min.) and distance (in frames) from session origin */
+/** compute the function constant from some tempo-time point.
+ * @param end_npm tempo (note types/min.)
+ * @param end_minute distance (in minutes) from session origin
+ * @return the calculated function constant
+*/
double
-TempoSection::compute_c_func_minute (const double& end_bpm, const double& end_minute) const
+TempoSection::compute_c_func_minute (const double& end_npm, const double& end_minute) const
{
- return c_func (end_bpm, end_minute - minute());
+ return c_func (end_npm, end_minute - minute());
}
/* position function */
double
-TempoSection::a_func (double end_bpm, double c_func) const
+TempoSection::a_func (double end_npm, double c_func) const
{
- return log (end_bpm / beats_per_minute()) / c_func;
+ return log (end_npm / note_types_per_minute()) / c_func;
}
/*function constant*/
double
-TempoSection::c_func (double end_bpm, double end_time) const
+TempoSection::c_func (double end_npm, double end_time) const
{
- return log (end_bpm / beats_per_minute()) / end_time;
+ return log (end_npm / note_types_per_minute()) / end_time;
}
-/* tempo in bpm at time in minutes */
+/* tempo in note types per minute at time in minutes */
double
TempoSection::_tempo_at_time (const double& time) const
{
- return exp (_c_func * time) * beats_per_minute();
+ return exp (_c_func * time) * note_types_per_minute();
}
-/* time in minutes at tempo in bpm */
+/* time in minutes at tempo in note types per minute */
double
-TempoSection::_time_at_tempo (const double& tempo) const
+TempoSection::_time_at_tempo (const double& npm) const
{
- return log (tempo / beats_per_minute()) / _c_func;
+ return log (npm / note_types_per_minute()) / _c_func;
}
-/* pulse at tempo in bpm */
+/* pulse at tempo in note types per minute */
double
-TempoSection::_pulse_at_tempo (const double& tempo) const
+TempoSection::_pulse_at_tempo (const double& npm) const
{
- return ((tempo - beats_per_minute()) / _c_func) / _note_type;
+ return ((npm - note_types_per_minute()) / _c_func) / _note_type;
}
-/* tempo in bpm at pulse */
+/* tempo in note types per minute at pulse */
double
TempoSection::_tempo_at_pulse (const double& pulse) const
{
- return (pulse * _note_type * _c_func) + beats_per_minute();
+ return (pulse * _note_type * _c_func) + note_types_per_minute();
}
/* pulse at time in minutes */
double
TempoSection::_pulse_at_time (const double& time) const
{
- return expm1 (_c_func * time) * (beats_per_minute() / (_c_func * _note_type));
+ return (expm1 (_c_func * time) * (note_types_per_minute() / _c_func)) / _note_type;
}
/* time in minutes at pulse */
double
TempoSection::_time_at_pulse (const double& pulse) const
{
- return log1p ((_c_func * pulse * _note_type) / beats_per_minute()) / _c_func;
+ return log1p ((_c_func * pulse * _note_type) / note_types_per_minute()) / _c_func;
}
/***********************************************************************/
double beat = 0.0;
framepos_t frame = 0;
pair<double, BBT_Time> start;
- double minute = 0.0;
if ((prop = node.property ("start")) != 0) {
if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
if ((prop = node.property ("frame")) != 0) {
if (sscanf (prop->value().c_str(), "%li", &frame) != 1) {
error << _("MeterSection XML node has an illegal \"frame\" value") << endmsg;
+ throw failed_constructor();
} else {
set_minute (minute_at_frame (frame));
}
}
- if ((prop = node.property ("minute")) != 0) {
- if (sscanf (prop->value().c_str(), "%lf", &minute) != 1) {
- error << _("MeterSection XML node has an illegal \"frame\" value") << endmsg;
- } else {
- set_minute (minute);
- }
- }
/* beats-per-bar is old; divisions-per-bar is new */
root->add_property ("note-type", buf);
snprintf (buf, sizeof (buf), "%li", frame());
root->add_property ("frame", buf);
- snprintf (buf, sizeof (buf), "%lf", minute());
- root->add_property ("minute", buf);
root->add_property ("lock-style", enum_2_string (position_lock_style()));
snprintf (buf, sizeof (buf), "%lf", _divisions_per_bar);
root->add_property ("divisions-per-bar", buf);
/*
Tempo Map Overview
- The Shaggs - Things I Wonder
- https://www.youtube.com/watch?v=9wQK6zMJOoQ
-
- Tempo is the rate of the musical pulse.
- Meter divides pulse into measures and beats.
-
- TempoSection - provides pulse in the form of beats_per_minute() - the number of quarter notes in one minute.
- Note that 'beats' in Tempo::beats_per_minute() are quarter notes (pulse based). In the rest of tempo map,
- 'beat' usually refers to accumulated BBT beats (pulse and meter based).
-
- MeterSecion - divides pulse into measures (via divisions_per_bar) and beats (via note_divisor).
+ Tempo determines the rate of musical pulse determined by its components
+ note types per minute - the rate per minute of the whole note divisor _note_type
+ note type - the division of whole notes (pulses) which occur at the rate of note types per minute.
+ Meter divides the musical pulse into measures and beats according to its components
+ divisions_per_bar
+ note_divisor
+
+ TempoSection - translates between time, musical pulse and tempo.
+ has a musical location in whole notes (pulses).
+ has a time location in minutes.
+ Note that 'beats' in Tempo::note_types_per_minute() are in fact note types per minute.
+ (In the rest of tempo map,'beat' usually refers to accumulated BBT beats (pulse and meter based).
+
+ MeterSection - translates between BBT, meter-based beat and musical pulse.
+ has a musical location in whole notes (pulses)
+ has a musical location in meter-based beats
+ has a musical location in BBT time
+ has a time location expressed in minutes.
- Both tempo and meter have a pulse position and a frame position.
- Meters also have a beat position, which is always 0.0 for the first one.
TempoSection and MeterSection may be locked to either audio or music (position lock style).
- The lock style determines the 'true' position of the section wich is used to calculate the other postion parameters of the section.
+ The lock style determines the location type to be kept as a reference when location is recalculated.
- 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.
+ The first tempo and meter are special. they must move together, and are locked to audio.
+ Audio locked tempi which lie before the first meter are made inactive.
- With tempo sections potentially being ramped, meters provide a way of mapping beats to whole pulses without
- referring to the tempo function(s) involved as the distance in whole pulses between a meter and a subsequent beat is
- sb->beat() - meter->beat() / meter->note_divisor().
- Because every meter falls on a known pulse, (derived from its bar), the rest is easy as the duration in pulses between
- two meters is of course
- (meater_b->bar - meter_a->bar) * meter_a->divisions_per_bar / meter_a->note_divisor.
+ Recomputing the map is the process where the 'missing' location types are calculated.
+ We construct the tempo map by first using the locked location type of each section
+ to determine non-locked location types (pulse or minute position).
+ We then use this map to find the pulse or minute position of each meter (again depending on lock style).
- Beat calculations are based on meter sections and all pulse and tempo calculations are based on tempo sections.
- Beat to frame conversion of course requires the use of meter and tempo.
-
- Remembering that ramped tempo sections interact, it is important to avoid referring to any other tempos when moving tempo sections,
- Here, beats (meters) are used to determine the new pulse (see predict_tempo_position())
-
- Recomputing the map is the process where the 'missing' position
- (tempo pulse or meter pulse & beat in the case of AudioTime, frame for MusicTime) is calculated.
- 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 tempo map (really just the tempos) to find the pulse or frame position of each meter (again depending on lock style).
-
- Having done this, we can now find any musical duration by selecting the tempo and meter covering the position (or tempo) in question
- and querying its appropriate meter/tempo.
+ Having done this, we can now traverse the Metrics list by pulse or minute
+ to query its relevant meter/tempo.
It is important to keep the _metrics in an order that makes sense.
Because ramped MusicTime and AudioTime tempos can interact with each other,
beat_at_frame (frame_at_beat (beat)) != beat due to the time quantization of frame_at_beat().
Doing the second one will result in a beat distance error of up to 0.5 audio samples.
- So instead work in pulses and/or beats and only use beat position to caclulate frame position (e.g. after tempo change).
- For audio-locked objects, use frame position to calculate beat position.
+ frames_between_quarter_notes () eliminats this effect when determining time duration
+ from Beats distance, or instead work in quarter-notes and/or beats and convert to frames last.
- The above pointless example would then do:
- beat_at_pulse (pulse_at_beat (beat)) to avoid rounding.
+ The above pointless example could instead do:
+ beat_at_quarter_note (quarter_note_at_beat (beat)) to avoid rounding.
+
+ The Shaggs - Things I Wonder
+ https://www.youtube.com/watch?v=9wQK6zMJOoQ
*/
struct MetricSectionSorter {
_frame_rate = fr;
BBT_Time start (1, 1, 0);
- TempoSection *t = new TempoSection (0.0, 0.0, _default_tempo.beats_per_minute(), _default_tempo.note_type(), TempoSection::Ramp, AudioTime, fr);
+ TempoSection *t = new TempoSection (0.0, 0.0, _default_tempo.note_types_per_minute(), _default_tempo.note_type(), TempoSection::Ramp, AudioTime, fr);
MeterSection *m = new MeterSection (0.0, 0.0, 0.0, start, _default_meter.divisions_per_bar(), _default_meter.note_divisor(), AudioTime, fr);
t->set_movable (false);
TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, double minute
, TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter)
{
- TempoSection* t = new TempoSection (pulse, minute, tempo.beats_per_minute(), tempo.note_type(), type, pls, _frame_rate);
+ TempoSection* t = new TempoSection (pulse, minute, tempo.note_types_per_minute(), tempo.note_type(), type, pls, _frame_rate);
t->set_locked_to_meter (locked_to_meter);
bool solved = false;
}
void
-TempoMap::change_initial_tempo (double beats_per_minute, double note_type)
+TempoMap::change_initial_tempo (double note_types_per_minute, double note_type)
{
- Tempo newtempo (beats_per_minute, note_type);
+ Tempo newtempo (note_types_per_minute, note_type);
TempoSection* t;
for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
}
void
-TempoMap::change_existing_tempo_at (framepos_t where, double beats_per_minute, double note_type)
+TempoMap::change_existing_tempo_at (framepos_t where, double note_types_per_minute, double note_type)
{
- Tempo newtempo (beats_per_minute, note_type);
+ Tempo newtempo (note_types_per_minute, note_type);
TempoSection* prev;
TempoSection* first;
}
if (prev_t) {
if (t->position_lock_style() == AudioTime) {
- prev_t->set_c_func (prev_t->compute_c_func_minute (t->beats_per_minute(), t->minute()));
+ prev_t->set_c_func (prev_t->compute_c_func_minute (t->note_types_per_minute(), t->minute()));
if (!t->locked_to_meter()) {
- t->set_pulse (prev_t->pulse_at_tempo (t->beats_per_minute(), t->minute()));
+ t->set_pulse (prev_t->pulse_at_ntpm (t->note_types_per_minute(), t->minute()));
}
} else {
- prev_t->set_c_func (prev_t->compute_c_func_pulse (t->beats_per_minute(), t->pulse()));
- t->set_minute (prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->note_types_per_minute(), t->pulse()));
+ t->set_minute (prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()));
}
}
prev_t = t;
}
}
+ assert (prev_t);
prev_t->set_c_func (0.0);
}
prev_m = m;
}
}
+ assert (prev_m);
TempoSection* t;
}
}
+ assert (prev_t);
return prev_t->minute_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse());
}
-/** Returns a Tempo corresponding to the supplied frame.
+/** Returns a Tempo corresponding to the supplied frame position.
* @param frame The audio frame.
* @return a Tempo according to the tempo map at the supplied frame.
*
}
if ((prev_t) && t->minute() > minute) {
/* t is the section past frame */
- const double ret_bpm = prev_t->tempo_at_minute (minute);
- const Tempo ret_tempo (ret_bpm, prev_t->note_type());
- return ret_tempo;
+ return prev_t->tempo_at_minute (minute);
}
prev_t = t;
}
}
- const double ret = prev_t->beats_per_minute();
- const Tempo ret_tempo (ret, prev_t->note_type ());
-
- return ret_tempo;
+ return Tempo (prev_t->note_types_per_minute(), prev_t->note_type());
}
/** returns the frame at which the supplied tempo occurs, or
TempoMap::minute_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const
{
TempoSection* prev_t = 0;
- const double tempo_bpm = tempo.beats_per_minute();
+ const double tempo_bpm = tempo.note_types_per_minute();
Metrics::const_iterator i;
continue;
}
- const double t_bpm = t->beats_per_minute();
+ const double t_bpm = t->note_types_per_minute();
if (t_bpm == tempo_bpm) {
return t->minute();
}
if (prev_t) {
- const double prev_t_bpm = prev_t->beats_per_minute();
+ const double prev_t_bpm = prev_t->note_types_per_minute();
if ((t_bpm > tempo_bpm && prev_t_bpm < tempo_bpm) || (t_bpm < tempo_bpm && prev_t_bpm > tempo_bpm)) {
- return prev_t->minute_at_tempo (tempo_bpm, prev_t->pulse());
+ return prev_t->minute_at_ntpm (prev_t->note_types_per_minute(), prev_t->pulse());
}
}
prev_t = t;
}
if ((prev_t) && t->pulse() > pulse) {
/* t is the section past frame */
- const double ret_bpm = prev_t->tempo_at_pulse (pulse);
- const Tempo ret_tempo (ret_bpm, prev_t->note_type());
- return ret_tempo;
+ return prev_t->tempo_at_pulse (pulse);
}
prev_t = t;
}
}
- const double ret = prev_t->beats_per_minute();
- const Tempo ret_tempo (ret, prev_t->note_type ());
-
- return ret_tempo;
+ return Tempo (prev_t->note_types_per_minute(), prev_t->note_type());
}
double
TempoMap::pulse_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const
{
TempoSection* prev_t = 0;
- const double tempo_bpm = tempo.beats_per_minute();
+ const double tempo_bpm = tempo.note_types_per_minute();
Metrics::const_iterator i;
continue;
}
- const double t_bpm = t->beats_per_minute();
+ const double t_bpm = t->note_types_per_minute();
if (t_bpm == tempo_bpm) {
return t->pulse();
}
if (prev_t) {
- const double prev_t_bpm = prev_t->beats_per_minute();
+ const double prev_t_bpm = prev_t->note_types_per_minute();
if ((t_bpm > tempo_bpm && prev_t_bpm < tempo_bpm) || (t_bpm < tempo_bpm && prev_t_bpm > tempo_bpm)) {
- return prev_t->pulse_at_tempo (tempo_bpm, prev_t->minute());
+ return prev_t->pulse_at_ntpm (prev_t->note_types_per_minute(), prev_t->minute());
}
}
prev_t = t;
}
}
- return prev_t->minute();
+ return prev_t->pulse();
}
-/** Returns a Tempo corresponding to the supplied BBT (meter-based) beat.
- * @param beat The BBT (meter-based) beat.
+/** Returns a Tempo corresponding to the supplied position in quarter-note beats.
+ * @param qn the position in quarter note beats.
+ * @return the Tempo at the supplied quarter-note.
*/
Tempo
-TempoMap::tempo_at_beat (const double& beat) const
+TempoMap::tempo_at_quarter_note (const double& qn) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- const MeterSection* prev_m = &meter_section_at_beat_locked (_metrics, beat);
- const TempoSection* prev_t = &tempo_section_at_beat_locked (_metrics, beat);
- return Tempo (prev_t->tempo_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse()), prev_t->note_type());
+ return tempo_at_pulse_locked (_metrics, qn / 4.0);
}
-/** Returns a BBT (meter-based) beat corresponding to the supplied Tempo.
- * @param tempo The tempo.
+/** Returns the position in quarter-note beats corresponding to the supplied Tempo.
+ * @param tempo the tempo.
+ * @return the position in quarter-note beats where the map bpm
+ * is equal to that of the Tempo. currently ignores note_type.
*/
double
-TempoMap::beat_at_tempo (const Tempo& tempo) const
+TempoMap::quarter_note_at_tempo (const Tempo& tempo) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- const double pulse = pulse_at_tempo_locked (_metrics, tempo);
- return beat_at_pulse_locked (_metrics, pulse);
+ return pulse_at_tempo_locked (_metrics, tempo) * 4.0;;
}
+
/** Returns the whole-note pulse corresponding to the supplied BBT (meter-based) beat.
+ * @param metrics the list of metric sections used to calculate the pulse.
* @param beat The BBT (meter-based) beat.
+ * @return the whole-note pulse at the supplied BBT (meter-based) beat.
*
* a pulse or whole note is the base musical position of a MetricSection.
* it is equivalent to four quarter notes.
*
*/
-double
-TempoMap::pulse_at_beat (const double& beat) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return pulse_at_beat_locked (_metrics, beat);
-}
-
double
TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
{
}
/** Returns the BBT (meter-based) beat corresponding to the supplied whole-note pulse .
+ * @param metrics the list of metric sections used to calculate the beat.
* @param pulse the whole-note pulse.
+ * @return the meter-based beat at the supplied whole-note pulse.
*
* a pulse or whole note is the base musical position of a MetricSection.
* it is equivalent to four quarter notes.
*/
-double
-TempoMap::beat_at_pulse (const double& pulse) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return beat_at_pulse_locked (_metrics, pulse);
-}
-
double
TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const
{
prev_m = m;
}
}
+ assert (prev_m);
double const ret = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat();
return ret;
}
-double
-TempoMap::pulse_at_frame (const framepos_t& frame) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
- return pulse_at_minute_locked (_metrics, minute_at_frame (frame));
-}
-
/* tempo section based */
double
TempoMap::pulse_at_minute_locked (const Metrics& metrics, const double& minute) const
}
/* treated as constant for this ts */
- const double pulses_in_section = ((minute - prev_t->minute()) * prev_t->beats_per_minute()) / prev_t->note_type();
+ const double pulses_in_section = ((minute - prev_t->minute()) * prev_t->note_types_per_minute()) / prev_t->note_type();
return pulses_in_section + prev_t->pulse();
}
-framepos_t
-TempoMap::frame_at_pulse (const double& pulse) const
-{
- Glib::Threads::RWLock::ReaderLock lm (lock);
-
- return frame_at_minute (minute_at_pulse_locked (_metrics, pulse));
-}
-
/* tempo section based */
double
TempoMap::minute_at_pulse_locked (const Metrics& metrics, const double& pulse) const
}
}
/* must be treated as constant, irrespective of _type */
- double const dtime = ((pulse - prev_t->pulse()) * prev_t->note_type()) / prev_t->beats_per_minute();
+ double const dtime = ((pulse - prev_t->pulse()) * prev_t->note_type()) / prev_t->note_types_per_minute();
return dtime + prev_t->minute();
}
/** Returns the BBT (meter-based) beat corresponding to the supplied BBT time.
* @param bbt The BBT time (meter-based).
+ * @return bbt The BBT beat (meter-based) at the supplied BBT time.
*
*/
double
/** Returns the BBT time corresponding to the supplied BBT (meter-based) beat.
* @param beat The BBT (meter-based) beat.
+ * @return The BBT time (meter-based) at the supplied meter-based beat.
*
*/
Timecode::BBT_Time
prev_m = m;
}
}
+ assert (prev_m);
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());
return ret;
}
-/** Returns the whole-note pulse corresponding to the supplied BBT time (meter-based).
+/** Returns the quarter-note beat corresponding to the supplied BBT time (meter-based).
* @param bbt The BBT time (meter-based).
+ * @return the quarter note beat at the supplied BBT time
+ *
+ * quarter-notes ignore meter and are based on pulse (the musical unit of MetricSection).
*
- * a pulse or whole note is the basic musical position of a MetricSection.
- * it is equivalent to four quarter notes.
* while the input uses meter, the output does not.
*/
double
-TempoMap::pulse_at_bbt (const Timecode::BBT_Time& bbt)
+TempoMap::quarter_note_at_bbt (const Timecode::BBT_Time& bbt)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return pulse_at_bbt_locked (_metrics, bbt);
+ return pulse_at_bbt_locked (_metrics, bbt) * 4.0;
}
double
-TempoMap::pulse_at_bbt_rt (const Timecode::BBT_Time& bbt)
+TempoMap::quarter_note_at_bbt_rt (const Timecode::BBT_Time& bbt)
{
- Glib::Threads::RWLock::ReaderLock lm (lock);
+ Glib::Threads::RWLock::ReaderLock lm (lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
- throw std::logic_error ("TempoMap::pulse_at_bbt_rt() could not lock tempo map");
+ throw std::logic_error ("TempoMap::quarter_note_at_bbt_rt() could not lock tempo map");
}
- return pulse_at_bbt_locked (_metrics, bbt);
+ return pulse_at_bbt_locked (_metrics, bbt) * 4.0;
}
double
return ret;
}
-/** Returns the BBT time (meter-based) corresponding to the supplied whole-note pulse.
- * @param pulse The whole-note pulse.
+
+/** Returns the BBT time corresponding to the supplied quarter-note beat.
+ * @param qn the quarter-note beat.
+ * @return The BBT time (meter-based) at the supplied meter-based beat.
+ *
+ * quarter-notes ignore meter and are based on pulse (the musical unit of MetricSection).
*
- * a pulse or whole note is the basic musical position of a MetricSection.
- * it is equivalent to four quarter notes.
- * while the input uses meter, the output does not.
*/
Timecode::BBT_Time
-TempoMap::bbt_at_pulse (const double& pulse)
+TempoMap::bbt_at_quarter_note (const double& qn)
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return bbt_at_pulse_locked (_metrics, pulse);
+ return bbt_at_pulse_locked (_metrics, qn / 4.0);
}
+/** Returns the BBT time (meter-based) corresponding to the supplied whole-note pulse position.
+ * @param metrics The list of metric sections used to determine the result.
+ * @param pulse The whole-note pulse.
+ * @return The BBT time at the supplied whole-note pulse.
+ *
+ * a pulse or whole note is the basic musical position of a MetricSection.
+ * it is equivalent to four quarter notes.
+ * while the output uses meter, the input does not.
+ */
Timecode::BBT_Time
TempoMap::bbt_at_pulse_locked (const Metrics& metrics, const double& pulse) const
{
}
}
+ assert (prev_m);
+
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);
/** Returns the BBT time corresponding to the supplied frame position.
* @param frame the position in audio samples.
+ * @return the BBT time at the frame position .
*
*/
BBT_Time
bbt.bars = 1;
bbt.beats = 1;
bbt.ticks = 0;
- warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg;
+ warning << string_compose (_("tempo map was asked for BBT time at frame %1\n"), frame) << endmsg;
return bbt;
}
Glib::Threads::RWLock::ReaderLock lm (lock);
return ret;
}
-/** Returns the frame corresponding to the supplied BBT time.
+/** Returns the frame position corresponding to the supplied BBT time.
* @param bbt the position in BBT time.
+ * @return the frame position at bbt.
*
*/
framepos_t
/**
* Returns the quarter-note beat position corresponding to the supplied frame.
*
- * @param frame The distance in frames relative to session 0 whose quarter note distance you would like.
+ * @param frame the position in frames.
* @return The quarter-note position of the supplied frame. Ignores meter.
*
- * Plugin APIs don't count ticks in the same way PROGRAM_NAME does.
- * We use ticks per beat whereas the rest of the world uses ticks per quarter note.
- * This is more or less the VST's ppqPos (a scalar you use to obtain tick position
- * in whatever ppqn you're using).
- *
*/
double
-TempoMap::quarter_note_at_frame (const framepos_t frame)
+TempoMap::quarter_note_at_frame (const framepos_t frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
}
double
-TempoMap::quarter_note_at_frame_rt (const framepos_t frame)
+TempoMap::quarter_note_at_frame_rt (const framepos_t frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock, Glib::Threads::TRY_LOCK);
}
/**
- * Returns the frame corresponding to the supplied quarter-note beat position.
+ * Returns the frame position corresponding to the supplied quarter-note beat.
*
- * @param quarter_note The quarter-note relative to session 0 whose frame position you would like.
- * @return The frame position of the supplied quarter-note. Ignores meter.
+ * @param quarter_note the quarter-note position.
+ * @return the frame position of the supplied quarter-note. Ignores meter.
*
*
*/
framepos_t
-TempoMap::frame_at_quarter_note (const double quarter_note)
+TempoMap::frame_at_quarter_note (const double quarter_note) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
/** Returns the quarter-note beats corresponding to the supplied BBT (meter-based) beat.
* @param beat The BBT (meter-based) beat.
+ * @return The quarter-note position of the supplied BBT (meter-based) beat.
*
- * a quarter-note is the musical unit of Evoral::Beats.
+ * a quarter-note may be compared with and assigned to Evoral::Beats.
*
*/
double
-TempoMap::quarter_note_at_beat (const double beat)
+TempoMap::quarter_note_at_beat (const double beat) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
/** Returns the BBT (meter-based) beat position corresponding to the supplied quarter-note beats.
* @param quarter_note The position in quarter-note beats.
+ * @return the BBT (meter-based) beat position of the supplied quarter-note beats.
*
* a quarter-note is the musical unit of Evoral::Beats.
*
*/
double
-TempoMap::beat_at_quarter_note (const double quarter_note)
+TempoMap::beat_at_quarter_note (const double quarter_note) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
return beat_at_pulse_locked (metrics, quarter_note / 4.0);
}
-/** Returns the distance in frames between two supplied quarter-note beats.
+/** Returns the duration in frames between two supplied quarter-note beat positions.
* @param start the first position in quarter-note beats.
* @param end the end position in quarter-note beats.
+ * @return the frame distance ober the quarter-note beats duration.
*
* use this rather than e.g.
* frame_at-quarter_note (end_beats) - frame_at_quarter_note (start_beats).
*
*/
framecnt_t
-TempoMap::frames_between_quarter_notes (const double start, const double end)
+TempoMap::frames_between_quarter_notes (const double start, const double end) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
}
double
-TempoMap::minutes_between_quarter_notes_locked (const Metrics& metrics, const double start, const double end)
+TempoMap::minutes_between_quarter_notes_locked (const Metrics& metrics, const double start, const double end) const
{
return minute_at_pulse_locked (metrics, end / 4.0) - minute_at_pulse_locked (metrics, start / 4.0);
}
+double
+TempoMap::quarter_notes_between_frames (const framecnt_t start, const framecnt_t end) const
+{
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+
+ return quarter_notes_between_frames_locked (_metrics, start, end);
+}
+
+double
+TempoMap::quarter_notes_between_frames_locked (const Metrics& metrics, const framecnt_t start, const framecnt_t end) const
+{
+ const TempoSection* prev_t = 0;
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+
+ if ((*i)->is_tempo()) {
+ t = static_cast<TempoSection*> (*i);
+ if (!t->active()) {
+ continue;
+ }
+ if (prev_t && t->frame() > start) {
+ break;
+ }
+ prev_t = t;
+ }
+ }
+ assert (prev_t);
+ const double start_qn = prev_t->pulse_at_frame (start);
+
+ for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+ TempoSection* t;
+
+ if ((*i)->is_tempo()) {
+ t = static_cast<TempoSection*> (*i);
+ if (!t->active()) {
+ continue;
+ }
+ if (prev_t && t->frame() > end) {
+ break;
+ }
+ prev_t = t;
+ }
+ }
+ const double end_qn = prev_t->pulse_at_frame (end);
+
+ return (end_qn - start_qn) * 4.0;
+}
+
bool
TempoMap::check_solved (const Metrics& metrics) const
{
}
/* precision check ensures tempo and frames align.*/
- if (t->frame() != frame_at_minute (prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()))) {
+ if (t->frame() != frame_at_minute (prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()))) {
if (!t->locked_to_meter()) {
return false;
}
continue;
}
if (t->position_lock_style() == MusicTime) {
- prev_t->set_c_func (prev_t->compute_c_func_pulse (t->beats_per_minute(), t->pulse()));
- t->set_minute (prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->note_types_per_minute(), t->pulse()));
+ t->set_minute (prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()));
} else {
- prev_t->set_c_func (prev_t->compute_c_func_minute (t->beats_per_minute(), t->minute()));
+ prev_t->set_c_func (prev_t->compute_c_func_minute (t->note_types_per_minute(), t->minute()));
if (!t->locked_to_meter()) {
- t->set_pulse (prev_t->pulse_at_tempo (t->beats_per_minute(), t->minute()));
+ t->set_pulse (prev_t->pulse_at_ntpm (t->note_types_per_minute(), t->minute()));
}
}
}
}
if (section_prev) {
- section_prev->set_c_func (section_prev->compute_c_func_minute (section->beats_per_minute(), minute));
+ section_prev->set_c_func (section_prev->compute_c_func_minute (section->note_types_per_minute(), minute));
if (!section->locked_to_meter()) {
- section->set_pulse (section_prev->pulse_at_tempo (section->beats_per_minute(), minute));
+ section->set_pulse (section_prev->pulse_at_ntpm (section->note_types_per_minute(), minute));
}
}
continue;
}
if (t->position_lock_style() == MusicTime) {
- prev_t->set_c_func (prev_t->compute_c_func_pulse (t->beats_per_minute(), t->pulse()));
- t->set_minute (prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()));
+ prev_t->set_c_func (prev_t->compute_c_func_pulse (t->note_types_per_minute(), t->pulse()));
+ t->set_minute (prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()));
} else {
- prev_t->set_c_func (prev_t->compute_c_func_minute (t->beats_per_minute(), t->minute()));
+ prev_t->set_c_func (prev_t->compute_c_func_minute (t->note_types_per_minute(), t->minute()));
if (!t->locked_to_meter()) {
- t->set_pulse (prev_t->pulse_at_tempo (t->beats_per_minute(), t->minute()));
+ t->set_pulse (prev_t->pulse_at_ntpm (t->note_types_per_minute(), t->minute()));
}
}
}
}
if (section_prev) {
- section_prev->set_c_func (section_prev->compute_c_func_pulse (section->beats_per_minute(), pulse));
- section->set_minute (section_prev->minute_at_tempo (section->beats_per_minute(), pulse));
+ section_prev->set_c_func (section_prev->compute_c_func_pulse (section->note_types_per_minute(), pulse));
+ section->set_minute (section_prev->minute_at_ntpm (section->note_types_per_minute(), pulse));
}
#if (0)
{
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());
+ tempo_copy->set_note_types_per_minute (bpm.note_types_per_minute());
recompute_tempi (future_map);
if (check_solved (future_map)) {
- ts->set_beats_per_minute (bpm.beats_per_minute());
+ ts->set_note_types_per_minute (bpm.note_types_per_minute());
recompute_map (_metrics);
can_solve = true;
}
}
void
-TempoMap::gui_dilate_tempo (TempoSection* ts, const framepos_t& frame, const framepos_t& end_frame, const double& pulse)
+TempoMap::gui_dilate_tempo (TempoSection* ts, const framepos_t& frame, const framepos_t& end_frame)
{
/*
Ts (future prev_t) Tnext
| |
| [drag^] |
|----------|----------
- e_f pulse(frame)
+ e_f qn_beats(frame)
*/
Metrics future_map;
TempoSection* prev_to_prev_t = 0;
const frameoffset_t fr_off = end_frame - frame;
- if (prev_t && prev_t->pulse() > 0.0) {
+ assert (prev_t);
+
+ if (prev_t->pulse() > 0.0) {
prev_to_prev_t = const_cast<TempoSection*>(&tempo_section_at_minute_locked (future_map, minute_at_frame (prev_t->frame() - 1)));
}
const frameoffset_t prev_t_frame_contribution = fr_off - (contribution * (double) fr_off);
- const double start_pulse = prev_t->pulse_at_frame (frame);
- const double end_pulse = prev_t->pulse_at_frame (end_frame);
+ const double start_pulse = prev_t->pulse_at_minute (minute_at_frame (frame));
+ const double end_pulse = prev_t->pulse_at_minute (minute_at_frame (end_frame));
double new_bpm;
if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
if (frame > prev_to_prev_t->frame() + min_dframe && (frame + prev_t_frame_contribution) > prev_to_prev_t->frame() + min_dframe) {
- new_bpm = prev_t->beats_per_minute() * ((frame - prev_to_prev_t->frame())
+ new_bpm = prev_t->note_types_per_minute() * ((frame - prev_to_prev_t->frame())
/ (double) ((frame + prev_t_frame_contribution) - prev_to_prev_t->frame()));
} else {
- new_bpm = prev_t->beats_per_minute();
+ new_bpm = prev_t->note_types_per_minute();
}
} else {
/* prev to prev is irrelevant */
if (start_pulse > prev_t->pulse() && end_pulse > prev_t->pulse()) {
- new_bpm = prev_t->beats_per_minute() * ((start_pulse - prev_t->pulse()) / (end_pulse - prev_t->pulse()));
+ new_bpm = prev_t->note_types_per_minute() * ((start_pulse - prev_t->pulse()) / (end_pulse - prev_t->pulse()));
} else {
- new_bpm = prev_t->beats_per_minute();
+ new_bpm = prev_t->note_types_per_minute();
}
}
} else {
if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
if (frame > prev_to_prev_t->frame() + min_dframe && end_frame > prev_to_prev_t->frame() + min_dframe) {
- new_bpm = prev_t->beats_per_minute() * ((frame - prev_to_prev_t->frame())
+ new_bpm = prev_t->note_types_per_minute() * ((frame - prev_to_prev_t->frame())
/ (double) ((end_frame) - prev_to_prev_t->frame()));
} else {
- new_bpm = prev_t->beats_per_minute();
+ new_bpm = prev_t->note_types_per_minute();
}
} else {
/* prev_to_prev_t is irrelevant */
if (frame > prev_t->frame() + min_dframe && end_frame > prev_t->frame() + min_dframe) {
- new_bpm = prev_t->beats_per_minute() * ((frame - prev_t->frame()) / (double) (end_frame - prev_t->frame()));
+ new_bpm = prev_t->note_types_per_minute() * ((frame - prev_t->frame()) / (double) (end_frame - prev_t->frame()));
} else {
- new_bpm = prev_t->beats_per_minute();
+ new_bpm = prev_t->note_types_per_minute();
}
}
}
double frame_ratio = 1.0;
double pulse_ratio = 1.0;
- const double pulse_pos = prev_t->frame_at_pulse (pulse);
+ const double pulse_pos = frame;
if (prev_to_prev_t) {
if (pulse_pos > prev_to_prev_t->frame() + min_dframe && (pulse_pos - fr_off) > prev_to_prev_t->frame() + min_dframe) {
}
pulse_ratio = (start_pulse / end_pulse);
}
- new_bpm = prev_t->beats_per_minute() * (pulse_ratio * frame_ratio);
+ new_bpm = prev_t->note_types_per_minute() * (pulse_ratio * frame_ratio);
}
/* don't clamp and proceed here.
return;
}
new_bpm = min (new_bpm, (double) 1000.0);
- prev_t->set_beats_per_minute (new_bpm);
+ prev_t->set_note_types_per_minute (new_bpm);
recompute_tempi (future_map);
recompute_meters (future_map);
if (check_solved (future_map)) {
- ts->set_beats_per_minute (new_bpm);
+ ts->set_note_types_per_minute (new_bpm);
recompute_tempi (_metrics);
recompute_meters (_metrics);
}
/** Returns the exact bbt-based beat corresponding to the bar, beat or quarter note subdivision nearest to
* the supplied frame, possibly returning a negative value.
+ *
* @param frame The session frame position.
* @param sub_num The subdivision to use when rounding the beat.
* A value of -1 indicates rounding to BBT bar. 1 indicates rounding to BBT beats.
* 0 indicates that the returned beat should not be rounded (equivalent to quarter_note_at_frame()).
* @return The beat position of the supplied frame.
*
+ * when working to a musical grid, the use of sub_nom indicates that
+ * the position should be interpreted musically.
+ *
+ * it effectively snaps to meter bars, meter beats or quarter note divisions
+ * (as per current gui convention) and returns a musical position independent of frame rate.
+ *
* If the supplied frame lies before the first meter, the return will be negative,
* in which case the returned beat uses the first meter (for BBT subdivisions) and
* the continuation of the tempo curve (backwards).
*
- * This function uses both tempo and meter.
+ * This function is sensitive to tempo and meter.
*/
double
-TempoMap::exact_beat_at_frame (const framepos_t& frame, const int32_t sub_num)
+TempoMap::exact_beat_at_frame (const framepos_t& frame, const int32_t sub_num) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
}
double
-TempoMap::exact_beat_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t divisions)
+TempoMap::exact_beat_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t divisions) const
{
return beat_at_pulse_locked (_metrics, exact_qn_at_frame_locked (metrics, frame, divisions) / 4.0);
}
/** Returns the exact quarter note corresponding to the bar, beat or quarter note subdivision nearest to
* the supplied frame, possibly returning a negative value.
- * Supplying a frame position with a non-zero sub_num is equivalent to supplying
- * a quarter-note musical position without frame rounding (see below)
*
* @param frame The session frame position.
* @param sub_num The subdivision to use when rounding the quarter note.
* 0 indicates that the returned quarter note should not be rounded (equivalent to quarter_note_at_frame()).
* @return The quarter note position of the supplied frame.
*
+ * When working to a musical grid, the use of sub_nom indicates that
+ * the frame position should be interpreted musically.
+ *
+ * it effectively snaps to meter bars, meter beats or quarter note divisions
+ * (as per current gui convention) and returns a musical position independent of frame rate.
+ *
* If the supplied frame lies before the first meter, the return will be negative,
* in which case the returned quarter note uses the first meter (for BBT subdivisions) and
* the continuation of the tempo curve (backwards).
*
- * This function uses both tempo and meter.
+ * This function is tempo-sensitive.
*/
double
-TempoMap::exact_qn_at_frame (const framepos_t& frame, const int32_t sub_num)
+TempoMap::exact_qn_at_frame (const framepos_t& frame, const int32_t sub_num) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
}
double
-TempoMap::exact_qn_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num)
+TempoMap::exact_qn_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num) const
{
double qn = quarter_note_at_minute_locked (metrics, minute_at_frame (frame));
Glib::Threads::RWLock::ReaderLock lm (lock);
BBT_Time pos_bbt = bbt_at_minute_locked (_metrics, minute_at_frame (pos));
- const framecnt_t offset = frame_at_minute (minute_at_bbt_locked (_metrics, pos_bbt));
+
const double divisions = meter_section_at_minute_locked (_metrics, minute_at_frame (pos)).divisions_per_bar();
if (dir > 0) {
pos_bbt.bars += 1;
pos_bbt.beats -= divisions;
}
+ const framecnt_t pos_bbt_frame = frame_at_minute (minute_at_bbt_locked (_metrics, pos_bbt));
+
+ return pos_bbt_frame - pos;
- return frame_at_minute (minute_at_bbt_locked (_metrics, pos_bbt)) - offset;
} else {
- pos_bbt.bars -= bbt.bars;
+
+ if (pos_bbt.bars <= bbt.bars) {
+ pos_bbt.bars = 1;
+ } else {
+ pos_bbt.bars -= bbt.bars;
+ }
if (pos_bbt.ticks < bbt.ticks) {
- if (pos_bbt.beats == 1) {
- pos_bbt.bars--;
- pos_bbt.beats = divisions;
+ if (pos_bbt.bars > 1) {
+ if (pos_bbt.beats == 1) {
+ pos_bbt.bars--;
+ pos_bbt.beats = divisions;
+ } else {
+ pos_bbt.beats--;
+ }
+ pos_bbt.ticks = BBT_Time::ticks_per_beat - (bbt.ticks - pos_bbt.ticks);
} else {
- pos_bbt.beats--;
+ pos_bbt.beats = 1;
+ pos_bbt.ticks = 0;
}
- pos_bbt.ticks = BBT_Time::ticks_per_beat - (bbt.ticks - pos_bbt.ticks);
} else {
pos_bbt.ticks -= bbt.ticks;
}
if (pos_bbt.beats <= bbt.beats) {
- pos_bbt.bars--;
- pos_bbt.beats = divisions - (bbt.beats - pos_bbt.beats);
+ if (pos_bbt.bars > 1) {
+ pos_bbt.bars--;
+ pos_bbt.beats = divisions - (bbt.beats - pos_bbt.beats);
+ } else {
+ pos_bbt.beats = 1;
+ }
} else {
pos_bbt.beats -= bbt.beats;
}
- return offset - frame_at_minute (minute_at_bbt_locked (_metrics, pos_bbt));
+ return pos - frame_at_minute (minute_at_bbt_locked (_metrics, pos_bbt));
}
return 0;
do that stuff based on the beat_at_frame and frame_at_beat api
*/
double
-TempoMap::frames_per_beat_at (const framepos_t& frame, const framecnt_t& sr) const
+TempoMap::frames_per_quarter_note_at (const framepos_t& frame, const framecnt_t& sr) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
ts_at = t;
}
}
+ assert (ts_at);
if (ts_after) {
- return (60.0 * _frame_rate) / ts_at->tempo_at_minute (minute_at_frame (frame));
+ return (60.0 * _frame_rate) / ts_at->tempo_at_minute (minute_at_frame (frame)).quarter_notes_per_minute();
}
/* must be treated as constant tempo */
- return ts_at->frames_per_beat (_frame_rate);
+ return ts_at->frames_per_quarter_note (_frame_rate);
}
const MeterSection&
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
if ((t = dynamic_cast<const TempoSection*>(*i)) != 0) {
- o << "Tempo @ " << *i << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type()
+ o << "Tempo @ " << *i << t->note_types_per_minute() << " BPM (pulse = 1/" << t->note_type()
<< " type= " << enum_2_string (t->type()) << ") " << " at pulse= " << t->pulse()
<< " minute= " << t->minute() << " frame= " << t->frame() << " (movable? " << t->movable() << ')'
<< " pos lock: " << enum_2_string (t->position_lock_style()) << std::endl;
if (prev_t) {
- o << std::setprecision (17) << " current : " << t->beats_per_minute()
+ o << std::setprecision (17) << " current : " << t->note_types_per_minute()
<< " | " << t->pulse() << " | " << t->frame() << " | " << t->minute() << std::endl;
- o << " previous : " << prev_t->beats_per_minute()
+ o << " previous : " << prev_t->note_types_per_minute()
<< " | " << prev_t->pulse() << " | " << prev_t->frame() << " | " << prev_t->minute() << std::endl;
o << " calculated : " << prev_t->tempo_at_pulse (t->pulse())
- << " | " << prev_t->pulse_at_tempo (t->beats_per_minute(), t->minute())
- << " | " << frame_at_minute (prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()))
- << " | " << prev_t->minute_at_tempo (t->beats_per_minute(), t->pulse()) << std::endl;
+ << " | " << prev_t->pulse_at_ntpm (t->note_types_per_minute(), t->minute())
+ << " | " << frame_at_minute (prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()))
+ << " | " << prev_t->minute_at_ntpm (t->note_types_per_minute(), t->pulse()) << std::endl;
}
prev_t = t;
} else if ((m = dynamic_cast<const MeterSection*>(*i)) != 0) {
* pos can be -ve, if required.
*/
framepos_t
-TempoMap::framepos_plus_qn (framepos_t frame, Evoral::Beats quarter_note) const
+TempoMap::framepos_plus_qn (framepos_t frame, Evoral::Beats beats) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
+ const double frame_qn = quarter_notes_between_frames_locked (_metrics, 0, frame);
- return frame_at_minute (minute_at_quarter_note_locked (_metrics, quarter_note_at_minute_locked (_metrics, minute_at_frame (frame)) + quarter_note.to_double()));
+ return frame_at_minute (minute_at_quarter_note_locked (_metrics, frame_qn + beats.to_double()));
}
framepos_t
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return Evoral::Beats (quarter_note_at_minute_locked (_metrics, minute_at_frame (pos + distance)) - quarter_note_at_minute_locked (_metrics, minute_at_frame (pos)));
+ return Evoral::Beats (quarter_notes_between_frames_locked (_metrics, pos, pos + distance));
}
struct bbtcmp {
std::ostream&
operator<< (std::ostream& o, const Tempo& t) {
- return o << t.beats_per_minute() << " 1/" << t.note_type() << "'s per minute";
+ return o << t.note_types_per_minute() << " 1/" << t.note_type() << "'s per minute";
}
std::ostream&