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         double note_types_per_minute (double note_type) const { return (_note_types_per_minute / _note_type) * note_type; }
  61         void set_note_types_per_minute (double npm) { _note_types_per_minute = npm; }
  62         double note_type () const { return _note_type; }
  63
  64         double quarter_notes_per_minute () const { return note_types_per_minute (4.0); }
  65         double pulses_per_minute () const { return note_types_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         Tempo tempo_at_minute (const double& minute) const;
 211         double minute_at_ntpm (const double& ntpm, const double& pulse) const;
 212
 213         Tempo tempo_at_pulse (const double& pulse) const;
 214         double pulse_at_ntpm (const double& ntpm, 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_ntpm, const double& end_pulse) const;
 220         double compute_c_func_minute (const double& end_ntpm, const double& end_minute) const;
 221
 222         double pulse_at_frame (const framepos_t& frame) const;
 223         framepos_t frame_at_pulse (const double& pulse) const;
 224
 225         Timecode::BBT_Time legacy_bbt () { return _legacy_bbt; }
 226
 227   private:
 228
 229         /*  tempo ramp functions. zero-based with time in minutes,
 230          * 'tick tempo' in ticks per minute and tempo in bpm.
 231          *  time relative to section start.
 232          */
 233         double a_func (double end_tpm, double c_func) const;
 234         double c_func (double end_tpm, double end_time) const;
 235
 236         double _tempo_at_time (const double& time) const;
 237         double _time_at_tempo (const double& tempo) const;
 238
 239         double _tempo_at_pulse (const double& pulse) const;
 240         double _pulse_at_tempo (const double& tempo) const;
 241
 242         double _pulse_at_time (const double& time) const;
 243         double _time_at_pulse (const double& pulse) const;
 244
 245         /* this value provides a fractional offset into the bar in which
 246            the tempo section is located in. A value of 0.0 indicates that
 247            it occurs on the first beat of the bar, a value of 0.5 indicates
 248            that it occurs halfway through the bar and so on.
 249
 250            this enables us to keep the tempo change at the same relative
 251            position within the bar if/when the meter changes.
 252         */
 253         Type _type;
 254         double _c_func;
 255         bool _active;
 256         bool _locked_to_meter;
 257         Timecode::BBT_Time _legacy_bbt;
 258 };
 259
 260 typedef std::list<MetricSection*> Metrics;
 261
 262 /** Helper class to keep track of the Meter *AND* Tempo in effect
 263     at a given point in time.
 264 */
 265 class LIBARDOUR_API TempoMetric {
 266   public:
 267         TempoMetric (const Meter& m, const Tempo& t)
 268                 : _meter (&m), _tempo (&t), _minute (0.0), _pulse (0.0) {}
 269
 270         void set_tempo (const Tempo& t)              { _tempo = &t; }
 271         void set_meter (const Meter& m)              { _meter = &m; }
 272         void set_minute (double m)                   { _minute = m; }
 273         void set_pulse (const double& p)             { _pulse = p; }
 274
 275         void set_metric (const MetricSection* section) {
 276                 const MeterSection* meter;
 277                 const TempoSection* tempo;
 278                 if ((meter = dynamic_cast<const MeterSection*>(section))) {
 279                         set_meter(*meter);
 280                 } else if ((tempo = dynamic_cast<const TempoSection*>(section))) {
 281                         set_tempo(*tempo);
 282                 }
 283
 284                 set_minute (section->minute());
 285                 set_pulse (section->pulse());
 286         }
 287
 288         const Meter&              meter() const { return *_meter; }
 289         const Tempo&              tempo() const { return *_tempo; }
 290         double                    minute() const { return _minute; }
 291         const double&             pulse() const { return _pulse; }
 292
 293   private:
 294         const Meter*       _meter;
 295         const Tempo*       _tempo;
 296         double             _minute;
 297         double             _pulse;
 298 };
 299
 300 /** Tempo Map - mapping of timecode to musical time.
 301  * convert audio-samples, sample-rate to Bar/Beat/Tick, Meter/Tempo
 302  */
 303 class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
 304 {
 305   public:
 306         TempoMap (framecnt_t frame_rate);
 307         ~TempoMap();
 308
 309         /* measure-based stuff */
 310
 311         enum BBTPointType {
 312                 Bar,
 313                 Beat,
 314         };
 315
 316         struct BBTPoint {
 317                 framepos_t          frame;
 318                 Meter               meter;
 319                 Tempo               tempo;
 320                 double              c;
 321                 uint32_t            bar;
 322                 uint32_t            beat;
 323
 324                 BBTPoint (const MeterSection& m, const Tempo& t, framepos_t f,
 325                           uint32_t b, uint32_t e, double func_c)
 326                 : 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) {}
 327
 328                 Timecode::BBT_Time bbt() const { return Timecode::BBT_Time (bar, beat, 0); }
 329                 operator Timecode::BBT_Time() const { return bbt(); }
 330                 operator framepos_t() const { return frame; }
 331                 bool is_bar() const { return beat == 1; }
 332         };
 333
 334         template<class T> void apply_with_metrics (T& obj, void (T::*method)(const Metrics&)) {
 335                 Glib::Threads::RWLock::ReaderLock lm (lock);
 336                 (obj.*method)(_metrics);
 337         }
 338
 339         void get_grid (std::vector<BBTPoint>&,
 340                        framepos_t start, framepos_t end, uint32_t bar_mod = 0);
 341
 342         static const Tempo& default_tempo() { return _default_tempo; }
 343         static const Meter& default_meter() { return _default_meter; }
 344
 345         /* because tempi may be ramped, this is only valid for the instant requested.*/
 346         double frames_per_quarter_note_at (const framepos_t&, const framecnt_t& sr) const;
 347
 348         const TempoSection& tempo_section_at_frame (framepos_t frame) const;
 349         const MeterSection& meter_section_at_frame (framepos_t frame) const;
 350         const MeterSection& meter_section_at_beat (double beat) const;
 351
 352         /** add a tempo section locked to pls. ignored values will be set in recompute_tempi()
 353          * @param pulse pulse position of new section. ignored if pls == AudioTime
 354          * @param frame frame position of new section. ignored if pls == MusicTime
 355          * @param type type of new tempo section (Ramp, Constant)
 356          */
 357         TempoSection* add_tempo (const Tempo&, const double& pulse, const framepos_t& frame, TempoSection::Type type, PositionLockStyle pls);
 358
 359         /** add an meter section locked to pls.. ignored values will be set in recompute_meters()
 360          * @param beat beat position of new section
 361          * @param where bbt position of new section
 362          * @param frame frame position of new section. ignored if pls == MusicTime
 363          */
 364         MeterSection* add_meter (const Meter&, const double& beat, const Timecode::BBT_Time& where, PositionLockStyle pls);
 365
 366         void remove_tempo (const TempoSection&, bool send_signal);
 367         void remove_meter (const MeterSection&, bool send_signal);
 368
 369         void replace_tempo (const TempoSection&, const Tempo&, const double& pulse, const framepos_t& frame
 370                             , TempoSection::Type type, PositionLockStyle pls);
 371
 372         void replace_meter (const MeterSection&, const Meter&, const Timecode::BBT_Time& where, PositionLockStyle pls);
 373
 374         framepos_t round_to_bar  (framepos_t frame, RoundMode dir);
 375         framepos_t round_to_beat (framepos_t frame, RoundMode dir);
 376         framepos_t round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 377         framepos_t round_to_quarter_note_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 378
 379         void set_length (framepos_t frames);
 380
 381         XMLNode& get_state (void);
 382         int set_state (const XMLNode&, int version);
 383
 384         void dump (const Metrics& metrics, std::ostream&) const;
 385         void clear ();
 386
 387         TempoMetric metric_at (Timecode::BBT_Time bbt) const;
 388
 389         /** Return the TempoMetric at frame @p t, and point @p last to the latest
 390          * metric change <= t, if it is non-NULL.
 391          */
 392         TempoMetric metric_at (framepos_t, Metrics::const_iterator* last=NULL) const;
 393
 394         Metrics::const_iterator metrics_end() { return _metrics.end(); }
 395
 396         void change_existing_tempo_at (framepos_t, double bpm, double note_type);
 397         void change_initial_tempo (double bpm, double note_type);
 398
 399         void insert_time (framepos_t, framecnt_t);
 400         bool remove_time (framepos_t where, framecnt_t amount);  //returns true if anything was moved
 401
 402         int n_tempos () const;
 403         int n_meters () const;
 404
 405         framecnt_t frame_rate () const { return _frame_rate; }
 406
 407         /* TEMPO- AND METER-SENSITIVE FUNCTIONS
 408
 409            bbt_at_frame(), frame_at_bbt(), beat_at_frame(), frame_at_beat()
 410            and bbt_duration_at()
 411            are all sensitive to tempo and meter, and will give answers
 412            that align with the grid formed by tempo and meter sections.
 413
 414            They SHOULD NOT be used to determine the position of events
 415            whose location is canonically defined in Evoral::Beats.
 416         */
 417
 418         double beat_at_frame (const framecnt_t& frame) const;
 419         framepos_t frame_at_beat (const double& beat) const;
 420
 421         const Meter& meter_at_frame (framepos_t) const;
 422
 423         /* bbt - it's nearly always better to use meter-based beat (above)
 424            unless tick resolution is desirable.
 425         */
 426         Timecode::BBT_Time bbt_at_frame (framepos_t when);
 427         Timecode::BBT_Time bbt_at_frame_rt (framepos_t when);
 428         framepos_t frame_at_bbt (const Timecode::BBT_Time&);
 429
 430         double beat_at_bbt (const Timecode::BBT_Time& bbt);
 431         Timecode::BBT_Time bbt_at_beat (const double& beats);
 432
 433         double quarter_note_at_bbt (const Timecode::BBT_Time& bbt);
 434         double quarter_note_at_bbt_rt (const Timecode::BBT_Time& bbt);
 435         Timecode::BBT_Time bbt_at_quarter_note (const double& quarter_note);
 436
 437         framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
 438         framepos_t framepos_plus_bbt (framepos_t pos, Timecode::BBT_Time b) const;
 439
 440         /* TEMPO-SENSITIVE FUNCTIONS
 441
 442            These next 2 functions will all take tempo in account and should be
 443            used to determine position (and in the last case, distance in beats)
 444            when tempo matters but meter does not.
 445
 446            They SHOULD be used to determine the position of events
 447            whose location is canonically defined in Evoral::Beats.
 448         */
 449
 450         framepos_t framepos_plus_qn (framepos_t, Evoral::Beats) const;
 451         Evoral::Beats framewalk_to_qn (framepos_t pos, framecnt_t distance) const;
 452
 453         /* quarter note related functions are also tempo-sensitive and ignore meter.
 454            quarter notes may be compared with and assigned to Evoral::Beats.
 455         */
 456         double quarter_note_at_frame (const framepos_t frame) const;
 457         double quarter_note_at_frame_rt (const framepos_t frame) const;
 458         framepos_t frame_at_quarter_note (const double quarter_note) const;
 459
 460         framecnt_t frames_between_quarter_notes (const double start, const double end) const;
 461         double     quarter_notes_between_frames (const framecnt_t start, const framecnt_t end) const;
 462
 463         double quarter_note_at_beat (const double beat);
 464         double beat_at_quarter_note (const double beat);
 465
 466         /* obtain a musical subdivision via a frame position and magic note divisor.*/
 467         double exact_qn_at_frame (const framepos_t& frame, const int32_t sub_num);
 468         double exact_beat_at_frame (const framepos_t& frame, const int32_t sub_num);
 469
 470         Tempo tempo_at_frame (const framepos_t& frame) const;
 471         framepos_t frame_at_tempo (const Tempo& tempo) const;
 472         Tempo tempo_at_quarter_note (const double& beat) const;
 473         double quarter_note_at_tempo (const Tempo& tempo) const;
 474
 475         void gui_move_tempo (TempoSection*, const framepos_t& frame, const int& sub_num);
 476         void gui_move_meter (MeterSection*, const framepos_t& frame);
 477         bool gui_change_tempo (TempoSection*, const Tempo& bpm);
 478         void gui_dilate_tempo (TempoSection* tempo, const framepos_t& frame, const framepos_t& end_frame);
 479
 480         std::pair<double, framepos_t> predict_tempo_position (TempoSection* section, const Timecode::BBT_Time& bbt);
 481         bool can_solve_bbt (TempoSection* section, const Timecode::BBT_Time& bbt);
 482
 483         PBD::Signal0<void> MetricPositionChanged;
 484         void fix_legacy_session();
 485
 486 private:
 487
 488         double beat_at_minute_locked (const Metrics& metrics, const double& minute) const;
 489         double minute_at_beat_locked (const Metrics& metrics, const double& beat) const;
 490
 491         double pulse_at_beat_locked (const Metrics& metrics, const double& beat) const;
 492         double beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 493
 494         double pulse_at_minute_locked (const Metrics& metrics, const double& minute) const;
 495         double minute_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 496
 497         Tempo tempo_at_minute_locked (const Metrics& metrics, const double& minute) const;
 498         double minute_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 499
 500         Tempo tempo_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 501         double pulse_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 502
 503         Timecode::BBT_Time bbt_at_minute_locked (const Metrics& metrics, const double& minute) const;
 504         double minute_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time&) const;
 505
 506         double beat_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const ;
 507         Timecode::BBT_Time bbt_at_beat_locked (const Metrics& metrics, const double& beats) const;
 508
 509         double pulse_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const;
 510         Timecode::BBT_Time bbt_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 511
 512         double minute_at_quarter_note_locked (const Metrics& metrics, const double quarter_note) const;
 513         double quarter_note_at_minute_locked (const Metrics& metrics, const double minute) const;
 514
 515         double quarter_note_at_beat_locked (const Metrics& metrics, const double beat) const;
 516         double beat_at_quarter_note_locked (const Metrics& metrics, const double beat) const;
 517
 518         double minutes_between_quarter_notes_locked (const Metrics& metrics, const double start_qn, const double end_qn) const;
 519         double quarter_notes_between_frames_locked (const Metrics& metrics, const framecnt_t  start, const framecnt_t end) const;
 520
 521         const TempoSection& tempo_section_at_minute_locked (const Metrics& metrics, double minute) const;
 522         const TempoSection& tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 523
 524         const MeterSection& meter_section_at_minute_locked (const Metrics& metrics, double minute) const;
 525         const MeterSection& meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 526
 527         bool check_solved (const Metrics& metrics) const;
 528         bool set_active_tempos (const Metrics& metrics, const framepos_t& frame);
 529
 530         bool solve_map_minute (Metrics& metrics, TempoSection* section, const double& minute);
 531         bool solve_map_pulse (Metrics& metrics, TempoSection* section, const double& pulse);
 532         bool solve_map_minute (Metrics& metrics, MeterSection* section, const double& minute);
 533         bool solve_map_bbt (Metrics& metrics, MeterSection* section, const Timecode::BBT_Time& bbt);
 534
 535         double exact_beat_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num);
 536         double exact_qn_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num);
 537
 538         double minute_at_frame (const framepos_t frame) const;
 539         framepos_t frame_at_minute (const double minute) const;
 540
 541         friend class ::BBTTest;
 542         friend class ::FrameposPlusBeatsTest;
 543         friend class ::FrameposMinusBeatsTest;
 544         friend class ::TempoTest;
 545
 546         static Tempo    _default_tempo;
 547         static Meter    _default_meter;
 548
 549         Metrics                       _metrics;
 550         framecnt_t                    _frame_rate;
 551         mutable Glib::Threads::RWLock lock;
 552
 553         void recompute_tempi (Metrics& metrics);
 554         void recompute_meters (Metrics& metrics);
 555         void recompute_map (Metrics& metrics, framepos_t end = -1);
 556
 557         framepos_t round_to_type (framepos_t fr, RoundMode dir, BBTPointType);
 558
 559         const MeterSection& first_meter() const;
 560         MeterSection&       first_meter();
 561         const TempoSection& first_tempo() const;
 562         TempoSection&       first_tempo();
 563
 564         void do_insert (MetricSection* section);
 565
 566         TempoSection* add_tempo_locked (const Tempo&, double pulse, double minute
 567                                , TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter = false);
 568
 569         MeterSection* add_meter_locked (const Meter&, double beat, const Timecode::BBT_Time& where, PositionLockStyle pls, bool recompute);
 570
 571         bool remove_tempo_locked (const TempoSection&);
 572         bool remove_meter_locked (const MeterSection&);
 573
 574         TempoSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section);
 575         MeterSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section);
 576 };
 577
 578 }; /* namespace ARDOUR */
 579
 580 std::ostream& operator<< (std::ostream&, const ARDOUR::Meter&);
 581 std::ostream& operator<< (std::ostream&, const ARDOUR::Tempo&);
 582 std::ostream& operator<< (std::ostream&, const ARDOUR::MetricSection&);
 583
 584 #endif /* __ardour_tempo_h__ */