Tempo ramps - add visualtempo curve, dragging bbt or music rulers with constraint...
[ardour.git] / libs / ardour / ardour / tempo.h
index 4236ed0ba4c4dbf8a851f6e5da149eb275c01ccf..ba28e8a44a563f6efa9220cf3eccf6e33dccb555 100644 (file)
@@ -55,7 +55,11 @@ class LIBARDOUR_API Tempo {
        Tempo (double bpm, double type=4.0) // defaulting to quarter note
                : _beats_per_minute (bpm), _note_type(type) {}
 
+       /* ..or more aptly 'pulse divisions per minute'.
+          Nothing to do with actual beats, which are defined by the meter and tempo.
+       */
        double beats_per_minute () const { return _beats_per_minute; }
+       void set_beats_per_minute (double bpm) { _beats_per_minute = bpm; }
        double note_type () const { return _note_type; }
        double pulses_per_minute () const { return _beats_per_minute / _note_type; }
        /** audio samples per beat
@@ -102,14 +106,13 @@ class LIBARDOUR_API Meter {
 class LIBARDOUR_API MetricSection {
   public:
        MetricSection (double pulse)
-               : _pulse (pulse), _frame (0), _movable (true), _position_lock_style (PositionLockStyle::MusicTime) {}
+               : _pulse (pulse), _frame (0), _movable (true), _position_lock_style (MusicTime) {}
        MetricSection (framepos_t frame)
-               : _pulse (0.0), _frame (frame), _movable (true), _position_lock_style (PositionLockStyle::AudioTime) {}
+               : _pulse (0.0), _frame (frame), _movable (true), _position_lock_style (AudioTime) {}
 
        virtual ~MetricSection() {}
 
        const double& pulse () const { return _pulse; }
-       //const double tick () const { return _beat * Timecode::BBT_Time::ticks_per_beat; }
        void set_pulse (double pulse) { _pulse = pulse; }
 
        framepos_t frame() const { return _frame; }
@@ -139,23 +142,26 @@ private:
 /** A section of timeline with a certain Meter. */
 class LIBARDOUR_API MeterSection : public MetricSection, public Meter {
   public:
-       MeterSection (double beat, const Timecode::BBT_Time& bbt, double bpb, double note_type)
-               : MetricSection (beat), Meter (bpb, note_type), _bbt (bbt) {}
-       MeterSection (framepos_t frame, double bpb, double note_type)
-               : MetricSection (frame), Meter (bpb, note_type), _bbt (1, 1, 0) {}
+       MeterSection (double pulse, double beat, const Timecode::BBT_Time& bbt, double bpb, double note_type)
+               : MetricSection (pulse), Meter (bpb, note_type), _bbt (bbt),  _beat (beat) {}
+       MeterSection (framepos_t frame, double beat, const Timecode::BBT_Time& bbt, double bpb, double note_type)
+               : MetricSection (frame), Meter (bpb, note_type), _bbt (bbt), _beat (beat) {}
        MeterSection (const XMLNode&);
 
        static const std::string xml_state_node_name;
 
        XMLNode& get_state() const;
 
-       void set_pulse (std::pair<double, Timecode::BBT_Time>& w) {
-               MetricSection::set_pulse (w.first);
+       void set_pulse (double w) {
+               MetricSection::set_pulse (w);
+       }
+       void set_beat (std::pair<double, Timecode::BBT_Time>& w) {
+               _beat = w.first;
                _bbt = w.second;
        }
 
        const Timecode::BBT_Time& bbt() const { return _bbt; }
-        double beat () { return _beat; }
+        const double& beat () const { return _beat; }
        void set_beat (double beat) { _beat = beat; }
 
 private:
@@ -171,44 +177,46 @@ 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), _bar_offset (-1.0), _type (tempo_type), _c_func (0.0)  {}
+       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), _bar_offset (-1.0), _type (tempo_type), _c_func (0.0) {}
+               : MetricSection (frame), Tempo (qpm, note_type), _type (tempo_type), _c_func (0.0), _active (true), _locked_to_meter (false) {}
        TempoSection (const XMLNode&);
 
        static const std::string xml_state_node_name;
 
        XMLNode& get_state() const;
 
-       void update_bar_offset_from_bbt (const Meter&);
-       void update_bbt_time_from_bar_offset (const Meter&);
-       double bar_offset() const { return _bar_offset; }
+       double c_func () const { return _c_func; }
+       void set_c_func (double c_func) { _c_func = c_func; }
 
        void set_type (Type type);
        Type type () const { return _type; }
 
-       double tempo_at_frame (framepos_t frame, framecnt_t frame_rate) const;
-       framepos_t frame_at_tempo (double tempo, double beat, framecnt_t frame_rate) const;
+       bool active () const { return _active; }
+       void set_active (bool yn) { _active = yn; }
 
-       double tempo_at_pulse (double beat) const;
-       double pulse_at_tempo (double tempo, framepos_t frame, framecnt_t frame_rate) const;
+       bool locked_to_meter ()  const { return _locked_to_meter; }
+       void set_locked_to_meter (bool yn) { _locked_to_meter = yn; }
 
-       double pulse_at_frame (framepos_t frame, framecnt_t frame_rate) const;
-       framepos_t frame_at_pulse (double pulse, framecnt_t frame_rate) const;
+       double tempo_at_frame (const framepos_t& frame, const framecnt_t& frame_rate) const;
+       framepos_t frame_at_tempo (const double& ppm, const double& beat, const framecnt_t& frame_rate) const;
 
-       double compute_c_func_pulse (double end_bpm, double end_pulse, framecnt_t frame_rate);
-       double compute_c_func_frame (double end_bpm, framepos_t end_frame, framecnt_t frame_rate) const;
+       double tempo_at_pulse (const double& pulse) const;
+       double pulse_at_tempo (const double& ppm, const framepos_t& frame, const framecnt_t& frame_rate) const;
 
-       double get_c_func () const { return _c_func; }
-       void set_c_func (double c_func) { _c_func = c_func; }
+       double pulse_at_frame (const framepos_t& frame, 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;
 
        Timecode::BBT_Time legacy_bbt () { return _legacy_bbt; }
 
   private:
 
-       framecnt_t minute_to_frame (double time, framecnt_t frame_rate) const;
-       double frame_to_minute (framecnt_t frame, framecnt_t frame_rate) const;
+       framepos_t minute_to_frame (const double& time, const framecnt_t& frame_rate) const;
+       double frame_to_minute (const framepos_t& frame, const framecnt_t& frame_rate) const;
 
        /*  tempo ramp functions. zero-based with time in minutes,
         * 'tick tempo' in ticks per minute and tempo in bpm.
@@ -217,14 +225,14 @@ class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
        double a_func (double end_tpm, double c_func) const;
        double c_func (double end_tpm, double end_time) const;
 
-       double pulse_tempo_at_time (double time) const;
-       double time_at_pulse_tempo (double pulse_tempo) const;
+       double pulse_tempo_at_time (const double& time) const;
+       double time_at_pulse_tempo (const double& pulse_tempo) const;
 
-       double pulse_tempo_at_pulse (double pulse) const;
-       double pulse_at_pulse_tempo (double pulse_tempo) const;
+       double pulse_tempo_at_pulse (const double& pulse) const;
+       double pulse_at_pulse_tempo (const double& pulse_tempo) const;
 
-       double pulse_at_time (double time) const;
-       double time_at_pulse (double pulse) const;
+       double pulse_at_time (const double& time) const;
+       double time_at_pulse (const double& pulse) const;
 
        /* this value provides a fractional offset into the bar in which
           the tempo section is located in. A value of 0.0 indicates that
@@ -234,9 +242,10 @@ class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
           this enables us to keep the tempo change at the same relative
           position within the bar if/when the meter changes.
        */
-       double _bar_offset;
        Type _type;
        double _c_func;
+       bool _active;
+       bool _locked_to_meter;
        Timecode::BBT_Time _legacy_bbt;
 };
 
@@ -298,14 +307,15 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 
        struct BBTPoint {
                framepos_t          frame;
-               const MeterSection* meter;
-               const Tempo tempo;
+               Meter               meter;
+               Tempo               tempo;
+               double              c;
                uint32_t            bar;
                uint32_t            beat;
 
                BBTPoint (const MeterSection& m, const Tempo& t, framepos_t f,
-                         uint32_t b, uint32_t e)
-               : frame (f), meter (&m), tempo (t.beats_per_minute(), t.note_type()), bar (b), beat (e) {}
+                         uint32_t b, uint32_t e, double func_c)
+               : frame (f), meter (m.note_divisor(), m.divisions_per_bar()), tempo (t.beats_per_minute(), t.note_type()), c (func_c), bar (b), beat (e) {}
 
                Timecode::BBT_Time bbt() const { return Timecode::BBT_Time (bar, beat, 0); }
                operator Timecode::BBT_Time() const { return bbt(); }
@@ -334,8 +344,8 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 
        void bbt_time (framepos_t when, Timecode::BBT_Time&);
 
-       double beat_at_frame (framecnt_t frame) const;
-       framecnt_t frame_at_beat (double beat) const;
+       double beat_at_frame (const framecnt_t& frame) const;
+       framecnt_t frame_at_beat (const double& beat) const;
 
        framepos_t frame_time (const Timecode::BBT_Time&);
        framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
@@ -358,35 +368,40 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
        static const Tempo& default_tempo() { return _default_tempo; }
        static const Meter& default_meter() { return _default_meter; }
 
-       const Tempo tempo_at (framepos_t) const;
-       double frames_per_beat_at (framepos_t, framecnt_t sr) const;
+       const Tempo tempo_at (const framepos_t& frame) const;
+       double frames_per_beat_at (const framepos_t&, const framecnt_t& sr) const;
 
        const Meter& meter_at (framepos_t) const;
 
        const TempoSection& tempo_section_at (framepos_t frame) const;
        const MeterSection& meter_section_at (framepos_t frame) const;
+       const MeterSection& meter_section_at_beat (double beat) const;
 
-       void add_tempo (const Tempo&, double where, TempoSection::Type type);
-       void add_tempo (const Tempo&, framepos_t frame, TempoSection::Type type);
+       TempoSection* add_tempo (const Tempo&, const double& pulse, TempoSection::Type type);
+       TempoSection* add_tempo (const Tempo&, const framepos_t& frame, TempoSection::Type type);
 
-       void add_meter (const Meter&, double beat, Timecode::BBT_Time where);
-       void add_meter (const Meter&, framepos_t frame);
+       MeterSection* add_meter (const Meter&, const double& beat, const Timecode::BBT_Time& where);
+       MeterSection* add_meter (const Meter&, const framepos_t& frame, const double& beat, const Timecode::BBT_Time& where);
 
        void remove_tempo (const TempoSection&, bool send_signal);
        void remove_meter (const MeterSection&, bool send_signal);
 
-       framepos_t predict_tempo_frame (TempoSection* section, const Tempo& bpm, const Timecode::BBT_Time& bbt);
-       double predict_tempo_beat (TempoSection* section, const Tempo& bpm, const framepos_t& beat);
+       framepos_t predict_tempo_frame (TempoSection* section, const Timecode::BBT_Time& bbt);
+       double predict_tempo_pulse (TempoSection* section, const framepos_t& frame);
 
        void replace_tempo (const TempoSection&, const Tempo&, const double& where, TempoSection::Type type);
        void replace_tempo (const TempoSection&, const Tempo&, const framepos_t& frame, TempoSection::Type type);
 
-       void gui_move_tempo_frame (TempoSection*, const Tempo& bpm, const framepos_t& frame);
-       void gui_move_tempo_beat (TempoSection*, const Tempo& bpm, const double& frame);
-       void gui_move_meter (MeterSection*, const Meter& mt, const framepos_t& frame);
-       void gui_move_meter (MeterSection*, const Meter& mt, const double& beat);
+       void gui_move_tempo_frame (TempoSection*, const framepos_t& frame);
+       void gui_move_tempo_beat (TempoSection*, const double& beat);
+       void gui_move_tempo_pulse (TempoSection*, const double& pulse);
+       void gui_move_meter (MeterSection*, const framepos_t& frame);
+       void gui_move_meter (MeterSection*, const Timecode::BBT_Time& bbt);
+       bool gui_change_tempo (TempoSection*, const Tempo& bpm);
+       void gui_dilate_tempo (MeterSection*, const framepos_t& frame);
+       void gui_dilate_tempo (const framepos_t& frame, const framepos_t& end_frame);
 
-       bool can_solve_bbt (TempoSection* section, const Tempo& bpm, const Timecode::BBT_Time& bbt);
+       bool can_solve_bbt (TempoSection* section, const Timecode::BBT_Time& bbt);
 
        void replace_meter (const MeterSection&, const Meter&, const Timecode::BBT_Time& where);
        void replace_meter (const MeterSection&, const Meter&, const framepos_t& frame);
@@ -394,13 +409,16 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
        framepos_t round_to_bar  (framepos_t frame, RoundMode dir);
        framepos_t round_to_beat (framepos_t frame, RoundMode dir);
        framepos_t round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir);
+       void round_bbt (Timecode::BBT_Time& when, const int32_t& snap_divisor, RoundMode dir);
 
        void set_length (framepos_t frames);
 
+       void fix_legacy_session();
+
        XMLNode& get_state (void);
        int set_state (const XMLNode&, int version);
 
-       void dump (Metrics& metrics, std::ostream&) const;
+       void dump (const Metrics& metrics, std::ostream&) const;
        void clear ();
 
        TempoMetric metric_at (Timecode::BBT_Time bbt) const;
@@ -423,35 +441,44 @@ class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 
        framecnt_t frame_rate () const { return _frame_rate; }
 
-       double bbt_to_beats (Timecode::BBT_Time bbt);
-       Timecode::BBT_Time beats_to_bbt (double beats);
-       Timecode::BBT_Time pulse_to_bbt (double pulse);
+       double bbt_to_beats (const Timecode::BBT_Time& bbt);
+       Timecode::BBT_Time beats_to_bbt (const double& beats);
+       Timecode::BBT_Time pulse_to_bbt (const double& pulse);
+
+       double pulse_at_beat (const double& beat) const;
+       double beat_at_pulse (const double& pulse) const;
+
+       double pulse_at_frame (const framecnt_t& frame) const;
+       framecnt_t frame_at_pulse (const double& pulse) const;
 
        PBD::Signal0<void> MetricPositionChanged;
 
 private:
-       double pulse_at_beat (const Metrics& metrics, const double& beat) const;
-       double beat_at_pulse (const Metrics& metrics, const double& pulse) const;
+       double pulse_at_beat_locked (const Metrics& metrics, const double& beat) const;
+       double beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
+       double pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const;
+       framecnt_t frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
+
        double beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const;
        framecnt_t frame_at_beat_locked (const Metrics& metrics, const double& beat) const;
        double bbt_to_beats_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const ;
        Timecode::BBT_Time beats_to_bbt_locked (const Metrics& metrics, const double& beats) const;
-       double pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const;
-       framecnt_t frame_at_pulse_locked (const Metrics& metrics, const double& beat) const;
-
-       double beat_offset_at (const Metrics& metrics, const double& beat) const;
-       frameoffset_t frame_offset_at (const Metrics& metrics, const framepos_t& frame) const;
 
        framepos_t frame_time_locked (const Metrics& metrics, const Timecode::BBT_Time&) const;
 
-       const MeterSection& meter_section_at_locked (framepos_t frame) const;
-       const TempoSection& tempo_section_at_locked (framepos_t frame) const;
+       const MeterSection& meter_section_at_locked (const Metrics& metrics, framepos_t frame) const;
+       const TempoSection& tempo_section_at_locked (const Metrics& metrics, framepos_t frame) const;
+       const MeterSection& meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
+       const TempoSection& tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
+       const TempoSection& tempo_section_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
+       const Tempo tempo_at_locked (const Metrics& metrics, const framepos_t& frame) const;
 
-       bool check_solved (Metrics& metrics, bool by_frame);
-       bool solve_map (Metrics& metrics, TempoSection* section, const Tempo& bpm, const framepos_t& frame);
-       bool solve_map (Metrics& metrics, TempoSection* section, const Tempo& bpm, const double& beat);
-       void solve_map (Metrics& metrics, MeterSection* section, const Meter& mt, const framepos_t& frame);
-       void solve_map (Metrics& metrics, MeterSection* section, const Meter& mt, const double& beat);
+       bool check_solved (const Metrics& metrics, bool by_frame) const;
+       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);
+       bool solve_map (Metrics& metrics, MeterSection* section, const framepos_t& frame);
+       bool solve_map (Metrics& metrics, MeterSection* section, const Timecode::BBT_Time& bbt);
 
        friend class ::BBTTest;
        friend class ::FrameposPlusBeatsTest;
@@ -477,16 +504,17 @@ private:
 
        void do_insert (MetricSection* section);
 
-       void add_tempo_locked (const Tempo&, double where, bool recompute, TempoSection::Type type);
-       void add_tempo_locked (const Tempo&, framepos_t frame, bool recompute, TempoSection::Type type);
+       TempoSection* add_tempo_locked (const Tempo&, double pulse, bool recompute, TempoSection::Type type);
+       TempoSection* add_tempo_locked (const Tempo&, framepos_t frame, bool recompute, TempoSection::Type type);
 
-       void add_meter_locked (const Meter&, double beat, Timecode::BBT_Time where, bool recompute);
-       void add_meter_locked (const Meter&, framepos_t frame, bool recompute);
+       MeterSection* add_meter_locked (const Meter&, double beat, const Timecode::BBT_Time& where, bool recompute);
+       MeterSection* add_meter_locked (const Meter&, framepos_t frame, double beat, const Timecode::BBT_Time& where, bool recompute);
 
        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 */