Tempo ramps - a different approach to audio-locked meters.

	- the bbt of a meter cannot be changed by moving tempos or other meters.
	  e.g. tempo motion will be disallowed if it would cause a bbt overlap

3 files changed, 210 insertions, 134 deletions

diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index f7d85bf5a1..d3f7a3c4bd 100644
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -3200,20 +3200,22 @@ MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
 		map.bbt_time (pf, bbt);
 		/* round bbt to bars */
 		map.round_bbt (bbt, -1);
+		const MeterSection& prev_m = map.meter_section_at (_real_section->frame() - 1);
 
-		if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+		if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
 			_editor->session()->tempo_map().gui_dilate_tempo (_real_section, pf);
 		} else if (bbt.bars > _real_section->bbt().bars) {
-			const double pulse = _real_section->pulse() + (_real_section->note_divisor() / _real_section->divisions_per_bar());
+			const double pulse = _real_section->pulse() + (prev_m.note_divisor() / prev_m.divisions_per_bar());
+			//const double pulse = _real_section->pulse() + (_real_section->note_divisor() / _real_section->divisions_per_bar());
 			_editor->session()->tempo_map().gui_move_meter (_real_section, pulse);
 		} else if (bbt.bars < _real_section->bbt().bars) {
-			const MeterSection& prev_m = map.meter_section_at (pf);
 			const double pulse = _real_section->pulse() - (prev_m.note_divisor() / prev_m.divisions_per_bar());
 			_editor->session()->tempo_map().gui_move_meter (_real_section, pulse);
 		}
 	} else {
 		/* AudioTime */
-		if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+		if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+			/* currently disabled in the lib for AudioTime */
 			if (_real_section->movable()) {
 				_editor->session()->tempo_map().gui_dilate_tempo (_real_section, pf);
 			}
@@ -3291,7 +3293,7 @@ TempoMarkerDrag::setup_pointer_frame_offset ()
 void
 TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 {
-	if (!_real_section->active() || _real_section->locked_to_meter()) {
+	if (!_real_section->active()) {
 		return;
 	}
 	if (first_move) {
@@ -3373,14 +3375,14 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 	}
 
 	framepos_t pf;
-	Tempo const tp = _marker->tempo();
-	if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+
+	if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
 		double new_bpm = _real_section->beats_per_minute() + ((last_pointer_y() - current_pointer_y()) / 5.0);
 		_editor->session()->tempo_map().gui_change_tempo (_real_section, Tempo (new_bpm, _real_section->note_type()));
 		stringstream strs;
 		strs << new_bpm;
 		show_verbose_cursor_text (strs.str());
-	} else if (_movable) {
+	} else if (_movable && !_real_section->locked_to_meter()) {
 		if (!_editor->snap_musical()) {
 			/* snap normally (this is not self-referential).*/
 			pf = adjusted_current_frame (event);
@@ -3443,7 +3445,7 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 void
 TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
 {
-	if (!_real_section->active() || _real_section->locked_to_meter()) {
+	if (!_real_section->active()) {
 		return;
 	}
 	if (!movement_occurred) {
diff --git a/libs/ardour/ardour/tempo.h b/libs/ardour/ardour/tempo.h
index 25180b8eb3..e6f07a3772 100644
--- a/libs/ardour/ardour/tempo.h
+++ b/libs/ardour/ardour/tempo.h
@@ -177,8 +177,8 @@ class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
 		Constant,
 	};
 
-	TempoSection (const double& beat, double qpm, double note_type, Type tempo_type)
-		: MetricSection (beat), Tempo (qpm, note_type), _type (tempo_type), _c_func (0.0), _active (true), _locked_to_meter (false)  {}
+	TempoSection (const double& pulse, double qpm, double note_type, Type tempo_type)
+		: MetricSection (pulse), Tempo (qpm, note_type), _type (tempo_type), _c_func (0.0), _active (true), _locked_to_meter (false)  {}
 	TempoSection (framepos_t frame, double qpm, double note_type, Type tempo_type)
 		: MetricSection (frame), Tempo (qpm, note_type), _type (tempo_type), _c_func (0.0), _active (true), _locked_to_meter (false) {}
 	TempoSection (const XMLNode&);
@@ -206,7 +206,7 @@ class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
 	double pulse_at_tempo (const double& ppm, const framepos_t& frame, const framecnt_t& frame_rate) const;
 
 	double pulse_at_frame (const framepos_t& frame, const framecnt_t& frame_rate) const;
-	framepos_t frame_at_pulse (const double& pulse, const framecnt_t& frame_rate) const;
+	frameoffset_t frame_at_pulse (const double& pulse, const framecnt_t& frame_rate) const;
 
 	double compute_c_func_pulse (const double& end_bpm, const double& end_pulse, const framecnt_t& frame_rate);
 	double compute_c_func_frame (const double& end_bpm, const framepos_t& end_frame, const framecnt_t& frame_rate) const;
@@ -475,8 +475,8 @@ private:
 	bool set_active_tempos (const Metrics& metrics, const framepos_t& frame);
 	bool solve_map (Metrics& metrics, TempoSection* section, const framepos_t& frame);
 	bool solve_map (Metrics& metrics, TempoSection* section, const double& pulse);
-	void solve_map (Metrics& metrics, MeterSection* section, const framepos_t& frame);
-	void solve_map (Metrics& metrics, MeterSection* section, const double& pulse);
+	bool solve_map (Metrics& metrics, MeterSection* section, const framepos_t& frame);
+	bool solve_map (Metrics& metrics, MeterSection* section, const double& pulse);
 
 	friend class ::BBTTest;
 	friend class ::FrameposPlusBeatsTest;
@@ -511,7 +511,8 @@ private:
 	bool remove_tempo_locked (const TempoSection&);
 	bool remove_meter_locked (const MeterSection&);
 
-	TempoSection* copy_metrics_and_point (Metrics& copy, TempoSection* section);
+	TempoSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section);
+	MeterSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section);
 };
 
 }; /* namespace ARDOUR */
diff --git a/libs/ardour/tempo.cc b/libs/ardour/tempo.cc
index 35facf91e5..cb4ef4d57c 100644
--- a/libs/ardour/tempo.cc
+++ b/libs/ardour/tempo.cc
@@ -277,11 +277,11 @@ TempoSection::pulse_at_frame (const framepos_t& f, const framecnt_t& frame_rate)
    falls.
 */
 
-framepos_t
+frameoffset_t
 TempoSection::frame_at_pulse (const double& p, const framecnt_t& frame_rate) const
 {
 	if (_type == Constant || _c_func == 0.0) {
-		return (framepos_t) floor ((p - pulse()) * frames_per_pulse (frame_rate)) + frame();
+		return (frameoffset_t) floor ((p - pulse()) * frames_per_pulse (frame_rate)) + frame();
 	}
 
 	return minute_to_frame (time_at_pulse (p - pulse()), frame_rate) + frame();
@@ -383,7 +383,7 @@ TempoSection::compute_c_func_frame (const double& end_bpm, const framepos_t& end
 frameoffset_t
 TempoSection::minute_to_frame (const double& time, const framecnt_t& frame_rate) const
 {
-	return (framecnt_t) floor ((time * 60.0 * frame_rate) + 0.5);
+	return (frameoffset_t) floor ((time * 60.0 * (frameoffset_t) frame_rate) + 0.5);
 }
 
 double
@@ -1299,7 +1299,9 @@ TempoMap::recompute_tempos (Metrics& metrics)
 			if (prev_t) {
 				if (t->position_lock_style() == AudioTime) {
 					prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
-					t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
+					if (!t->locked_to_meter()) {
+						t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
+					}
 
 				} else {
 					prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
@@ -1326,21 +1328,8 @@ TempoMap::recompute_meters (Metrics& metrics)
 				double pulse = 0.0;
 				pair<double, BBT_Time> b_bbt;
 				if (meter->movable()) {
-					const double beats = floor ((pulse_at_frame_locked (metrics, meter->frame()) - prev_m->pulse())
-								    * prev_m->note_divisor() + 0.5);
-
-					if (beats + prev_m->beat() < meter->beat()) {
-						/* tempo change caused a change in beat (bar). */
-						const double floor_beats = beats - fmod (beats, prev_m->divisions_per_bar());
-						b_bbt = make_pair (floor_beats + prev_m->beat()
-								   , BBT_Time ((floor_beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
-						const double true_pulse = prev_m->pulse() + (floor_beats / prev_m->note_divisor());
-						const double pulse_off = true_pulse - (beats / prev_m->note_divisor()) - prev_m->pulse();
-						pulse = true_pulse - pulse_off;
-					} else {
-						b_bbt = make_pair (meter->beat(), meter->bbt());
-						pulse = pulse_at_frame_locked (metrics, meter->frame());
-					}
+					b_bbt = make_pair (meter->beat(), meter->bbt());
+					pulse = pulse_at_frame_locked (metrics, meter->frame());
 				} else {
 					b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
 				}
@@ -1351,14 +1340,14 @@ TempoMap::recompute_meters (Metrics& metrics)
 				pair<double, BBT_Time> new_beat;
 				if (prev_m) {
 					pulse = prev_m->pulse() + ((meter->bbt().bars - prev_m->bbt().bars) *  prev_m->divisions_per_bar() / prev_m->note_divisor());
-					new_beat = make_pair (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), meter->bbt());
+					//new_beat = make_pair (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), meter->bbt());
 				} else {
 					/* shouldn't happen - the first is audio-locked */
 					pulse = pulse_at_beat_locked (metrics, meter->beat());
-					new_beat = make_pair (pulse, meter->bbt());
+					new_beat = make_pair (meter->beat(), meter->bbt());
 				}
 
-				meter->set_beat (new_beat);
+				//meter->set_beat (new_beat);
 				meter->set_frame (frame_at_pulse_locked (metrics, pulse));
 				meter->set_pulse (pulse);
 			}
@@ -1489,7 +1478,7 @@ TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) con
 		MeterSection* m;
 		if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
 			if (prev_m && m->pulse() > pulse) {
-				if ((pulse - prev_m->pulse()) * prev_m->note_divisor() < m->beat()) {
+				if (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > m->beat()) {
 					break;
 				}
 			}
@@ -1497,9 +1486,8 @@ TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) con
 		}
 	}
 
-	double const beats_in_section = (pulse - prev_m->pulse()) * prev_m->note_divisor();
-
-	return beats_in_section + prev_m->beat();
+	double const ret = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat();
+	return ret;
 }
 
 double
@@ -1840,9 +1828,11 @@ bool
 TempoMap::check_solved (const Metrics& metrics, bool by_frame) const
 {
 	TempoSection* prev_t = 0;
+	MeterSection* prev_m = 0;
 
 	for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
 		TempoSection* t;
+		MeterSection* m;
 		if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
 			if (!t->active()) {
 				continue;
@@ -1858,11 +1848,27 @@ TempoMap::check_solved (const Metrics& metrics, bool by_frame) const
 
 				/* precision check ensures pulses and frames align.*/
 				if (t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) {
-					return false;
+					if (!t->locked_to_meter()) {
+						return false;
+					}
 				}
 			}
 			prev_t = t;
 		}
+
+		if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+			if (prev_m && m->position_lock_style() == AudioTime) {
+				TempoSection* t = const_cast<TempoSection*>(&tempo_section_at_locked (metrics, m->frame() - 1));
+				const double nascent_m_pulse = ((m->beat() - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse();
+				const frameoffset_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;
@@ -1931,7 +1937,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t
 					t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
 				} else {
 					prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
-					t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+					if (!t->locked_to_meter()) {
+						t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+					}
 				}
 			}
 			prev_t = t;
@@ -1940,7 +1948,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t
 
 	if (section_prev) {
 		section_prev->set_c_func (section_prev->compute_c_func_frame (section->pulses_per_minute(), frame, _frame_rate));
-		section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate));
+		if (!section->locked_to_meter()) {
+			section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate));
+		}
 	}
 
 	if (section->position_lock_style() == MusicTime) {
@@ -1952,6 +1962,7 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t
 		recompute_tempos (imaginary);
 	}
 
+	recompute_meters (imaginary);
 	if (check_solved (imaginary, true)) {
 		return true;
 	}
@@ -1967,6 +1978,7 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const framepos_t
 		recompute_tempos (imaginary);
 	}
 
+	recompute_meters (imaginary);
 	if (check_solved (imaginary, true)) {
 		return true;
 	}
@@ -2005,7 +2017,9 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu
 					t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
 				} else {
 					prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
-					t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+					if (!t->locked_to_meter()) {
+						t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
+					}
 				}
 			}
 			prev_t = t;
@@ -2025,6 +2039,7 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu
 		recompute_tempos (imaginary);
 	}
 
+	recompute_meters (imaginary);
 	if (check_solved (imaginary, false)) {
 		return true;
 	}
@@ -2040,6 +2055,7 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu
 		recompute_tempos (imaginary);
 	}
 
+	recompute_meters (imaginary);
 	if (check_solved (imaginary, false)) {
 		return true;
 	}
@@ -2049,52 +2065,43 @@ TempoMap::solve_map (Metrics& imaginary, TempoSection* section, const double& pu
 	return false;
 }
 
-void
+bool
 TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
 {
 	/* disallow moving first meter past any subsequent one, and any movable meter before the first one */
 	const MeterSection* other =  &meter_section_at_locked (imaginary, frame);
 	if ((!section->movable() && other->movable()) || (!other->movable() && section->movable() && other->frame() >= frame)) {
-		return;
+		return false;
 	}
-	MeterSection* prev_m = 0;
+
 	if (!section->movable()) {
 		/* lock the first tempo to our first meter */
 		if (!set_active_tempos (imaginary, frame)) {
-			return;
-		}
-		TempoSection* first_t = &first_tempo();
-		Metrics future_map;
-		TempoSection* new_section = copy_metrics_and_point (future_map, first_t);
-
-		new_section->set_frame (frame);
-		new_section->set_pulse (0.0);
-		new_section->set_active (true);
-
-		if (solve_map (future_map, new_section, frame)) {
-			first_t->set_frame (frame);
-			first_t->set_pulse (0.0);
-			first_t->set_active (true);
-			solve_map (imaginary, first_t, frame);
-		} else {
-			return;
+			return false;
 		}
 	}
 
 	TempoSection* meter_locked_tempo = 0;
-
-	if ((meter_locked_tempo = const_cast<TempoSection*>(&tempo_section_at_locked (imaginary, section->frame())))->frame() == section->frame()) {
-		if (!meter_locked_tempo->locked_to_meter()) {
-			meter_locked_tempo = 0;
+	for (Metrics::const_iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
+		TempoSection* t;
+		if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+			if ((t->locked_to_meter() || !t->movable()) && t->frame() == section->frame()) {
+				if (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<MeterSection*> (*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());
+					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().
@@ -2102,44 +2109,66 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t
 						   this is what the user would actually want.
 						   here we set the frame/pulse corresponding to its musical position.
 						*/
-						const double new_pulse = ((section->beat() - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse();
 
 						if (meter_locked_tempo) {
 							Metrics future_map;
-							TempoSection* new_section = copy_metrics_and_point (future_map, meter_locked_tempo);
-
-							new_section->set_active (true);
+							TempoSection* new_section = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+							if (!new_section) {
+								return false;
+							}
+							const double new_pulse = ((section->beat() - prev_m->beat())
+										  / prev_m->note_divisor()) + prev_m->pulse();
 
 							if (solve_map (future_map, new_section, section->frame())) {
-								meter_locked_tempo->set_active (true);
+								meter_locked_tempo->set_pulse (new_pulse);
 								solve_map (imaginary, meter_locked_tempo, section->frame());
 								section->set_frame (frame_at_pulse_locked (imaginary, new_pulse));
 								section->set_pulse (new_pulse);
 							} else {
-								return;
+								return false;
 							}
-							meter_locked_tempo->set_frame (section->frame());
-							/* XX need to fake the pulse and prevent it from changing */
-							//meter_locked_tempo->set_pulse (pulse_at_frame_locked (imaginary, section->frame()));
 						}
-						return;
+						return false;
 					} else {
 						if (meter_locked_tempo) {
 							Metrics future_map;
-							TempoSection* new_section = copy_metrics_and_point (future_map, meter_locked_tempo);
-
+							TempoSection* new_section = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+							if (!new_section) {
+								return false;
+							}
 							new_section->set_active (true);
 
 							if (solve_map (future_map, new_section, frame)) {
-								meter_locked_tempo->set_active (true);
+								meter_locked_tempo->set_pulse (((section->beat() - prev_m->beat())
+												/ prev_m->note_divisor()) + prev_m->pulse());
 								solve_map (imaginary, meter_locked_tempo, frame);
-								section->set_pulse (pulse_at_frame_locked (imaginary, frame));
 							} else {
-								return;
+								return false;
 							}
 						}
 					}
 				} else {
+					if (meter_locked_tempo) {
+						Metrics future_map;
+						TempoSection* new_section = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
+						if (!new_section) {
+							return false;
+						}
+						new_section->set_frame (frame);
+						new_section->set_pulse (0.0);
+						new_section->set_active (true);
+
+						if (solve_map (future_map, new_section, frame)) {
+							meter_locked_tempo->set_frame (frame);
+							meter_locked_tempo->set_pulse (0.0);
+							meter_locked_tempo->set_active (true);
+							solve_map (imaginary, meter_locked_tempo, frame);
+						} else {
+							return false;
+						}
+					} else {
+						return false;
+					}
 					pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
 					section->set_beat (b_bbt);
 					section->set_pulse (0.0);
@@ -2164,9 +2193,10 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const framepos_t
 		recompute_meters (imaginary);
 	}
 	//dump (imaginary, std::cerr);
+	return true;
 }
 
-void
+bool
 TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pulse)
 {
 	MeterSection* prev_m = 0;
@@ -2176,18 +2206,43 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pu
 	for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
 		MeterSection* m;
 		if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
+			double new_pulse = 0.0;
+			pair<double, BBT_Time> b_bbt;
+
 			if (prev_m && m == section){
 				/* the first meter is always audio-locked, so prev_m should exist.
 				   should we allow setting audio locked meters by pulse?
 				*/
-				const double beats = ((pulse - prev_m->pulse()) * prev_m->note_divisor());
-				const int32_t bars = (beats + 1) / prev_m->divisions_per_bar();
+				const double beats = floor (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + 0.5);
+				const int32_t bars = (beats) / prev_m->divisions_per_bar();
 				pair<double, BBT_Time> b_bbt = make_pair (beats + prev_m->beat(), BBT_Time (bars + prev_m->bbt().bars, 1, 0));
 				section->set_beat (b_bbt);
 				section->set_frame (frame_at_pulse_locked (imaginary, pulse));
-				break;
+				prev_m = m;
+				continue;
 			}
-
+			if (m->position_lock_style() == AudioTime) {
+				if (m->movable()) {
+					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). */
+						const double floor_beats = beats - fmod (beats, prev_m->divisions_per_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 {
+						b_bbt = make_pair (m->beat(), m->bbt());
+						new_pulse = pulse_at_frame_locked (imaginary, m->frame());
+					}
+				} else {
+					b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
+				}
+			} else {
+				new_pulse = prev_m->pulse() + ((m->bbt().bars - prev_m->bbt().bars) *  prev_m->divisions_per_bar() / prev_m->note_divisor());
+				b_bbt = make_pair (((new_pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat(), m->bbt());
+			}
+			m->set_beat (b_bbt);
+			m->set_pulse (new_pulse);
 			prev_m = m;
 		}
 	}
@@ -2202,59 +2257,59 @@ TempoMap::solve_map (Metrics& imaginary, MeterSection* section, const double& pu
 	} else {
 		recompute_meters (imaginary);
 	}
+	return true;
 }
 
 /** places a copy of _metrics into copy and returns a pointer
  *  to section's equivalent in copy.
  */
 TempoSection*
-TempoMap::copy_metrics_and_point (Metrics& copy, TempoSection* section)
+TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section)
 {
-	TempoSection* t;
-	MeterSection* m;
 	TempoSection* ret = 0;
 
-	for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
+	for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+		TempoSection* t;
+		MeterSection* m;
 		if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
 			if (t == section) {
-				if (t->position_lock_style() == MusicTime) {
-					ret = new TempoSection (t->pulse(), t->beats_per_minute(), t->note_type(), t->type());
-					ret->set_frame (t->frame());
-				} else {
-					ret = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
-					ret->set_pulse (t->pulse());
-				}
-				ret->set_c_func (t->c_func());
-				ret->set_active (t->active());
-				ret->set_movable (t->movable());
-				ret->set_locked_to_meter (t->locked_to_meter());
+				ret = new TempoSection (*t);
 				copy.push_back (ret);
 				continue;
 			}
-			TempoSection* cp = 0;
-			if (t->position_lock_style() == MusicTime) {
-				cp = new TempoSection (t->pulse(), t->beats_per_minute(), t->note_type(), t->type());
-				cp->set_frame (t->frame());
-			} else {
-				cp = new TempoSection (t->frame(), t->beats_per_minute(), t->note_type(), t->type());
-				cp->set_pulse (t->pulse());
-			}
-			cp->set_c_func (t->c_func());
-			cp->set_active (t->active());
-			cp->set_movable (t->movable());
-			cp->set_locked_to_meter (t->locked_to_meter());
+
+			TempoSection* cp = new TempoSection (*t);
 			copy.push_back (cp);
 		}
 		if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
-			MeterSection* cp = 0;
-			if (m->position_lock_style() == MusicTime) {
-				cp = new MeterSection (m->pulse(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
-				cp->set_frame (m->frame());
-			} else {
-				cp = new MeterSection (m->frame(), m->beat(), m->bbt(), m->divisions_per_bar(), m->note_divisor());
-				cp->set_pulse (m->pulse());
+			MeterSection* cp = new MeterSection (*m);
+			copy.push_back (cp);
+		}
+	}
+
+	return ret;
+}
+
+MeterSection*
+TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section)
+{
+	MeterSection* ret = 0;
+
+	for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
+		TempoSection* t;
+		MeterSection* m;
+		if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
+			TempoSection* cp = new TempoSection (*t);
+			copy.push_back (cp);
+		}
+
+		if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
+			if (m == section) {
+				ret = new MeterSection (*m);
+				copy.push_back (ret);
+				continue;
 			}
-			cp->set_movable (m->movable());
+			MeterSection* cp = new MeterSection (*m);
 			copy.push_back (cp);
 		}
 	}
@@ -2270,7 +2325,10 @@ TempoMap::can_solve_bbt (TempoSection* ts, const BBT_Time& bbt)
 
 	{
 		Glib::Threads::RWLock::ReaderLock lm (lock);
-		new_section = copy_metrics_and_point (copy, ts);
+		new_section = copy_metrics_and_point (_metrics, copy, ts);
+		if (!new_section) {
+			return false;
+		}
 	}
 
 	const double beat = bbt_to_beats_locked (copy, bbt);
@@ -2299,8 +2357,10 @@ TempoMap::predict_tempo_frame (TempoSection* section, const BBT_Time& bbt)
 	Glib::Threads::RWLock::ReaderLock lm (lock);
 	Metrics future_map;
 	framepos_t ret = 0;
-	TempoSection* new_section = copy_metrics_and_point (future_map, section);
-
+	TempoSection* new_section = copy_metrics_and_point (_metrics, future_map, section);
+	if (!new_section) {
+		return 0;
+	}
 	const double beat = bbt_to_beats_locked (future_map, bbt);
 
 	if (solve_map (future_map, new_section, pulse_at_beat_locked (future_map, beat))) {
@@ -2323,7 +2383,7 @@ TempoMap::predict_tempo_pulse (TempoSection* section, const framepos_t& frame)
 	Glib::Threads::RWLock::ReaderLock lm (lock);
 	Metrics future_map;
 	double ret = 0.0;
-	TempoSection* new_section = copy_metrics_and_point (future_map, section);
+	TempoSection* new_section = copy_metrics_and_point (_metrics, future_map, section);
 
 	if (solve_map (future_map, new_section, frame)) {
 		ret = new_section->pulse();
@@ -2345,7 +2405,7 @@ TempoMap::gui_move_tempo_frame (TempoSection* ts, const framepos_t& frame)
 	Metrics future_map;
 	{
 		Glib::Threads::RWLock::WriterLock lm (lock);
-		TempoSection* new_section = copy_metrics_and_point (future_map, ts);
+		TempoSection* new_section = copy_metrics_and_point (_metrics, future_map, ts);
 		if (solve_map (future_map, new_section, frame)) {
 			solve_map (_metrics, ts, frame);
 			recompute_meters (_metrics);
@@ -2367,7 +2427,7 @@ TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat)
 	Metrics future_map;
 	{
 		Glib::Threads::RWLock::WriterLock lm (lock);
-		TempoSection* new_section = copy_metrics_and_point (future_map, ts);
+		TempoSection* new_section = copy_metrics_and_point (_metrics, future_map, ts);
 		if (solve_map (future_map, new_section, pulse_at_beat_locked (future_map, beat))) {
 			solve_map (_metrics, ts, pulse_at_beat_locked (_metrics, beat));
 			recompute_meters (_metrics);
@@ -2386,9 +2446,13 @@ TempoMap::gui_move_tempo_beat (TempoSection* ts, const double& beat)
 void
 TempoMap::gui_move_meter (MeterSection* ms, const framepos_t&  frame)
 {
+	Metrics future_map;
 	{
 		Glib::Threads::RWLock::WriterLock lm (lock);
-		solve_map (_metrics, ms, frame);
+		MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
+		if (solve_map (future_map, copy, frame)) {
+			solve_map (_metrics, ms, frame);
+		}
 	}
 
 	MetricPositionChanged (); // Emit Signal
@@ -2412,7 +2476,7 @@ TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm)
 	bool can_solve = false;
 	{
 		Glib::Threads::RWLock::WriterLock lm (lock);
-		TempoSection* new_section = copy_metrics_and_point (future_map, ts);
+		TempoSection* new_section = copy_metrics_and_point (_metrics, future_map, ts);
 		new_section->set_beats_per_minute (bpm.beats_per_minute());
 		recompute_tempos (future_map);
 
@@ -2439,10 +2503,18 @@ TempoMap::gui_dilate_tempo (MeterSection* ms, const framepos_t& frame)
 {
 	Metrics future_map;
 	TempoSection* ts = 0;
+
+	if (ms->position_lock_style() == AudioTime) {
+		/* disabled for now due to faked tempo locked to meter pulse */
+		return;
+	}
 	{
 		Glib::Threads::RWLock::WriterLock lm (lock);
 		ts = const_cast<TempoSection*>(&tempo_section_at_locked (_metrics, ms->frame() - 1));
-		TempoSection* prev_t = copy_metrics_and_point (future_map, ts);
+		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;
@@ -2530,6 +2602,7 @@ TempoMap::gui_dilate_tempo (MeterSection* ms, const framepos_t& frame)
 
 		prev_t->set_beats_per_minute (new_bpm);
 		recompute_tempos (future_map);
+		recompute_meters (future_map);
 
 		if (check_solved (future_map, true)) {