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), _initial (false), _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_initial (bool yn) { _initial = yn; }
 130         bool initial() const { return _initial; }
 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               _initial;
 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 (TempoMap const &);
 308         ~TempoMap();
 309
 310         TempoMap& operator= (TempoMap const &);
 311
 312         /* measure-based stuff */
 313
 314         enum BBTPointType {
 315                 Bar,
 316                 Beat,
 317         };
 318
 319         struct BBTPoint {
 320                 framepos_t          frame;
 321                 Meter               meter;
 322                 Tempo               tempo;
 323                 double              c;
 324                 uint32_t            bar;
 325                 uint32_t            beat;
 326
 327                 BBTPoint (const MeterSection& m, const Tempo& t, framepos_t f,
 328                           uint32_t b, uint32_t e, double func_c)
 329                 : 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) {}
 330
 331                 Timecode::BBT_Time bbt() const { return Timecode::BBT_Time (bar, beat, 0); }
 332                 operator Timecode::BBT_Time() const { return bbt(); }
 333                 operator framepos_t() const { return frame; }
 334                 bool is_bar() const { return beat == 1; }
 335         };
 336
 337         template<class T> void apply_with_metrics (T& obj, void (T::*method)(const Metrics&)) {
 338                 Glib::Threads::RWLock::ReaderLock lm (lock);
 339                 (obj.*method)(_metrics);
 340         }
 341
 342         void get_grid (std::vector<BBTPoint>&,
 343                        framepos_t start, framepos_t end, uint32_t bar_mod = 0);
 344
 345         static const Tempo& default_tempo() { return _default_tempo; }
 346         static const Meter& default_meter() { return _default_meter; }
 347
 348         /* because tempi may be ramped, this is only valid for the instant requested.*/
 349         double frames_per_quarter_note_at (const framepos_t&, const framecnt_t& sr) const;
 350
 351         const TempoSection& tempo_section_at_frame (framepos_t frame) const;
 352         const MeterSection& meter_section_at_frame (framepos_t frame) const;
 353         const MeterSection& meter_section_at_beat (double beat) const;
 354
 355         /** add a tempo section locked to pls. ignored values will be set in recompute_tempi()
 356          * @param pulse pulse position of new section. ignored if pls == AudioTime
 357          * @param frame frame position of new section. ignored if pls == MusicTime
 358          * @param type type of new tempo section (Ramp, Constant)
 359          */
 360         TempoSection* add_tempo (const Tempo&, const double& pulse, const framepos_t& frame, TempoSection::Type type, PositionLockStyle pls);
 361
 362         /** add a meter section locked to pls.. ignored values will be set in recompute_meters()
 363          * @param meter the Meter to be added
 364          * @param beat beat position of new section
 365          * @param where bbt position of new section
 366          * @param frame frame position of new section. ignored if pls == MusicTime
 367          * note that @frame may also be ignored if it would create an un-solvable map
 368          * (previous audio-locked tempi may place the requested beat at an earlier time than frame)
 369          * in which case the new meter will be placed at the specified BBT.
 370          * @param  pls the position lock style
 371          *
 372          * adding an audio-locked meter will add a meter-locked tempo section at the meter position.
 373          * the meter-locked tempo tempo will be the Tempo at @beat
 374          */
 375         MeterSection* add_meter (const Meter& meter, const double& beat, const Timecode::BBT_Time& where, framepos_t frame, PositionLockStyle pls);
 376
 377         void remove_tempo (const TempoSection&, bool send_signal);
 378         void remove_meter (const MeterSection&, bool send_signal);
 379
 380         void replace_tempo (const TempoSection&, const Tempo&, const double& pulse, const framepos_t& frame
 381                             , TempoSection::Type type, PositionLockStyle pls);
 382
 383         void replace_meter (const MeterSection&, const Meter&, const Timecode::BBT_Time& where, framepos_t frame, PositionLockStyle pls);
 384
 385         framepos_t round_to_bar  (framepos_t frame, RoundMode dir);
 386         framepos_t round_to_beat (framepos_t frame, RoundMode dir);
 387         framepos_t round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 388         framepos_t round_to_quarter_note_subdivision (framepos_t fr, int sub_num, RoundMode dir);
 389
 390         void set_length (framepos_t frames);
 391
 392         XMLNode& get_state (void);
 393         int set_state (const XMLNode&, int version);
 394
 395         void dump (std::ostream&) const;
 396         void clear ();
 397
 398         TempoMetric metric_at (Timecode::BBT_Time bbt) const;
 399
 400         /** Return the TempoMetric at frame @p t, and point @p last to the latest
 401          * metric change <= t, if it is non-NULL.
 402          */
 403         TempoMetric metric_at (framepos_t, Metrics::const_iterator* last=NULL) const;
 404
 405         Metrics::const_iterator metrics_end() { return _metrics.end(); }
 406
 407         void change_existing_tempo_at (framepos_t, double bpm, double note_type);
 408         void change_initial_tempo (double bpm, double note_type);
 409
 410         void insert_time (framepos_t, framecnt_t);
 411         bool remove_time (framepos_t where, framecnt_t amount);  //returns true if anything was moved
 412
 413         int n_tempos () const;
 414         int n_meters () const;
 415
 416         framecnt_t frame_rate () const { return _frame_rate; }
 417
 418         /* TEMPO- AND METER-SENSITIVE FUNCTIONS
 419
 420            bbt_at_frame(), frame_at_bbt(), beat_at_frame(), frame_at_beat()
 421            and bbt_duration_at()
 422            are all sensitive to tempo and meter, and will give answers
 423            that align with the grid formed by tempo and meter sections.
 424
 425            They SHOULD NOT be used to determine the position of events
 426            whose location is canonically defined in Evoral::Beats.
 427         */
 428
 429         double beat_at_frame (const framecnt_t& frame) const;
 430         framepos_t frame_at_beat (const double& beat) const;
 431
 432         const Meter& meter_at_frame (framepos_t) const;
 433
 434         /* bbt - it's nearly always better to use meter-based beat (above)
 435            unless tick resolution is desirable.
 436         */
 437         Timecode::BBT_Time bbt_at_frame (framepos_t when);
 438         Timecode::BBT_Time bbt_at_frame_rt (framepos_t when);
 439         framepos_t frame_at_bbt (const Timecode::BBT_Time&);
 440
 441         double beat_at_bbt (const Timecode::BBT_Time& bbt);
 442         Timecode::BBT_Time bbt_at_beat (const double& beats);
 443
 444         double quarter_note_at_bbt (const Timecode::BBT_Time& bbt);
 445         double quarter_note_at_bbt_rt (const Timecode::BBT_Time& bbt);
 446         Timecode::BBT_Time bbt_at_quarter_note (const double& quarter_note);
 447
 448         framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
 449         framepos_t framepos_plus_bbt (framepos_t pos, Timecode::BBT_Time b) const;
 450
 451         /* TEMPO-SENSITIVE FUNCTIONS
 452
 453            These next 2 functions will all take tempo in account and should be
 454            used to determine position (and in the last case, distance in beats)
 455            when tempo matters but meter does not.
 456
 457            They SHOULD be used to determine the position of events
 458            whose location is canonically defined in Evoral::Beats.
 459         */
 460
 461         framepos_t framepos_plus_qn (framepos_t, Evoral::Beats) const;
 462         Evoral::Beats framewalk_to_qn (framepos_t pos, framecnt_t distance) const;
 463
 464         /* quarter note related functions are also tempo-sensitive and ignore meter.
 465            quarter notes may be compared with and assigned to Evoral::Beats.
 466         */
 467         double quarter_note_at_frame (const framepos_t frame) const;
 468         double quarter_note_at_frame_rt (const framepos_t frame) const;
 469         framepos_t frame_at_quarter_note (const double quarter_note) const;
 470
 471         framecnt_t frames_between_quarter_notes (const double start, const double end) const;
 472         double     quarter_notes_between_frames (const framecnt_t start, const framecnt_t end) const;
 473
 474         double quarter_note_at_beat (const double beat) const;
 475         double beat_at_quarter_note (const double beat) const;
 476
 477         /* obtain a musical subdivision via a frame position and magic note divisor.*/
 478         double exact_qn_at_frame (const framepos_t& frame, const int32_t sub_num) const;
 479         double exact_beat_at_frame (const framepos_t& frame, const int32_t sub_num) const;
 480
 481         Tempo tempo_at_frame (const framepos_t& frame) const;
 482         framepos_t frame_at_tempo (const Tempo& tempo) const;
 483         Tempo tempo_at_quarter_note (const double& beat) const;
 484         double quarter_note_at_tempo (const Tempo& tempo) const;
 485
 486         void gui_set_tempo_position (TempoSection*, const framepos_t& frame, const int& sub_num);
 487         void gui_set_meter_position (MeterSection*, const framepos_t& frame);
 488         bool gui_change_tempo (TempoSection*, const Tempo& bpm);
 489         void gui_stretch_tempo (TempoSection* tempo, const framepos_t& frame, const framepos_t& end_frame);
 490
 491         std::pair<double, framepos_t> predict_tempo_position (TempoSection* section, const Timecode::BBT_Time& bbt);
 492         bool can_solve_bbt (TempoSection* section, const Timecode::BBT_Time& bbt);
 493
 494         PBD::Signal0<void> MetricPositionChanged;
 495         void fix_legacy_session();
 496
 497 private:
 498
 499         double beat_at_minute_locked (const Metrics& metrics, const double& minute) const;
 500         double minute_at_beat_locked (const Metrics& metrics, const double& beat) const;
 501
 502         double pulse_at_beat_locked (const Metrics& metrics, const double& beat) const;
 503         double beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 504
 505         double pulse_at_minute_locked (const Metrics& metrics, const double& minute) const;
 506         double minute_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 507
 508         Tempo tempo_at_minute_locked (const Metrics& metrics, const double& minute) const;
 509         double minute_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 510
 511         Tempo tempo_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 512         double pulse_at_tempo_locked (const Metrics& metrics, const Tempo& tempo) const;
 513
 514         Timecode::BBT_Time bbt_at_minute_locked (const Metrics& metrics, const double& minute) const;
 515         double minute_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time&) const;
 516
 517         double beat_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const ;
 518         Timecode::BBT_Time bbt_at_beat_locked (const Metrics& metrics, const double& beats) const;
 519
 520         double pulse_at_bbt_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const;
 521         Timecode::BBT_Time bbt_at_pulse_locked (const Metrics& metrics, const double& pulse) const;
 522
 523         double minute_at_quarter_note_locked (const Metrics& metrics, const double quarter_note) const;
 524         double quarter_note_at_minute_locked (const Metrics& metrics, const double minute) const;
 525
 526         double quarter_note_at_beat_locked (const Metrics& metrics, const double beat) const;
 527         double beat_at_quarter_note_locked (const Metrics& metrics, const double beat) const;
 528
 529         double minutes_between_quarter_notes_locked (const Metrics& metrics, const double start_qn, const double end_qn) const;
 530         double quarter_notes_between_frames_locked (const Metrics& metrics, const framecnt_t  start, const framecnt_t end) const;
 531
 532         const TempoSection& tempo_section_at_minute_locked (const Metrics& metrics, double minute) const;
 533         const TempoSection& tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 534
 535         const MeterSection& meter_section_at_minute_locked (const Metrics& metrics, double minute) const;
 536         const MeterSection& meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const;
 537
 538         bool check_solved (const Metrics& metrics) const;
 539         bool set_active_tempi (const Metrics& metrics, const framepos_t& frame);
 540
 541         bool solve_map_minute (Metrics& metrics, TempoSection* section, const double& minute);
 542         bool solve_map_pulse (Metrics& metrics, TempoSection* section, const double& pulse);
 543         bool solve_map_minute (Metrics& metrics, MeterSection* section, const double& minute);
 544         bool solve_map_bbt (Metrics& metrics, MeterSection* section, const Timecode::BBT_Time& bbt);
 545
 546         double exact_beat_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num) const;
 547         double exact_qn_at_frame_locked (const Metrics& metrics, const framepos_t& frame, const int32_t sub_num) const;
 548
 549         double minute_at_frame (const framepos_t frame) const;
 550         framepos_t frame_at_minute (const double minute) const;
 551
 552         friend class ::BBTTest;
 553         friend class ::FrameposPlusBeatsTest;
 554         friend class ::FrameposMinusBeatsTest;
 555         friend class ::TempoTest;
 556
 557         static Tempo    _default_tempo;
 558         static Meter    _default_meter;
 559
 560         Metrics                       _metrics;
 561         framecnt_t                    _frame_rate;
 562         mutable Glib::Threads::RWLock lock;
 563
 564         void recompute_tempi (Metrics& metrics);
 565         void recompute_meters (Metrics& metrics);
 566         void recompute_map (Metrics& metrics, framepos_t end = -1);
 567
 568         framepos_t round_to_type (framepos_t fr, RoundMode dir, BBTPointType);
 569
 570         const MeterSection& first_meter() const;
 571         MeterSection&       first_meter();
 572         const TempoSection& first_tempo() const;
 573         TempoSection&       first_tempo();
 574
 575         void do_insert (MetricSection* section);
 576
 577         TempoSection* add_tempo_locked (const Tempo&, double pulse, double minute
 578                                , TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter = false);
 579
 580         MeterSection* add_meter_locked (const Meter&, double beat, const Timecode::BBT_Time& where, framepos_t frame, PositionLockStyle pls, bool recompute);
 581
 582         bool remove_tempo_locked (const TempoSection&);
 583         bool remove_meter_locked (const MeterSection&);
 584
 585         TempoSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section);
 586         MeterSection* copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section);
 587 };
 588
 589 }; /* namespace ARDOUR */
 590
 591 LIBARDOUR_API std::ostream& operator<< (std::ostream&, const ARDOUR::Meter&);
 592 LIBARDOUR_API std::ostream& operator<< (std::ostream&, const ARDOUR::Tempo&);
 593 LIBARDOUR_API std::ostream& operator<< (std::ostream&, const ARDOUR::MetricSection&);
 594
 595 #endif /* __ardour_tempo_h__ */