libs/ardour/ardour/tempo.h

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_tempo_h__
  21 #define __ardour_tempo_h__
  22
  23 #include <list>
  24 #include <string>
  25 #include <vector>
  26 #include <cmath>
  27 #include <glibmm/threads.h>
  28
  29 #include "pbd/undo.h"
  30
  31 #include "pbd/stateful.h"
  32 #include "pbd/statefuldestructible.h"
  33
  34 #include "evoral/Beats.hpp"
  35
  36 #include "ardour/ardour.h"
  37
  38 class BBTTest;
  39 class FrameposPlusBeatsTest;
  40 class FrameposMinusBeatsTest;
  41 class TempoTest;
  42 class XMLNode;
  43
  44 namespace ARDOUR {
  45
  46 class Meter;
  47 class TempoMap;
  48
  49 /** Tempo, the speed at which musical time progresses (BPM). */
  50 class LIBARDOUR_API Tempo {
  51   public:
  52         /**
  53          * @param npm Note Types per minute
  54          * @param type Note Type (default `4': quarter note)
  55          */
  56         Tempo (double npm, double type=4.0) // defaulting to quarter note
  57                 : _note_types_per_minute (npm), _note_type(type) {}
  58
  59         double note_types_per_minute () const { return _note_types_per_minute; }
  60         void set_note_types_per_minute (double npm) { _note_types_per_minute = npm; }
  61         double note_type () const { return _note_type; }
  62
  63         double note_divisions_per_minute (double note_type) const { return _note_types_per_minute * (note_type / _note_type); }
  64         double quarter_notes_per_minute () const { return note_divisions_per_minute (4.0); }
  65         double pulses_per_minute () const { return note_divisions_per_minute (1.0); }
  66         /** audio samples per note type.
  67          * if you want an instantaneous value for this, use TempoMap::frames_per_quarter_note_at() instead.
  68          * @param sr samplerate
  69          */
  70         double frames_per_note_type (framecnt_t sr) const {
  71                 return (60.0 * sr) / _note_types_per_minute;
  72         }
  73         /** audio samples per quarter note.
  74          * if you want an instantaneous value for this, use TempoMap::frames_per_quarter_note_at() instead.
  75          * @param sr samplerate
  76          */
  77         double frames_per_quarter_note (framecnt_t sr) const {
  78                 return (60.0 * sr) / quarter_notes_per_minute ();
  79         }
  80
  81   protected:
  82         double _note_types_per_minute;
  83         double _note_type;
  84 };
  85
  86 /** Meter, or time signature (beats per bar, and which note type is a beat). */
  87 class LIBARDOUR_API Meter {
  88   public:
  89         Meter (double dpb, double bt)
  90                 : _divisions_per_bar (dpb), _note_type (bt) {}
  91
  92         double divisions_per_bar () const { return _divisions_per_bar; }
  93         double note_divisor() const { return _note_type; }
  94
  95         double frames_per_bar (const Tempo&, framecnt_t sr) const;
  96         double frames_per_grid (const Tempo&, framecnt_t sr) const;
  97
  98   protected:
  99         /** The number of divisions in a bar.  This is a floating point value because
 100             there are musical traditions on our planet that do not limit
 101             themselves to integral numbers of beats per bar.
 102         */
 103         double _divisions_per_bar;
 104
 105         /** The type of "note" that a division represents.  For example, 4.0 is
 106             a quarter (crotchet) note, 8.0 is an eighth (quaver) note, etc.
 107         */
 108         double _note_type;
 109 };
 110
 111 /** A section of timeline with a certain Tempo or Meter. */
 112 class LIBARDOUR_API MetricSection {
 113   public:
 114         MetricSection (double pulse, double minute, PositionLockStyle pls, bool is_tempo, framecnt_t sample_rate)
 115                 : _pulse (pulse), _minute (minute), _movable (true), _position_lock_style (pls), _is_tempo (is_tempo), _sample_rate (sample_rate) {}
 116
 117         virtual ~MetricSection() {}
 118
 119         const double& pulse () const { return _pulse; }
 120         void set_pulse (double pulse) { _pulse = pulse; }
 121
 122         double minute() const { return _minute; }
 123         virtual void set_minute (double m) {
 124                 _minute = m;
 125         }
 126
 127         framepos_t frame () const { return frame_at_minute (_minute); }
 128
 129         void set_movable (bool yn) { _movable = yn; }
 130         bool movable() const { return _movable; }
 131
 132         /* MeterSections are not stateful in the full sense,
 133            but we do want them to control their own
 134            XML state information.
 135         */
 136         virtual XMLNode& get_state() const = 0;
 137
 138         PositionLockStyle position_lock_style () const { return _position_lock_style; }
 139         void set_position_lock_style (PositionLockStyle ps) { _position_lock_style = ps; }
 140         bool is_tempo () const { return _is_tempo; }
 141
 142         framepos_t frame_at_minute (const double& time) const;
 143         double minute_at_frame (const framepos_t& frame) const;
 144
 145 private:
 146
 147         double             _pulse;
 148         double             _minute;
 149         bool               _movable;
 150         PositionLockStyle  _position_lock_style;
 151         const bool         _is_tempo;
 152         framecnt_t         _sample_rate;
 153 };
 154
 155 /** A section of timeline with a certain Meter. */
 156 class LIBARDOUR_API MeterSection : public MetricSection, public Meter {
 157   public:
 158         MeterSection (double pulse, double minute, double beat, const Timecode::BBT_Time& bbt, double bpb, double note_type, PositionLockStyle pls, framecnt_t sr)
 159                 : MetricSection (pulse, minute, pls, false, sr), Meter (bpb, note_type), _bbt (bbt),  _beat (beat) {}
 160
 161         MeterSection (const XMLNode&, const framecnt_t sample_rate);
 162
 163         static const std::string xml_state_node_name;
 164
 165         XMLNode& get_state() const;
 166
 167         void set_beat (std::pair<double, Timecode::BBT_Time>& w) {
 168                 _beat = w.first;
 169                 _bbt = w.second;
 170         }
 171
 172         const Timecode::BBT_Time& bbt() const { return _bbt; }
 173         const double& beat () const { return _beat; }
 174         void set_beat (double beat) { _beat = beat; }
 175
 176 private:
 177         Timecode::BBT_Time _bbt;
 178         double _beat;
 179 };
 180
 181 /** A section of timeline with a certain Tempo. */
 182 class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
 183   public:
 184         enum Type {
 185                 Ramp,
 186                 Constant,
 187         };
 188
 189         TempoSection (const double& pulse, const double& minute, double qpm, double note_type, Type tempo_type, PositionLockStyle pls, framecnt_t sr)
 190                 : MetricSection (pulse, minute, pls, true, sr), Tempo (qpm, note_type), _type (tempo_type), _c_func (0.0), _active (true), _locked_to_meter (false)  {}
 191
 192         TempoSection (const XMLNode&, const framecnt_t sample_rate);
 193
 194         static const std::string xml_state_node_name;
 195
 196         XMLNode& get_state() const;
 197
 198         double c_func () const { return _c_func; }
 199         void set_c_func (double c_func) { _c_func = c_func; }
 200
 201         void set_type (Type type);
 202         Type type () const { return _type; }
 203
 204         bool active () const { return _active; }
 205         void set_active (bool yn) { _active = yn; }
 206
 207         bool locked_to_meter ()  const { return _locked_to_meter; }
 208         void set_locked_to_meter (bool yn) { _locked_to_meter = yn; }
 209
 210         double tempo_at_minute (const double& minute) const;
 211         double minute_at_tempo (const double& bpm, const double& pulse) const;
 212
 213         double tempo_at_pulse (const double& pulse) const;
 214         double pulse_at_tempo (const double& bpm, const double& minute) const;
 215
 216         double pulse_at_minute (const double& minute) const;
 217         double minute_at_pulse (const double& pulse) const;
 218
 219         double compute_c_func_pulse (const double& end_bpm, const double& end_pulse) const;
 220         double compute_c_func_minute (const double& end_bpm, const double& end_minute) const;
 221
 222         Timecode::BBT_Time legacy_bbt () { return _legacy_bbt; }
 223
 224   private:
 225
 226         /*  tempo ramp functions. zero-based with time in minutes,
 227          * 'tick tempo' in ticks per minute and tempo in bpm.
 228          *  time relative to section start.
 229          */
 230         double a_func (double end_tpm, double c_func) const;
 231         double c_func (double end_tpm, double end_time) const;
 232
 233         double _tempo_at_time (const double& time) const;
 234         double _time_at_tempo (const double& tempo) const;
 235
 236         double _tempo_at_pulse (const double& pulse) const;
 237         double _pulse_at_tempo (const double& tempo) const;
 238
 239         double _pulse_at_time (const double& time) const;
 240         double _time_at_pulse (const double& pulse) const;
 241
 242         /* this value provides a fractional offset into the bar in which
 243            the tempo section is located in. A value of 0.0 indicates that
 244            it occurs on the first beat of the bar, a value of 0.5 indicates
 245            that it occurs halfway through the bar and so on.
 246
 247            this enables us to keep the tempo change at the same relative
 248            position within the bar if/when the meter changes.
 249         */
 250         Type _type;
 251         double _c_func;
 252         bool _active;
 253         bool _locked_to_meter;
 254         Timecode::BBT_Time _legacy_bbt;
 255 };
 256
 257 typedef std::list<MetricSection*> Metrics;
 258
 259 /** Helper class to keep track of the Meter *AND* Tempo in effect
 260     at a given point in time.
 261 */
 262 class LIBARDOUR_API TempoMetric {
 263   public:
 264         TempoMetric (const Meter& m, const Tempo& t)
 265                 : _meter (&m), _tempo (&t), _minute (0.0), _pulse (0.0) {}
 266
 267         void set_tempo (const Tempo& t)              { _tempo = &t; }
 268         void set_meter (const Meter& m)              { _meter = &m; }
 269         void set_minute (double m)                   { _minute = m; }
 270         void set_pulse (const double& p)             { _pulse = p; }
 271
 272         void set_metric (const MetricSection* section) {
 273                 const MeterSection* meter;
 274                 const TempoSection* tempo;
 275                 if ((meter = dynamic_cast<const MeterSection*>(section))) {
 276                         set_meter(*meter);
 277                 } else if ((tempo = dynamic_cast<const TempoSection*>(section))) {
 278                         set_tempo(*tempo);
 279                 }
 280
 281                 set_minute (section->minute());
 282                 set_pulse (section->pulse());
 283         }
 284
 285         const Meter&              meter() const { return *_meter; }
 286         const Tempo&              tempo() const { return *_tempo; }
 287         double                    minute() const { return _minute; }
 288         const double&             pulse() const { return _pulse; }
 289
 290   private:
 291         const Meter*       _meter;
 292         const Tempo*       _tempo;
 293         double             _minute;
 294         double             _pulse;
 295 };
 296
 297 /** Tempo Map - mapping of timecode to musical time.
 298  * convert audio-samples, sample-rate to Bar/Beat/Tick, Meter/Tempo
 299  */
 300 class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 301 {
 302   public:
 303         TempoMap (framecnt_t frame_rate);
 304         ~TempoMap();
 305
 306         /* measure-based stuff */
 307
 308         enum BBTPointType {
 309                 Bar,
 310                 Beat,
 311         };
 312
 313         struct BBTPoint {
 314                 framepos_t          frame;
 315                 Meter               meter;
 316                 Tempo               tempo;
 317                 double              c;
 318                 uint32_t            bar;
 319                 uint32_t            beat;
 320
 321                 BBTPoint (const MeterSection& m, const Tempo& t, framepos_t f,
 322                           uint32_t b, uint32_t e, double func_c)
 323                 : frame (f), meter (m.divisions_per_bar(), m.note_divisor()), tempo (t.note_types_per_minute(), t.note_type()), c (func_c), bar (b), beat (e) {}
 324
 325                 Timecode::BBT_Time bbt() const { return Timecode::BBT_Time (bar, beat, 0); }
 326                 operator Timecode::BBT_Time() const { return bbt(); }
 327                 operator framepos_t() const { return frame; }
 328                 bool is_bar() const { return beat == 1; }
 329         };
 330
 331         template<class T> void apply_with_metrics (T& obj, void (T::*method)(const Metrics&)) {
 332                 Glib::Threads::RWLock::ReaderLock lm (lock);
 333                 (obj.*method)(_metrics);
 334         }
 335
 336         void get_grid (std::vector<BBTPoint>&,
 337                        framepos_t start, framepos_t end, uint32_t bar_mod = 0);
 338
 339         static const Tempo& default_tempo() { return _default_tempo; }
 340         static const Meter& default_meter() { return _default_meter; }
 341
 342         /* because tempi may be ramped, this is only valid for the instant requested.*/
 343         double frames_per_quarter_note_at (const framepos_t&, const framecnt_t& sr) const;
 344
 345         const TempoSection& tempo_section_at_frame (framepos_t frame) const;
 346         const MeterSection& meter_section_at_frame (framepos_t frame) const;
 347         const MeterSection& meter_section_at_beat (double beat) const;
 348
 349         /** add a tempo section locked to pls. ignored values will be set in recompute_tempi()
 350          * @param pulse pulse position of new section. ignored if pls == AudioTime
 351          * @param frame frame position of new section. ignored if pls == MusicTime
 352          * @param type type of new tempo section (Ramp, Constant)
 353          */
 354         TempoSection* add_tempo (const Tempo&, const double& pulse, const framepos_t& frame, TempoSection::Type type, PositionLockStyle pls);
 355
 356         /** add an meter section locked to pls.. ignored values will be set in recompute_meters()
 357          * @param beat beat position of new section
 358          * @param where bbt position of new section
 359          * @param frame frame position of new section. ignored if pls == MusicTime
 360          */
 361         MeterSection* add_meter (const Meter&, const double& beat, const Timecode::BBT_Time& where, PositionLockStyle pls);
 362
 363         void remove_tempo (const TempoSection&, bool send_signal);
 364         void remove_meter (const MeterSection&, bool send_signal);
 365
 366         void replace_tempo (const TempoSection&, const Tempo&, const double& pulse, const framepos_t& frame
 367                             , TempoSection::Type type, PositionLockStyle pls);
 368
 369         void replace_meter (const MeterSection&, const Meter&, const Timecode::BBT_Time& where, PositionLockStyle pls);
 370
 371         framepos_t round_to_bar  (framepos_t frame, RoundMode dir);
 372         framepos_t round_to_beat (framepos_t frame, RoundMode dir);
 373         framepos_t round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 374         framepos_t round_to_quarter_note_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 375
 376         void set_length (framepos_t frames);
 377
 378         XMLNode& get_state (void);
 379         int set_state (const XMLNode&, int version);
 380
 381         void dump (const Metrics& metrics, std::ostream&) const;
 382         void clear ();
 383
 384         TempoMetric metric_at (Timecode::BBT_Time bbt) const;
 385
 386         /** Return the TempoMetric at frame @p t, and point @p last to the latest
 387          * metric change <= t, if it is non-NULL.
 388          */
 389         TempoMetric metric_at (framepos_t, Metrics::const_iterator* last=NULL) const;
 390
 391         Metrics::const_iterator metrics_end() { return _metrics.end(); }
 392
 393         void change_existing_tempo_at (framepos_t, double bpm, double note_type);
 394         void change_initial_tempo (double bpm, double note_type);
 395
 396         void insert_time (framepos_t, framecnt_t);
 397         bool remove_time (framepos_t where, framecnt_t amount);  //returns true if anything was moved
 398
 399         int n_tempos () const;
 400         int n_meters () const;
 401
 402         framecnt_t frame_rate () const { return _frame_rate; }
 403
 404         /* TEMPO- AND METER-SENSITIVE FUNCTIONS
 405
 406            bbt_at_frame(), frame_at_bbt(), beat_at_frame(), frame_at_beat()
 407            and bbt_duration_at()
 408            are all sensitive to tempo and meter, and will give answers
 409            that align with the grid formed by tempo and meter sections.
 410
 411            They SHOULD NOT be used to determine the position of events
 412            whose location is canonically defined in Evoral::Beats.
 413         */
 414
 415         double beat_at_frame (const framecnt_t& frame) const;
 416         framepos_t frame_at_beat (const double& beat) const;
 417
 418         const Meter& meter_at_frame (framepos_t) const;
 419
 420         /* bbt - it's nearly always better to use meter-based beat (above)
 421            unless tick resolution is desirable.
 422         */
 423         Timecode::BBT_Time bbt_at_frame (framepos_t when);
 424         Timecode::BBT_Time bbt_at_frame_rt (framepos_t when);
 425         framepos_t frame_at_bbt (const Timecode::BBT_Time&);
 426
 427         double beat_at_bbt (const Timecode::BBT_Time& bbt);
 428         Timecode::BBT_Time bbt_at_beat (const double& beats);
 429
 430         double quarter_note_at_bbt (const Timecode::BBT_Time& bbt);
 431         double quarter_note_at_bbt_rt (const Timecode::BBT_Time& bbt);
 432         Timecode::BBT_Time bbt_at_quarter_note (const double& quarter_note);
 433
 434         framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
 435         framepos_t framepos_plus_bbt (framepos_t pos, Timecode::BBT_Time b) const;
 436
 437         /* TEMPO-SENSITIVE FUNCTIONS
 438
 439            These next 2 functions will all take tempo in account and should be
 440            used to determine position (and in the last case, distance in beats)
 441            when tempo matters but meter does not.
 442
 443            They SHOULD be used to determine the position of events
 444            whose location is canonically defined in Evoral::Beats.
 445         */
 446
 447         framepos_t framepos_plus_qn (framepos_t, Evoral::Beats) const;
 448         Evoral::Beats framewalk_to_qn (framepos_t pos, framecnt_t distance) const;
 449
 450         /* quarter note related functions are also tempo-sensitive and ignore meter.
 451            quarter notes may be compared with and assigned to Evoral::Beats.
 452         */
 453         double quarter_note_at_frame (const framepos_t frame);
 454         double quarter_note_at_frame_rt (const framepos_t frame);
 455         framepos_t frame_at_quarter_note (const double quarter_note);
 456
 457         framecnt_t frames_between_quarter_notes (const double start, const double end);
 458
 459         double quarter_note_at_beat (const double beat);
 460         double beat_at_quarter_note (const double beat);
 461
 462         /* obtain a musical subdivision via a frame position and magic note divisor.*/
 463         double exact_qn_at_frame (const framepos_t& frame, const int32_t sub_num);
 464         double exact_beat_at_frame (const framepos_t& frame, const int32_t sub_num);
 465
 466         Tempo tempo_at_frame (const framepos_t& frame) const;
 467         framepos_t frame_at_tempo (const Tempo& tempo) const;
 468         Tempo tempo_at_quarter_note (const double& beat) const;
 469         double quarter_note_at_tempo (const Tempo& tempo) const;
 470
 471         void gui_move_tempo (TempoSection*, const framepos_t& frame, const int& sub_num);
 472         void gui_move_meter (MeterSection*, const framepos_t& frame);
 473         bool gui_change_tempo (TempoSection*, const Tempo& bpm);
 474         void gui_dilate_tempo (TempoSection* tempo, const framepos_t& frame, const framepos_t& end_frame);
 475
 476         std::pair<double, framepos_t> predict_tempo_position (TempoSection* section, const Timecode::BBT_Time& bbt);
 477         bool can_solve_bbt (TempoSection* section, const Timecode::BBT_Time& bbt);
 478
 479         PBD::Signal0<void> MetricPositionChanged;
 480         void fix_legacy_session();
 481
 482 private:
 483
 484         double beat_at_minute_locked (const Metrics& metrics, const double& minute) const;
 485         double minute_at_beat_locked (const Metrics& metrics, const double& beat) const;
 486
 487         double pulse_at_beat_locked (const Metrics& metrics, const double& beat) const;
 488         double beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 489
 490         double pulse_at_minute_locked (const Metrics& metrics, const double& minute) const;
 491         double minute_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 492
 493         Tempo tempo_at_minute_locked (const Metrics& metrics, const double& minute) const;
 494         double minute_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 495
 496         Tempo tempo_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 497         double pulse_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 498
 499         Timecode::BBT_Time bbt_at_minute_locked (const Metrics& metrics, const double& minute) const;
 500         double minute_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time&) const;
 501
 502         double beat_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const ;
 503         Timecode::BBT_Time bbt_at_beat_locked (const Metrics& metrics, const double& beats) const;
 504
 505         double pulse_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const;
 506         Timecode::BBT_Time bbt_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 507
 508         double minute_at_quarter_note_locked (const Metrics& metrics, const double quarter_note) const;
 509         double quarter_note_at_minute_locked (const Metrics& metrics, const double minute) const;
 510
 511         double quarter_note_at_beat_locked (const Metrics& metrics, const double beat) const;
 512         double beat_at_quarter_note_locked (const Metrics& metrics, const double beat) const;
 513
 514         double minutes_between_quarter_notes_locked (const Metrics& metrics, const double start_qn, const double end_qn);
 515
 516         const TempoSection& tempo_section_at_minute_locked (const Metrics& metrics, double minute) const;
 517         const TempoSection& tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 518
 519         const MeterSection& meter_section_at_minute_locked (const Metrics& metrics, double minute) const;
 520         const MeterSection& meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 521
 522         bool check_solved (const Metrics& metrics) const;
 523         bool set_active_tempos (const Metrics& metrics, const framepos_t& frame);
 524
 525         bool solve_map_minute (Metrics& metrics, TempoSection* section, const double& minute);
 526         bool solve_map_pulse (Metrics& metrics, TempoSection* section, const double& pulse);
 527         bool solve_map_minute (Metrics& metrics, MeterSection* section, const double& minute);
 528         bool solve_map_bbt (Metrics& metrics, MeterSection* section, const Timecode::BBT_Time& bbt);
 529
 530         double exact_beat_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num);
 531         double exact_qn_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num);
 532
 533         double minute_at_frame (const framepos_t frame) const;
 534         framepos_t frame_at_minute (const double minute) const;
 535
 536         friend class ::BBTTest;
 537         friend class ::FrameposPlusBeatsTest;
 538         friend class ::FrameposMinusBeatsTest;
 539         friend class ::TempoTest;
 540
 541         static Tempo    _default_tempo;
 542         static Meter    _default_meter;
 543
 544         Metrics                       _metrics;
 545         framecnt_t                    _frame_rate;
 546         mutable Glib::Threads::RWLock lock;
 547
 548         void recompute_tempi (Metrics& metrics);
 549         void recompute_meters (Metrics& metrics);
 550         void recompute_map (Metrics& metrics, framepos_t end = -1);
 551
 552         framepos_t round_to_type (framepos_t fr, RoundMode dir, BBTPointType);
 553
 554         const MeterSection& first_meter() const;
 555         MeterSection&       first_meter();
 556         const TempoSection& first_tempo() const;
 557         TempoSection&       first_tempo();
 558
 559         void do_insert (MetricSection* section);
 560
 561         TempoSection* add_tempo_locked (const Tempo&, double pulse, double minute
 562                                , TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter = false);
 563
 564         MeterSection* add_meter_locked (const Meter&, double beat, const Timecode::BBT_Time& where, PositionLockStyle pls, bool recompute);
 565
 566         bool remove_tempo_locked (const TempoSection&);
 567         bool remove_meter_locked (const MeterSection&);
 568
 569         TempoSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section);
 570         MeterSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section);
 571 };
 572
 573 }; /* namespace ARDOUR */
 574
 575 std::ostream& operator<< (std::ostream&, const ARDOUR::Meter&);
 576 std::ostream& operator<< (std::ostream&, const ARDOUR::Tempo&);
 577 std::ostream& operator<< (std::ostream&, const ARDOUR::MetricSection&);
 578
 579 #endif /* __ardour_tempo_h__ */