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)
{
const XMLProperty *prop;
LocaleGuard lg;
set_active (string_is_affirmative (prop->value()));
}
- if ((prop = node.property ("bar-offset")) == 0) {
- _bar_offset = -1.0;
- } 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();
- }
- }
-
if ((prop = node.property ("tempo-type")) == 0) {
_type = Constant;
} else {
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");
return *root;
}
-void
-
-TempoSection::update_bar_offset_from_bbt (const Meter& m)
-{
- _bar_offset = (pulse() * 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, pulse(), m.divisions_per_bar()));
-}
-
void
TempoSection::set_type (Type type)
{
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 / pulses_per_minute());
- return pulses_per_minute() * (exp (log_tempo_ratio) - 1) / (end_pulse - pulse());
+ return pulses_per_minute() * (expm1 (log_tempo_ratio)) / (end_pulse - pulse());
}
/* compute the function constant from some later tempo section, given tempo (whole pulses/min.) and distance (in frames) from session origin */
double
TempoSection::pulse_at_time (const double& time) const
{
- return ((exp (_c_func * time)) - 1) * (pulses_per_minute() / _c_func);
+ return expm1 (_c_func * time) * (pulses_per_minute() / _c_func);
}
/* time in minutes at pulse */
double
TempoSection::time_at_pulse (const double& pulse) const
{
- return log (((_c_func * pulse) / pulses_per_minute()) + 1) / _c_func;
-}
-
-
-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 = pulse();
-
- 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_pulse (new_beat);
+ return log1p ((_c_func * pulse) / pulses_per_minute()) / _c_func;
}
/***********************************************************************/
}
/***********************************************************************/
+/*
+ Tempo Map Overview
+
+ Tempos can be thought of as a source of the musical pulse.
+
+ 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->pulse() < b->pulse();
{
Glib::Threads::RWLock::WriterLock lm (lock);
MeterSection& first (first_meter());
- TempoSection& first_t (first_tempo());
- const PositionLockStyle pl = ms.position_lock_style();
- if (ms.pulse() != first.pulse()) {
+ if (ms.movable()) {
remove_meter_locked (ms);
- add_meter_locked (meter, pulse_at_beat_locked (_metrics, bbt_to_beats_locked (_metrics, where)), where, true);
+ add_meter_locked (meter, bbt_to_beats_locked (_metrics, where), where, true);
} else {
+ const PositionLockStyle pl = ms.position_lock_style();
/* cannot move the first meter section */
*static_cast<Meter*>(&first) = meter;
first.set_position_lock_style (pl);
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
- MeterSection& first (first_meter());
- TempoSection& first_t (first_tempo());
- const PositionLockStyle pl = ms.position_lock_style();
- if (ms.pulse() != first.pulse()) {
+ 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<Meter*>(&first) = meter;
first.set_position_lock_style (AudioTime);
first.set_frame (frame);
pair<double, BBT_Time> beat = make_pair (0.0, BBT_Time (1, 1, 0));
first.set_beat (beat);
- recompute_meters (_metrics);
first_t.set_frame (first.frame());
first_t.set_pulse (0.0);
first_t.set_position_lock_style (AudioTime);
}
void
-TempoMap::add_meter (const Meter& meter, const framepos_t& frame)
+TempoMap::add_meter (const Meter& meter, const framepos_t& frame, const double& beat, const Timecode::BBT_Time& where)
{
{
Glib::Threads::RWLock::WriterLock lm (lock);
- add_meter_locked (meter, frame, true);
+ add_meter_locked (meter, frame, beat, where, true);
}
}
void
-TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, bool recompute)
+TempoMap::add_meter_locked (const Meter& meter, framepos_t frame, double beat, Timecode::BBT_Time where, bool recompute)
{
- MeterSection* new_meter = new MeterSection (frame, 0.0, meter.divisions_per_bar(), meter.note_divisor());
+ MeterSection* new_meter = new MeterSection (frame, beat, where, meter.divisions_per_bar(), meter.note_divisor());
+
+ double pulse = pulse_at_frame_locked (_metrics, frame);
+ new_meter->set_pulse (pulse);
do_insert (new_meter);
Glib::Threads::RWLock::WriterLock lm (lock);
TempoSection* new_section = copy_metrics_and_point (future_map, ts);
if (solve_map (future_map, new_section, bpm, pulse_at_beat_locked (future_map, beat))) {
- solve_map (_metrics, ts, bpm, beat);
+ solve_map (_metrics, ts, bpm, pulse_at_beat_locked (_metrics, beat));
}
}
copy.push_back (cp);
}
if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
+ MeterSection* cp = 0;
if (m->position_lock_style() == MusicTime) {
- copy.push_back (new MeterSection (m->pulse(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor()));
+ cp = new MeterSection (m->pulse(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
} else {
- copy.push_back (new MeterSection (m->frame(), m->beat(), m->divisions_per_bar(), m->note_divisor()));
+ cp = new MeterSection (m->frame(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
}
+ cp->set_movable (m->movable());
+ copy.push_back (cp);
}
}
- recompute_map (copy);
+ //recompute_map (copy);
return ret;
}
if (!t->active()) {
continue;
}
- return *t;
+ if (!t->movable()) {
+ return *t;
+ }
}
}
if (!t->active()) {
continue;
}
- return *t;
+ if (!t->movable()) {
+ return *t;
+ }
}
}
prev_ts = t;
}
}
+ prev_ts->set_c_func (0.0);
}
/* tempos must be positioned correctly */
{
MeterSection* meter = 0;
MeterSection* prev_m = 0;
- double accumulated_beats = 0.0;
uint32_t accumulated_bars = 0;
for (Metrics::const_iterator mi = metrics.begin(); mi != metrics.end(); ++mi) {
if ((meter = dynamic_cast<MeterSection*> (*mi)) != 0) {
if (prev_m) {
const double beats_in_m = (meter->pulse() - prev_m->pulse()) * prev_m->note_divisor();
- accumulated_beats += beats_in_m;
accumulated_bars += (beats_in_m + 1) / prev_m->divisions_per_bar();
}
if (meter->position_lock_style() == AudioTime) {
double pulse = 0.0;
- pair<double, BBT_Time> bt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- meter->set_beat (bt);
+ pair<double, BBT_Time> b_bbt;
if (prev_m) {
- pulse = prev_m->pulse() + (meter->beat() - prev_m->beat()) / prev_m->note_divisor();
- } else {
- if (meter->movable()) {
- pulse = pulse_at_frame_locked (metrics, meter->frame());
- } else {
- pulse = 0.0;
- }
+ double beats = ((pulse_at_frame_locked (metrics, meter->frame()) - prev_m->pulse()) * prev_m->note_divisor()) - prev_m->beat();
+ b_bbt = make_pair (ceil (beats), BBT_Time (accumulated_bars + 1, 1, 0));
+ const double true_pulse = prev_m->pulse() + (ceil (beats) - prev_m->beat()) / prev_m->note_divisor();
+ const double pulse_off = true_pulse - ((beats - prev_m->beat()) / prev_m->note_divisor());
+ pulse = true_pulse - pulse_off;
+ }
+ if (!meter->movable()) {
+ b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
}
+ meter->set_beat (b_bbt);
meter->set_pulse (pulse);
} else {
double pulse = 0.0;
double
TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
{
- framecnt_t const offset_frame = frame + frame_offset_at (metrics, frame);
- double const pulse = pulse_at_frame_locked (metrics, offset_frame);
+ //framecnt_t const offset_frame = frame + frame_offset_at (metrics, frame);
+ double const pulse = pulse_at_frame_locked (metrics, frame);
return beat_at_pulse_locked (metrics, pulse);
}
TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
{
framecnt_t const frame = frame_at_pulse_locked (metrics, pulse_at_beat_locked (metrics, beat));
- frameoffset_t const frame_off = frame_offset_at (metrics, frame);
- return frame - frame_off;
+ //frameoffset_t const frame_off = frame_offset_at (metrics, frame);
+ return frame;
}
framecnt_t
if ((by_frame && t->frame() < prev_ts->frame()) || (!by_frame && t->pulse() < prev_ts->pulse())) {
return false;
}
- if (by_frame && t->frame() != prev_ts->frame_at_pulse (t->pulse(), _frame_rate)) {
+
+ if (t->frame() == prev_ts->frame()) {
return false;
}
- /*
- if (!by_frame && fabs (t->pulse() - prev_ts->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate)) > 0.00001) {
- std::cerr << "beat precision too low for bpm: " << t->beats_per_minute() << std::endl <<
- " |error :" << t->pulse() - prev_ts->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate) << std::endl <<
- "|frame at beat :" << prev_ts->frame_at_pulse (t->pulse(), _frame_rate) << std::endl <<
- " |frame at tempo : " << prev_ts->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate) << std::endl;
+
+ /* precision check ensures pulses and frames align independent of lock style.*/
+ if (by_frame && t->frame() != prev_ts->frame_at_pulse (t->pulse(), _frame_rate)) {
return false;
}
- */
}
prev_ts = t;
}
}
bool
-TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const Tempo& bpm, const framepos_t& frame)
+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<TempoSection*> (*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;
+}
+bool
+TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const Tempo& bpm, const framepos_t& frame)
+{
TempoSection* prev_ts = 0;
TempoSection* section_prev = 0;
- MetricSectionFrameSorter fcmp;
- MetricSectionSorter cmp;
framepos_t first_m_frame = 0;
+
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (!m->movable()) {
first_m_frame = m->frame();
+ break;
}
}
}
- if (section->movable() && frame < first_m_frame) {
+ if (section->movable() && frame <= first_m_frame) {
return false;
} else {
section->set_active (true);
return true;
}
+ MetricSectionFrameSorter fcmp;
imaginary.sort (fcmp);
if (section->position_lock_style() == MusicTime) {
/* we're setting the frame */
return true;
}
+ MetricSectionSorter cmp;
imaginary.sort (cmp);
if (section->position_lock_style() == MusicTime) {
/* we're setting the frame */
bool
TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const Tempo& bpm, const double& pulse)
{
- MetricSectionSorter cmp;
- MetricSectionFrameSorter fcmp;
TempoSection* prev_ts = 0;
TempoSection* section_prev = 0;
return true;
}
+ MetricSectionSorter cmp;
imaginary.sort (cmp);
if (section->position_lock_style() == AudioTime) {
/* we're setting the pulse */
return true;
}
+ MetricSectionFrameSorter fcmp;
imaginary.sort (fcmp);
if (section->position_lock_style() == AudioTime) {
/* we're setting the pulse */
}
void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const double& pulse)
+TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const framepos_t& frame)
{
MeterSection* prev_ms = 0;
- double accumulated_beats = 0.0;
+
+ if (!section->movable()) {
+ /* lock the first tempo to our first meter */
+ if (!set_active_tempos (imaginary, frame)) {
+ return;
+ }
+ TempoSection* first_t = &first_tempo();
+ Metrics future_map;
+ TempoSection* new_section = copy_metrics_and_point (future_map, first_t);
+
+ new_section->set_frame (frame);
+ new_section->set_pulse (0.0);
+ new_section->set_active (true);
+
+ if (solve_map (future_map, new_section, Tempo (new_section->beats_per_minute(), new_section->note_type()), frame)) {
+ first_t->set_frame (frame);
+ first_t->set_pulse (0.0);
+ first_t->set_active (true);
+ solve_map (imaginary, first_t, Tempo (first_t->beats_per_minute(), first_t->note_type()), frame);
+ } else {
+ return;
+ }
+ }
+
uint32_t accumulated_bars = 0;
- section->set_pulse (pulse);
+ section->set_frame (frame);
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (prev_ms) {
- double const beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
- accumulated_beats += beats_in_m;
+ const double beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
accumulated_bars += (beats_in_m + 1) / prev_ms->divisions_per_bar();
}
if (m == section){
- section->set_frame (frame_at_pulse_locked (imaginary, pulse));
- pair<double, BBT_Time> b_bbt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- section->set_beat (b_bbt);
- prev_ms = section;
+ /*
+ here we set the beat for this frame.
+ we're going to set it 'incorrectly' to the next integer and use this difference
+ to find the meter's pulse later.
+ (meters should fall on absolute beats to keep us sane)
+ */
+ double pulse = 0.0;
+ pair<double, BBT_Time> b_bbt;
+ if (m->movable()) {
+ double beats = ((pulse_at_frame_locked (imaginary, frame) - prev_ms->pulse()) * prev_ms->note_divisor()) - prev_ms->beat();
+ b_bbt = make_pair (ceil (beats), BBT_Time (accumulated_bars + 1, 1, 0));
+ const double true_pulse = prev_ms->pulse() + ((ceil (beats) - prev_ms->beat()) / prev_ms->note_divisor());
+ const double pulse_off = true_pulse - ((beats - prev_ms->beat()) / prev_ms->note_divisor());
+ pulse = true_pulse - pulse_off;
+ } else {
+ b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ }
+ m->set_beat (b_bbt);
+ m->set_pulse (pulse);
+ prev_ms = m;
continue;
}
if (prev_ms) {
m->set_frame (frame_at_pulse_locked (imaginary, pulse));
m->set_pulse (pulse);
} else {
- pair<double, BBT_Time> b_bbt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- m->set_beat (b_bbt);
+ if (!m->movable()) {
+ pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ m->set_beat (b_bbt);
+ }
const double pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
m->set_pulse (pulse);
}
}
}
- if (section->position_lock_style() == AudioTime) {
- /* we're setting the pulse */
- section->set_position_lock_style (MusicTime);
- recompute_meters (imaginary);
+ 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);
}
+ //dump (imaginary, std::cerr);
}
void
-TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const framepos_t& frame)
+TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const Meter& mt, const double& pulse)
{
MeterSection* prev_ms = 0;
-
- if (!section->movable()) {
- TempoSection* first_t;
- for (Metrics::const_iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
- TempoSection* t;
- if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
- if (!t->movable()) {
- t->set_active (true);
- first_t = t;
- }
- 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;
- }
- }
- }
-
- Metrics future_map;
- TempoSection* new_section = copy_metrics_and_point (future_map, first_t);
-
- new_section->set_frame (frame);
- new_section->set_pulse (0.0);
- new_section->set_active (true);
-
- if (solve_map (future_map, new_section, Tempo (new_section->beats_per_minute(), new_section->note_type()), frame)) {
- first_t->set_frame (frame);
- first_t->set_pulse (0.0);
- first_t->set_active (true);
- solve_map (imaginary, first_t, Tempo (first_t->beats_per_minute(), first_t->note_type()), frame);
- } else {
- return;
- }
- }
-
double accumulated_beats = 0.0;
uint32_t accumulated_bars = 0;
- section->set_frame (frame);
+ section->set_pulse (pulse);
for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
MeterSection* m;
if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
if (prev_ms) {
- const double beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
+ double const beats_in_m = (m->pulse() - prev_ms->pulse()) * prev_ms->note_divisor();
accumulated_beats += beats_in_m;
accumulated_bars += (beats_in_m + 1) / prev_ms->divisions_per_bar();
}
if (m == section){
- /*
- here we define the pulse for this frame.
- we're going to set it 'incorrectly' to the next integer and use this 'error'
- as an offset to the map as far as users of the public methods are concerned.
- (meters should go on absolute pulses to keep us sane)
- */
+ section->set_frame (frame_at_pulse_locked (imaginary, pulse));
pair<double, BBT_Time> b_bbt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- if (m->movable()) {
- m->set_pulse (pulse_at_frame_locked (imaginary, frame));
- } else {
- m->set_pulse (0.0);
- }
- m->set_beat (b_bbt);
- prev_ms = m;
+ section->set_beat (b_bbt);
+ prev_ms = section;
continue;
}
if (prev_ms) {
m->set_frame (frame_at_pulse_locked (imaginary, pulse));
m->set_pulse (pulse);
} else {
- pair<double, BBT_Time> b_bbt = make_pair (accumulated_beats, BBT_Time (accumulated_bars + 1, 1, 0));
- m->set_beat (b_bbt);
+ if (!m->movable()) {
+ pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+ m->set_beat (b_bbt);
+ }
const double pulse = prev_ms->pulse() + (m->beat() - prev_ms->beat()) / prev_ms->note_divisor();
m->set_pulse (pulse);
}
}
}
- if (section->position_lock_style() == MusicTime) {
- /* we're setting the frame */
- section->set_position_lock_style (AudioTime);
- recompute_meters (imaginary);
+ 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);
}
- //dump (imaginary, std::cerr);
}
framecnt_t
return ret_frame;
}
+void
+TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num)
+{
+ if (sub_num == -1) {
+ const double bpb = meter_section_at (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
+ if ((double) when.beats > bpb / 2.0) {
+ ++when.bars;
+ }
+ when.beats = 1;
+ when.ticks = 0;
+ return;
+ } else if (sub_num == 0) {
+ const double bpb = meter_section_at (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
+ 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;
+ 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
TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type)
{
TempoSection const tempo = tempo_section_at_locked (pos);
MeterSection const meter = meter_section_at_locked (pos);
BBT_Time const bbt = beats_to_bbt (cnt);
-
- points.push_back (BBTPoint (meter, Tempo (tempo.beats_per_minute(), tempo.note_type()), pos, bbt.bars, bbt.beats));
+ BBTPoint point = BBTPoint (meter, tempo_at_locked (pos), pos, bbt.bars, bbt.beats, tempo.get_c_func());
+ points.push_back (point);
++cnt;
}
}
TempoMap::tempo_at (const framepos_t& frame) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- //frameoffset_t const frame_off = frame_offset_at (_metrics, frame);
+ return tempo_at_locked (frame);
+}
+
+const Tempo
+TempoMap::tempo_at_locked (const framepos_t& frame) const
+{
TempoSection* prev_ts = 0;
Metrics::const_iterator i;
return m.meter();
}
+const MeterSection&
+TempoMap::meter_section_at (const double& beat) const
+{
+ MeterSection* prev_ms = 0;
+ Glib::Threads::RWLock::ReaderLock lm (lock);
+
+ for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+ MeterSection* m;
+ if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+ if (prev_ms && m->beat() > beat) {
+ break;
+ }
+ prev_ms = m;
+ }
+
+ }
+ return *prev_ms;
+}
+
XMLNode&
TempoMap::get_state ()
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
Metrics old_metrics (_metrics);
- MeterSection* last_meter = 0;
_metrics.clear();
nlist = node.children();
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);
- }
- }
}
catch (failed_constructor& err){
try {
MeterSection* ms = new MeterSection (*child);
_metrics.push_back (ms);
- last_meter = ms;
}
catch (failed_constructor& err) {
for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
if ((t = dynamic_cast<const TempoSection*>(*i)) != 0) {
- o << "Tempo @ " << *i << " (Bar-offset: " << t->bar_offset() << ") " << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->pulse() << " frame= " << t->frame() << " (movable? "
+ o << "Tempo @ " << *i << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->pulse() << " frame= " << t->frame() << " (movable? "
<< t->movable() << ')' << " pos lock: " << enum_2_string (t->position_lock_style()) << std::endl;
o << "current : " << t->beats_per_minute() << " | " << t->pulse() << " | " << t->frame() << std::endl;
if (prev_ts) {
if ((ts = dynamic_cast<const TempoSection*> (§ion)) != 0) {
o << *((const Tempo*) ts);
} else if ((ms = dynamic_cast<const MeterSection*> (§ion)) != 0) {
- //o << *((const Meter*) ms);
+ o << *((const Meter*) ms);
}
return o;
projects / ardour.git / blobdiff