libs/ardour/tempo.cc

   1 /*
   2     Copyright (C) 2000-2002 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 #include <algorithm>
  21 #include <stdexcept>
  22 #include <cmath>
  23
  24 #include <unistd.h>
  25
  26 #include <glibmm/threads.h>
  27
  28 #include "pbd/enumwriter.h"
  29 #include "pbd/xml++.h"
  30 #include "evoral/Beats.hpp"
  31
  32 #include "ardour/debug.h"
  33 #include "ardour/lmath.h"
  34 #include "ardour/tempo.h"
  35
  36 #include "i18n.h"
  37 #include <locale.h>
  38
  39 using namespace std;
  40 using namespace ARDOUR;
  41 using namespace PBD;
  42
  43 using Timecode::BBT_Time;
  44
  45 /* _default tempo is 4/4 qtr=120 */
  46
  47 Meter    TempoMap::_default_meter (4.0, 4.0);
  48 Tempo    TempoMap::_default_tempo (120.0);
  49
  50 /***********************************************************************/
  51
  52 double
  53 Meter::frames_per_grid (const Tempo& tempo, framecnt_t sr) const
  54 {
  55         /* This is tempo- and meter-sensitive. The number it returns
  56            is based on the interval between any two lines in the
  57            grid that is constructed from tempo and meter sections.
  58
  59            The return value IS NOT interpretable in terms of "beats".
  60         */
  61
  62         return (60.0 * sr) / (tempo.beats_per_minute() * (_note_type/tempo.note_type()));
  63 }
  64
  65 double
  66 Meter::frames_per_bar (const Tempo& tempo, framecnt_t sr) const
  67 {
  68         return frames_per_grid (tempo, sr) * _divisions_per_bar;
  69 }
  70
  71 /***********************************************************************/
  72
  73 const string TempoSection::xml_state_node_name = "Tempo";
  74
  75 TempoSection::TempoSection (const XMLNode& node)
  76         : MetricSection (0.0, 0, MusicTime)
  77         , Tempo (TempoMap::default_tempo())
  78         , _c_func (0.0)
  79         , _active (true)
  80         , _locked_to_meter (false)
  81 {
  82         XMLProperty const * prop;
  83         LocaleGuard lg;
  84         BBT_Time bbt;
  85         double pulse;
  86         uint32_t frame;
  87
  88         _legacy_bbt = BBT_Time (0, 0, 0);
  89
  90         if ((prop = node.property ("start")) != 0) {
  91                 if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
  92                             &bbt.bars,
  93                             &bbt.beats,
  94                             &bbt.ticks) == 3) {
  95                         /* legacy session - start used to be in bbt*/
  96                         _legacy_bbt = bbt;
  97                         pulse = -1.0;
  98                         info << _("Legacy session detected. TempoSection XML node will be altered.") << endmsg;
  99                 }
 100         }
 101
 102         if ((prop = node.property ("pulse")) != 0) {
 103                 if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1) {
 104                         error << _("TempoSection XML node has an illegal \"pulse\" value") << endmsg;
 105                 }
 106         }
 107
 108         set_pulse (pulse);
 109
 110         if ((prop = node.property ("frame")) != 0) {
 111                 if (sscanf (prop->value().c_str(), "%" PRIu32, &frame) != 1) {
 112                         error << _("TempoSection XML node has an illegal \"frame\" value") << endmsg;
 113                 } else {
 114                         set_frame (frame);
 115                 }
 116         }
 117
 118         if ((prop = node.property ("beats-per-minute")) == 0) {
 119                 error << _("TempoSection XML node has no \"beats-per-minute\" property") << endmsg;
 120                 throw failed_constructor();
 121         }
 122
 123         if (sscanf (prop->value().c_str(), "%lf", &_beats_per_minute) != 1 || _beats_per_minute < 0.0) {
 124                 error << _("TempoSection XML node has an illegal \"beats_per_minute\" value") << endmsg;
 125                 throw failed_constructor();
 126         }
 127
 128         if ((prop = node.property ("note-type")) == 0) {
 129                 /* older session, make note type be quarter by default */
 130                 _note_type = 4.0;
 131         } else {
 132                 if (sscanf (prop->value().c_str(), "%lf", &_note_type) != 1 || _note_type < 1.0) {
 133                         error << _("TempoSection XML node has an illegal \"note-type\" value") << endmsg;
 134                         throw failed_constructor();
 135                 }
 136         }
 137
 138         if ((prop = node.property ("movable")) == 0) {
 139                 error << _("TempoSection XML node has no \"movable\" property") << endmsg;
 140                 throw failed_constructor();
 141         }
 142
 143         set_movable (string_is_affirmative (prop->value()));
 144
 145         if ((prop = node.property ("active")) == 0) {
 146                 warning << _("TempoSection XML node has no \"active\" property") << endmsg;
 147                 set_active(true);
 148         } else {
 149                 set_active (string_is_affirmative (prop->value()));
 150         }
 151
 152         if ((prop = node.property ("tempo-type")) == 0) {
 153                 _type = Constant;
 154         } else {
 155                 _type = Type (string_2_enum (prop->value(), _type));
 156         }
 157
 158         if ((prop = node.property ("lock-style")) == 0) {
 159                 if (movable()) {
 160                         set_position_lock_style (MusicTime);
 161                 } else {
 162                         set_position_lock_style (AudioTime);
 163                 }
 164         } else {
 165                 set_position_lock_style (PositionLockStyle (string_2_enum (prop->value(), position_lock_style())));
 166         }
 167
 168         if ((prop = node.property ("locked-to-meter")) == 0) {
 169                 set_locked_to_meter (false);
 170         } else {
 171                 set_locked_to_meter (string_is_affirmative (prop->value()));
 172         }
 173 }
 174
 175 XMLNode&
 176 TempoSection::get_state() const
 177 {
 178         XMLNode *root = new XMLNode (xml_state_node_name);
 179         char buf[256];
 180         LocaleGuard lg;
 181
 182         snprintf (buf, sizeof (buf), "%f", pulse());
 183         root->add_property ("pulse", buf);
 184         snprintf (buf, sizeof (buf), "%li", frame());
 185         root->add_property ("frame", buf);
 186         snprintf (buf, sizeof (buf), "%f", _beats_per_minute);
 187         root->add_property ("beats-per-minute", buf);
 188         snprintf (buf, sizeof (buf), "%f", _note_type);
 189         root->add_property ("note-type", buf);
 190         snprintf (buf, sizeof (buf), "%s", movable()?"yes":"no");
 191         root->add_property ("movable", buf);
 192         snprintf (buf, sizeof (buf), "%s", active()?"yes":"no");
 193         root->add_property ("active", buf);
 194         root->add_property ("tempo-type", enum_2_string (_type));
 195         root->add_property ("lock-style", enum_2_string (position_lock_style()));
 196         root->add_property ("locked-to-meter", locked_to_meter()?"yes":"no");
 197
 198         return *root;
 199 }
 200
 201 void
 202 TempoSection::set_type (Type type)
 203 {
 204         _type = type;
 205 }
 206
 207 /** returns the tempo in whole pulses per minute at the zero-based (relative to session) frame.
 208 */
 209 double
 210 TempoSection::tempo_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const
 211 {
 212
 213         if (_type == Constant || _c_func == 0.0) {
 214                 return pulses_per_minute();
 215         }
 216
 217         return pulse_tempo_at_time (frame_to_minute (f - frame(), frame_rate));
 218 }
 219
 220 /** returns the zero-based frame (relative to session)
 221    where the tempo in whole pulses per minute occurs in this section.
 222    beat b is only used for constant tempos.
 223    note that the tempo map may have multiple such values.
 224 */
 225 framepos_t
 226 TempoSection::frame_at_tempo (const double& ppm, const double& b, const framecnt_t& frame_rate) const
 227 {
 228         if (_type == Constant || _c_func == 0.0) {
 229                 return ((b - pulse())  * frames_per_pulse (frame_rate))  + frame();
 230         }
 231
 232         return minute_to_frame (time_at_pulse_tempo (ppm), frame_rate) + frame();
 233 }
 234 /** returns the tempo in pulses per minute at the zero-based (relative to session) beat.
 235 */
 236 double
 237 TempoSection::tempo_at_pulse (const double& p) const
 238 {
 239
 240         if (_type == Constant || _c_func == 0.0) {
 241                 return pulses_per_minute();
 242         }
 243         double const ppm = pulse_tempo_at_pulse (p - pulse());
 244         return ppm;
 245 }
 246
 247 /** returns the zero-based beat (relative to session)
 248    where the tempo in whole pulses per minute occurs given frame f. frame f is only used for constant tempos.
 249    note that the session tempo map may have multiple beats at a given tempo.
 250 */
 251 double
 252 TempoSection::pulse_at_tempo (const double& ppm, const framepos_t& f, const framecnt_t& frame_rate) const
 253 {
 254         if (_type == Constant || _c_func == 0.0) {
 255                 double const pulses = ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
 256                 return  pulses;
 257         }
 258         return pulse_at_pulse_tempo (ppm) + pulse();
 259 }
 260
 261 /** returns the zero-based pulse (relative to session origin)
 262    where the zero-based frame (relative to session)
 263    lies.
 264 */
 265 double
 266 TempoSection::pulse_at_frame (const framepos_t& f, const framecnt_t& frame_rate) const
 267 {
 268         if (_type == Constant || _c_func == 0.0) {
 269                 return ((f - frame()) / frames_per_pulse (frame_rate)) + pulse();
 270         }
 271
 272         return pulse_at_time (frame_to_minute (f - frame(), frame_rate)) + pulse();
 273 }
 274
 275 /** returns the zero-based frame (relative to session start frame)
 276    where the zero-based pulse (relative to session start)
 277    falls.
 278 */
 279
 280 framepos_t
 281 TempoSection::frame_at_pulse (const double& p, const framecnt_t& frame_rate) const
 282 {
 283         if (_type == Constant || _c_func == 0.0) {
 284                 return (framepos_t) floor ((p - pulse()) * frames_per_pulse (frame_rate)) + frame();
 285         }
 286
 287         return minute_to_frame (time_at_pulse (p - pulse()), frame_rate) + frame();
 288 }
 289
 290 /*
 291 Ramp Overview
 292
 293       |                     *
 294 Tempo |                   *
 295 Tt----|-----------------*|
 296 Ta----|--------------|*  |
 297       |            * |   |
 298       |         *    |   |
 299       |     *        |   |
 300 T0----|*             |   |
 301   *   |              |   |
 302       _______________|___|____
 303       time           a   t (next tempo)
 304       [        c         ] defines c
 305
 306 Duration in beats at time a is the integral of some Tempo function.
 307 In our case, the Tempo function (Tempo at time t) is
 308 T(t) = T0(e^(ct))
 309
 310 with function constant
 311 c = log(Ta/T0)/a
 312 so
 313 a = log(Ta/T0)/c
 314
 315 The integral over t of our Tempo function (the beat function, which is the duration in beats at some time t) is:
 316 b(t) = T0(e^(ct) - 1) / c
 317
 318 To find the time t at beat duration b, we use the inverse function of the beat function (the time function) which can be shown to be:
 319 t(b) = log((c.b / T0) + 1) / c
 320
 321 The time t at which Tempo T occurs is a as above:
 322 t(T) = log(T / T0) / c
 323
 324 The beat at which a Tempo T occurs is:
 325 b(T) = (T - T0) / c
 326
 327 The Tempo at which beat b occurs is:
 328 T(b) = b.c + T0
 329
 330 We define c for this tempo ramp by placing a new tempo section at some time t after this one.
 331 Our problem is that we usually don't know t.
 332 We almost always know the duration in beats between this and the new section, so we need to find c in terms of the beat function.
 333 Where a = t (i.e. when a is equal to the time of the next tempo section), the beat function reveals:
 334 t = b log (Ta / T0) / (T0 (e^(log (Ta / T0)) - 1))
 335
 336 By substituting our expanded t as a in the c function above, our problem is reduced to:
 337 c = T0 (e^(log (Ta / T0)) - 1) / b
 338
 339 Of course the word 'beat' has been left loosely defined above.
 340 In music, a beat is defined by the musical pulse (which comes from the tempo)
 341 and the meter in use at a particular time (how many  pulse divisions there are in one bar).
 342 It would be more accurate to substitute the work 'pulse' for 'beat' above.
 343
 344 Anyway ...
 345
 346 We can now store c for future time calculations.
 347 If the following tempo section (the one that defines c in conjunction with this one)
 348 is changed or moved, c is no longer valid.
 349
 350 The public methods are session-relative.
 351
 352 Most of this stuff is taken from this paper:
 353
 354 WHERE’S THE BEAT?
 355 TOOLS FOR DYNAMIC TEMPO CALCULATIONS
 356 Jan C. Schacher
 357 Martin Neukom
 358 Zurich University of Arts
 359 Institute for Computer Music and Sound Technology
 360
 361 https://www.zhdk.ch/fileadmin/data_subsites/data_icst/Downloads/Timegrid/ICST_Tempopolyphony_ICMC07.pdf
 362
 363 */
 364
 365 /*
 366   compute this ramp's function constant using the end tempo (in whole pulses per minute)
 367   and duration (pulses into global start) of some later tempo section.
 368 */
 369 double
 370 TempoSection::compute_c_func_pulse (const double& end_bpm, const double& end_pulse, const framecnt_t& frame_rate)
 371 {
 372         double const log_tempo_ratio = log (end_bpm / pulses_per_minute());
 373         return pulses_per_minute() *  (expm1 (log_tempo_ratio)) / (end_pulse - pulse());
 374 }
 375
 376 /* compute the function constant from some later tempo section, given tempo (whole pulses/min.) and distance (in frames) from session origin */
 377 double
 378 TempoSection::compute_c_func_frame (const double& end_bpm, const framepos_t& end_frame, const framecnt_t& frame_rate) const
 379 {
 380         return c_func (end_bpm, frame_to_minute (end_frame - frame(), frame_rate));
 381 }
 382
 383 framepos_t
 384 TempoSection::minute_to_frame (const double& time, const framecnt_t& frame_rate) const
 385 {
 386         return (framepos_t) floor ((time * 60.0 * frame_rate) + 0.5);
 387 }
 388
 389 double
 390 TempoSection::frame_to_minute (const framepos_t& frame, const framecnt_t& frame_rate) const
 391 {
 392         return (frame / (double) frame_rate) / 60.0;
 393 }
 394
 395 /* position function */
 396 double
 397 TempoSection::a_func (double end_ppm, double c_func) const
 398 {
 399         return log (end_ppm / pulses_per_minute()) /  c_func;
 400 }
 401
 402 /*function constant*/
 403 double
 404 TempoSection::c_func (double end_ppm, double end_time) const
 405 {
 406         return log (end_ppm / pulses_per_minute()) /  end_time;
 407 }
 408
 409 /* tempo in ppm at time in minutes */
 410 double
 411 TempoSection::pulse_tempo_at_time (const double& time) const
 412 {
 413         return exp (_c_func * time) * pulses_per_minute();
 414 }
 415
 416 /* time in minutes at tempo in ppm */
 417 double
 418 TempoSection::time_at_pulse_tempo (const double& pulse_tempo) const
 419 {
 420         return log (pulse_tempo / pulses_per_minute()) / _c_func;
 421 }
 422
 423 /* tick at tempo in ppm */
 424 double
 425 TempoSection::pulse_at_pulse_tempo (const double& pulse_tempo) const
 426 {
 427         return (pulse_tempo - pulses_per_minute()) / _c_func;
 428 }
 429
 430 /* tempo in ppm at tick */
 431 double
 432 TempoSection::pulse_tempo_at_pulse (const double& pulse) const
 433 {
 434         return (pulse * _c_func) + pulses_per_minute();
 435 }
 436
 437 /* pulse at time in minutes */
 438 double
 439 TempoSection::pulse_at_time (const double& time) const
 440 {
 441         return expm1 (_c_func * time) * (pulses_per_minute() / _c_func);
 442 }
 443
 444 /* time in minutes at pulse */
 445 double
 446 TempoSection::time_at_pulse (const double& pulse) const
 447 {
 448         return log1p ((_c_func * pulse) / pulses_per_minute()) / _c_func;
 449 }
 450
 451 /***********************************************************************/
 452
 453 const string MeterSection::xml_state_node_name = "Meter";
 454
 455 MeterSection::MeterSection (const XMLNode& node)
 456         : MetricSection (0.0, 0, MusicTime), Meter (TempoMap::default_meter())
 457 {
 458         XMLProperty const * prop;
 459         LocaleGuard lg;
 460         BBT_Time bbt;
 461         double pulse = 0.0;
 462         double beat = 0.0;
 463         framepos_t frame = 0;
 464         pair<double, BBT_Time> start;
 465
 466         if ((prop = node.property ("start")) != 0) {
 467                 if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
 468                     &bbt.bars,
 469                     &bbt.beats,
 470                     &bbt.ticks) < 3) {
 471                         error << _("MeterSection XML node has an illegal \"start\" value") << endmsg;
 472                 } else {
 473                         /* legacy session - start used to be in bbt*/
 474                         info << _("Legacy session detected - MeterSection XML node will be altered.") << endmsg;
 475                         pulse = -1.0;
 476                 }
 477         }
 478
 479         if ((prop = node.property ("pulse")) != 0) {
 480                 if (sscanf (prop->value().c_str(), "%lf", &pulse) != 1) {
 481                         error << _("MeterSection XML node has an illegal \"pulse\" value") << endmsg;
 482                 }
 483         }
 484         set_pulse (pulse);
 485
 486         if ((prop = node.property ("beat")) != 0) {
 487                 if (sscanf (prop->value().c_str(), "%lf", &beat) != 1) {
 488                         error << _("MeterSection XML node has an illegal \"beat\" value") << endmsg;
 489                 }
 490         }
 491
 492         start.first = beat;
 493
 494         if ((prop = node.property ("bbt")) == 0) {
 495                 warning << _("MeterSection XML node has no \"bbt\" property") << endmsg;
 496         } else if (sscanf (prop->value().c_str(), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
 497                     &bbt.bars,
 498                     &bbt.beats,
 499                     &bbt.ticks) < 3) {
 500                 error << _("MeterSection XML node has an illegal \"bbt\" value") << endmsg;
 501                 throw failed_constructor();
 502         }
 503
 504         start.second = bbt;
 505         set_beat (start);
 506
 507         if ((prop = node.property ("frame")) != 0) {
 508                 if (sscanf (prop->value().c_str(), "%li", &frame) != 1) {
 509                         error << _("MeterSection XML node has an illegal \"frame\" value") << endmsg;
 510                 } else {
 511                         set_frame (frame);
 512                 }
 513         }
 514
 515         /* beats-per-bar is old; divisions-per-bar is new */
 516
 517         if ((prop = node.property ("divisions-per-bar")) == 0) {
 518                 if ((prop = node.property ("beats-per-bar")) == 0) {
 519                         error << _("MeterSection XML node has no \"beats-per-bar\" or \"divisions-per-bar\" property") << endmsg;
 520                         throw failed_constructor();
 521                 }
 522         }
 523         if (sscanf (prop->value().c_str(), "%lf", &_divisions_per_bar) != 1 || _divisions_per_bar < 0.0) {
 524                 error << _("MeterSection XML node has an illegal \"divisions-per-bar\" value") << endmsg;
 525                 throw failed_constructor();
 526         }
 527
 528         if ((prop = node.property ("note-type")) == 0) {
 529                 error << _("MeterSection XML node has no \"note-type\" property") << endmsg;
 530                 throw failed_constructor();
 531         }
 532         if (sscanf (prop->value().c_str(), "%lf", &_note_type) != 1 || _note_type < 0.0) {
 533                 error << _("MeterSection XML node has an illegal \"note-type\" value") << endmsg;
 534                 throw failed_constructor();
 535         }
 536
 537         if ((prop = node.property ("movable")) == 0) {
 538                 error << _("MeterSection XML node has no \"movable\" property") << endmsg;
 539                 throw failed_constructor();
 540         }
 541
 542         set_movable (string_is_affirmative (prop->value()));
 543
 544         if ((prop = node.property ("lock-style")) == 0) {
 545                 warning << _("MeterSection XML node has no \"lock-style\" property") << endmsg;
 546                 if (movable()) {
 547                         set_position_lock_style (MusicTime);
 548                 } else {
 549                         set_position_lock_style (AudioTime);
 550                 }
 551         } else {
 552                 set_position_lock_style (PositionLockStyle (string_2_enum (prop->value(), position_lock_style())));
 553         }
 554 }
 555
 556 XMLNode&
 557 MeterSection::get_state() const
 558 {
 559         XMLNode *root = new XMLNode (xml_state_node_name);
 560         char buf[256];
 561         LocaleGuard lg;
 562
 563         snprintf (buf, sizeof (buf), "%lf", pulse());
 564         root->add_property ("pulse", buf);
 565         snprintf (buf, sizeof (buf), "%" PRIu32 "|%" PRIu32 "|%" PRIu32,
 566                   bbt().bars,
 567                   bbt().beats,
 568                   bbt().ticks);
 569         root->add_property ("bbt", buf);
 570         snprintf (buf, sizeof (buf), "%lf", beat());
 571         root->add_property ("beat", buf);
 572         snprintf (buf, sizeof (buf), "%f", _note_type);
 573         root->add_property ("note-type", buf);
 574         snprintf (buf, sizeof (buf), "%li", frame());
 575         root->add_property ("frame", buf);
 576         root->add_property ("lock-style", enum_2_string (position_lock_style()));
 577         snprintf (buf, sizeof (buf), "%f", _divisions_per_bar);
 578         root->add_property ("divisions-per-bar", buf);
 579         snprintf (buf, sizeof (buf), "%s", movable()?"yes":"no");
 580         root->add_property ("movable", buf);
 581
 582         return *root;
 583 }
 584
 585 /***********************************************************************/
 586 /*
 587   Tempo Map Overview
 588
 589   Tempo is the rate of the musical pulse.
 590   Meters divide the pulses into measures and beats.
 591
 592   Note that Tempo::beats_per_minute() has nothing to do with musical beats.
 593   It should rather be thought of as tempo note divisions per minute.
 594
 595   TempoSections, which are nice to think of in whole pulses per minute,
 596   and MeterSecions which divide tempo pulses into measures (via divisions_per_bar)
 597   and beats (via note_divisor) are used to form a tempo map.
 598   TempoSections and MeterSections may be locked to either audio or music (position lock style).
 599   We construct the tempo map by first using the frame or pulse position (depending on position lock style) of each tempo.
 600   We then use this pulse/frame layout to find the beat & pulse or frame position of each meter (again depending on lock style).
 601
 602   Having done this, we can now find any one of tempo, beat, frame or pulse if a beat, frame, pulse or tempo is known.
 603
 604   With tepo sections potentially being ramped, meters provide a way of mapping beats to whole pulses without
 605   referring to the tempo function(s) involved as the distance in whole pulses between a meter and a subsequent beat is
 606   sb->beat() - meter->beat() / meter->note_divisor().
 607   Because every meter falls on a known pulse, (derived from its bar), the rest is easy as the duration in pulses between
 608   two meters is of course
 609   (meater_b->bar - meter_a->bar) * meter_a->divisions_per_bar / meter_a->note_divisor.
 610
 611   Below, beat calculations are based on meter sections and all pulse and tempo calculations are based on tempo sections.
 612   Beat to frame conversion of course requires the use of meter and tempo.
 613
 614   Remembering that ramped tempo sections interact, it is important to avoid referring to any other tempos when moving tempo sections,
 615   Here, beats (meters) are used to determine the new pulse (see predict_tempo_position())
 616
 617   The first tempo and first meter are special. they must move together, and must be locked to audio.
 618   Audio locked tempos which lie before the first meter are made inactive.
 619   They will be re-activated if the first meter is again placed before them.
 620
 621   Both tempos and meters have a pulse position and a frame position.
 622   Meters also have a beat position, which is always 0.0 for the first meter.
 623
 624   A tempo locked to music is locked to musical pulses.
 625   A meter locked to music is locked to beats.
 626
 627   Recomputing the tempo map is the process where the 'missing' position
 628   (tempo pulse or meter pulse & beat in the case of AudioTime, frame for MusicTime) is calculated.
 629
 630   It is important to keep the _metrics in an order that makes sense.
 631   Because ramped MusicTime and AudioTime tempos can interact with each other,
 632   reordering is frequent. Care must be taken to keep _metrics in a solved state.
 633   Solved means ordered by frame or pulse with frame-accurate precision (see check_solved()).
 634 */
 635 struct MetricSectionSorter {
 636     bool operator() (const MetricSection* a, const MetricSection* b) {
 637             return a->pulse() < b->pulse();
 638     }
 639 };
 640
 641 struct MetricSectionFrameSorter {
 642     bool operator() (const MetricSection* a, const MetricSection* b) {
 643             return a->frame() < b->frame();
 644     }
 645 };
 646
 647 TempoMap::TempoMap (framecnt_t fr)
 648 {
 649         _frame_rate = fr;
 650         BBT_Time start (1, 1, 0);
 651
 652         TempoSection *t = new TempoSection (0.0, 0, _default_tempo.beats_per_minute(), _default_tempo.note_type(), TempoSection::Constant, AudioTime);
 653         MeterSection *m = new MeterSection (0.0, 0, 0.0, start, _default_meter.divisions_per_bar(), _default_meter.note_divisor(), AudioTime);
 654
 655         t->set_movable (false);
 656         m->set_movable (false);
 657
 658         /* note: frame time is correct (zero) for both of these */
 659
 660         _metrics.push_back (t);
 661         _metrics.push_back (m);
 662
 663 }
 664
 665 TempoMap::~TempoMap ()
 666 {
 667         Metrics::const_iterator d = _metrics.begin();
 668         while (d != _metrics.end()) {
 669                 delete (*d);
 670                 ++d;
 671         }
 672         _metrics.clear();
 673 }
 674
 675 void
 676 TempoMap::remove_tempo (const TempoSection& tempo, bool complete_operation)
 677 {
 678         bool removed = false;
 679
 680         {
 681                 Glib::Threads::RWLock::WriterLock lm (lock);
 682                 if ((removed = remove_tempo_locked (tempo))) {
 683                         if (complete_operation) {
 684                                 recompute_map (_metrics);
 685                         }
 686                 }
 687         }
 688
 689         if (removed && complete_operation) {
 690                 PropertyChanged (PropertyChange ());
 691         }
 692 }
 693
 694 bool
 695 TempoMap::remove_tempo_locked (const TempoSection& tempo)
 696 {
 697         Metrics::iterator i;
 698
 699         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
 700                 if (dynamic_cast<TempoSection*> (*i) != 0) {
 701                         if (tempo.frame() == (*i)->frame()) {
 702                                 if ((*i)->movable()) {
 703                                         delete (*i);
 704                                         _metrics.erase (i);
 705                                         return true;
 706                                 }
 707                         }
 708                 }
 709         }
 710
 711         return false;
 712 }
 713
 714 void
 715 TempoMap::remove_meter (const MeterSection& tempo, bool complete_operation)
 716 {
 717         bool removed = false;
 718
 719         {
 720                 Glib::Threads::RWLock::WriterLock lm (lock);
 721                 if ((removed = remove_meter_locked (tempo))) {
 722                         if (complete_operation) {
 723                                 recompute_map (_metrics);
 724                         }
 725                 }
 726         }
 727
 728         if (removed && complete_operation) {
 729                 PropertyChanged (PropertyChange ());
 730         }
 731 }
 732
 733 bool
 734 TempoMap::remove_meter_locked (const MeterSection& meter)
 735 {
 736         Metrics::iterator i;
 737
 738         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
 739                 TempoSection* t = 0;
 740                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
 741                         if (meter.frame() == (*i)->frame()) {
 742                                 if (t->locked_to_meter()) {
 743                                         delete (*i);
 744                                         _metrics.erase (i);
 745                                         break;
 746                                 }
 747                         }
 748                 }
 749         }
 750
 751         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
 752                 if (dynamic_cast<MeterSection*> (*i) != 0) {
 753                         if (meter.frame() == (*i)->frame()) {
 754                                 if ((*i)->movable()) {
 755                                         delete (*i);
 756                                         _metrics.erase (i);
 757                                         return true;
 758                                 }
 759                         }
 760                 }
 761         }
 762
 763         return false;
 764 }
 765
 766 void
 767 TempoMap::do_insert (MetricSection* section)
 768 {
 769         bool need_add = true;
 770         /* we only allow new meters to be inserted on beat 1 of an existing
 771          * measure.
 772          */
 773         MeterSection* m = 0;
 774         if ((m = dynamic_cast<MeterSection*>(section)) != 0) {
 775
 776                 if ((m->bbt().beats != 1) || (m->bbt().ticks != 0)) {
 777
 778                         pair<double, BBT_Time> corrected = make_pair (m->pulse(), m->bbt());
 779                         corrected.second.beats = 1;
 780                         corrected.second.ticks = 0;
 781                         corrected.first = bbt_to_beats_locked (_metrics, corrected.second);
 782                         warning << string_compose (_("Meter changes can only be positioned on the first beat of a bar. Moving from %1 to %2"),
 783                                                    m->bbt(), corrected.second) << endmsg;
 784                         //m->set_pulse (corrected);
 785                 }
 786         }
 787
 788         /* Look for any existing MetricSection that is of the same type and
 789            in the same bar as the new one, and remove it before adding
 790            the new one. Note that this means that if we find a matching,
 791            existing section, we can break out of the loop since we're
 792            guaranteed that there is only one such match.
 793         */
 794
 795         for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
 796
 797                 TempoSection* const tempo = dynamic_cast<TempoSection*> (*i);
 798                 TempoSection* const insert_tempo = dynamic_cast<TempoSection*> (section);
 799                 MeterSection* const meter = dynamic_cast<MeterSection*> (*i);
 800                 MeterSection* const insert_meter = dynamic_cast<MeterSection*> (section);
 801
 802                 if (tempo && insert_tempo) {
 803
 804                         /* Tempo sections */
 805                         bool const ipm = insert_tempo->position_lock_style() == MusicTime;
 806                         if ((ipm && tempo->pulse() == insert_tempo->pulse()) || (!ipm && tempo->frame() == insert_tempo->frame())) {
 807
 808                                 if (!tempo->movable()) {
 809
 810                                         /* can't (re)move this section, so overwrite
 811                                          * its data content (but not its properties as
 812                                          * a section).
 813                                          */
 814
 815                                         *(dynamic_cast<Tempo*>(*i)) = *(dynamic_cast<Tempo*>(insert_tempo));
 816                                         (*i)->set_position_lock_style (AudioTime);
 817                                         TempoSection* t;
 818                                         if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
 819                                                 t->set_type (insert_tempo->type());
 820                                         }
 821                                         need_add = false;
 822                                 } else {
 823                                         delete (*i);
 824                                         _metrics.erase (i);
 825                                 }
 826                                 break;
 827                         }
 828
 829                 } else if (meter && insert_meter) {
 830
 831                         /* Meter Sections */
 832
 833                         bool const ipm = insert_meter->position_lock_style() == MusicTime;
 834
 835                         if ((ipm && meter->beat() == insert_meter->beat()) || (!ipm && meter->frame() == insert_meter->frame())) {
 836
 837                                 if (!meter->movable()) {
 838
 839                                         /* can't (re)move this section, so overwrite
 840                                          * its data content (but not its properties as
 841                                          * a section
 842                                          */
 843
 844                                         *(dynamic_cast<Meter*>(*i)) = *(dynamic_cast<Meter*>(insert_meter));
 845                                         (*i)->set_position_lock_style (AudioTime);
 846                                         need_add = false;
 847                                 } else {
 848                                         delete (*i);
 849                                         _metrics.erase (i);
 850                                 }
 851
 852                                 break;
 853                         }
 854                 } else {
 855                         /* non-matching types, so we don't care */
 856                 }
 857         }
 858
 859         /* Add the given MetricSection, if we didn't just reset an existing
 860          * one above
 861          */
 862
 863         if (need_add) {
 864                 MeterSection* const insert_meter = dynamic_cast<MeterSection*> (section);
 865                 TempoSection* const insert_tempo = dynamic_cast<TempoSection*> (section);
 866                 Metrics::iterator i;
 867                 if (insert_meter) {
 868                         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
 869                                 MeterSection* const meter = dynamic_cast<MeterSection*> (*i);
 870
 871                                 if (meter) {
 872                                         bool const ipm = insert_meter->position_lock_style() == MusicTime;
 873                                         if ((ipm && meter->beat() > insert_meter->beat()) || (!ipm && meter->frame() > insert_meter->frame())) {
 874                                                 break;
 875                                         }
 876                                 }
 877                         }
 878                 } else if (insert_tempo) {
 879                         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
 880                                 TempoSection* const tempo = dynamic_cast<TempoSection*> (*i);
 881
 882                                 if (tempo) {
 883                                         bool const ipm = insert_tempo->position_lock_style() == MusicTime;
 884                                         if ((ipm && tempo->pulse() > insert_tempo->pulse()) || (!ipm && tempo->frame() > insert_tempo->frame())) {
 885                                                 break;
 886                                         }
 887                                 }
 888                         }
 889                 }
 890
 891                 _metrics.insert (i, section);
 892                 //dump (_metrics, std::cout);
 893         }
 894 }
 895
 896 TempoSection*
 897 TempoMap::add_tempo (const Tempo& tempo, const double& pulse, const framepos_t& frame, ARDOUR::TempoSection::Type type, PositionLockStyle pls)
 898 {
 899         TempoSection* ts = 0;
 900         {
 901                 Glib::Threads::RWLock::WriterLock lm (lock);
 902                 ts = add_tempo_locked (tempo, pulse, frame, type, pls, true);
 903         }
 904
 905
 906         PropertyChanged (PropertyChange ());
 907
 908         return ts;
 909 }
 910
 911 void
 912 TempoMap::replace_tempo (const TempoSection& ts, const Tempo& tempo, const double& pulse, const framepos_t& frame, TempoSection::Type type, PositionLockStyle pls)
 913 {
 914         const bool locked_to_meter = ts.locked_to_meter();
 915
 916         {
 917                 Glib::Threads::RWLock::WriterLock lm (lock);
 918                 TempoSection& first (first_tempo());
 919                 if (ts.frame() != first.frame()) {
 920                         remove_tempo_locked (ts);
 921                         add_tempo_locked (tempo, pulse, frame, type, pls, true, locked_to_meter);
 922                 } else {
 923                         first.set_type (type);
 924                         first.set_pulse (0.0);
 925                         first.set_frame (frame);
 926                         first.set_position_lock_style (AudioTime);
 927                         {
 928                                 /* cannot move the first tempo section */
 929                                 *static_cast<Tempo*>(&first) = tempo;
 930                                 recompute_map (_metrics);
 931                         }
 932                 }
 933         }
 934
 935         PropertyChanged (PropertyChange ());
 936 }
 937
 938 TempoSection*
 939 TempoMap::add_tempo_locked (const Tempo& tempo, double pulse, framepos_t frame
 940                             , TempoSection::Type type, PositionLockStyle pls, bool recompute, bool locked_to_meter)
 941 {
 942         TempoSection* t = new TempoSection (pulse, frame, tempo.beats_per_minute(), tempo.note_type(), type, pls);
 943         t->set_locked_to_meter (locked_to_meter);
 944
 945         do_insert (t);
 946
 947         if (recompute) {
 948                 if (pls == AudioTime) {
 949                         solve_map_frame (_metrics, t, t->frame());
 950                 } else {
 951                         solve_map_pulse (_metrics, t, t->pulse());
 952                 }
 953                 recompute_meters (_metrics);
 954         }
 955
 956         return t;
 957 }
 958
 959 MeterSection*
 960 TempoMap::add_meter (const Meter& meter, const double& beat, const Timecode::BBT_Time& where, const framepos_t& frame, PositionLockStyle pls)
 961 {
 962         MeterSection* m = 0;
 963         {
 964                 Glib::Threads::RWLock::WriterLock lm (lock);
 965                 m = add_meter_locked (meter, beat, where, frame, pls, true);
 966         }
 967
 968
 969 #ifndef NDEBUG
 970         if (DEBUG_ENABLED(DEBUG::TempoMap)) {
 971                 dump (_metrics, std::cerr);
 972         }
 973 #endif
 974
 975         PropertyChanged (PropertyChange ());
 976         return m;
 977 }
 978
 979 void
 980 TempoMap::replace_meter (const MeterSection& ms, const Meter& meter, const BBT_Time& where, const framepos_t& frame, PositionLockStyle pls)
 981 {
 982         {
 983                 Glib::Threads::RWLock::WriterLock lm (lock);
 984                 const double beat = bbt_to_beats_locked (_metrics, where);
 985
 986                 if (ms.movable()) {
 987                         remove_meter_locked (ms);
 988                         add_meter_locked (meter, beat, where, frame, pls, true);
 989                 } else {
 990                         MeterSection& first (first_meter());
 991                         TempoSection& first_t (first_tempo());
 992                         /* cannot move the first meter section */
 993                         *static_cast<Meter*>(&first) = meter;
 994                         first.set_position_lock_style (AudioTime);
 995                         first.set_pulse (0.0);
 996                         first.set_frame (frame);
 997                         pair<double, BBT_Time> beat = make_pair (0.0, BBT_Time (1, 1, 0));
 998                         first.set_beat (beat);
 999                         first_t.set_frame (first.frame());
1000                         first_t.set_pulse (0.0);
1001                         first_t.set_position_lock_style (AudioTime);
1002                 }
1003                 recompute_map (_metrics);
1004         }
1005         PropertyChanged (PropertyChange ());
1006 }
1007
1008 MeterSection*
1009 TempoMap::add_meter_locked (const Meter& meter, double beat, const Timecode::BBT_Time& where, framepos_t frame, PositionLockStyle pls, bool recompute)
1010 {
1011         const MeterSection& prev_m = meter_section_at_locked  (_metrics, frame - 1);
1012         const double pulse = ((where.bars - prev_m.bbt().bars) * (prev_m.divisions_per_bar() / prev_m.note_divisor())) + prev_m.pulse();
1013
1014         if (pls == AudioTime) {
1015                 /* add meter-locked tempo */
1016                 add_tempo_locked (tempo_at_locked (_metrics, frame), pulse,  frame, TempoSection::Ramp, AudioTime, true, true);
1017         }
1018
1019         MeterSection* new_meter = new MeterSection (pulse, frame, beat, where, meter.divisions_per_bar(), meter.note_divisor(), pls);
1020
1021         do_insert (new_meter);
1022
1023         if (recompute) {
1024
1025                 if (pls == AudioTime) {
1026                         solve_map_frame (_metrics, new_meter, frame);
1027                 } else {
1028                         solve_map_bbt (_metrics, new_meter, where);
1029                 }
1030         }
1031
1032         return new_meter;
1033 }
1034
1035 void
1036 TempoMap::change_initial_tempo (double beats_per_minute, double note_type)
1037 {
1038         Tempo newtempo (beats_per_minute, note_type);
1039         TempoSection* t;
1040
1041         for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1042                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1043                         if (!t->active()) {
1044                                 continue;
1045                         }
1046                         {
1047                                 Glib::Threads::RWLock::WriterLock lm (lock);
1048                                 *((Tempo*) t) = newtempo;
1049                                 recompute_map (_metrics);
1050                         }
1051                         PropertyChanged (PropertyChange ());
1052                         break;
1053                 }
1054         }
1055 }
1056
1057 void
1058 TempoMap::change_existing_tempo_at (framepos_t where, double beats_per_minute, double note_type)
1059 {
1060         Tempo newtempo (beats_per_minute, note_type);
1061
1062         TempoSection* prev;
1063         TempoSection* first;
1064         Metrics::iterator i;
1065
1066         /* find the TempoSection immediately preceding "where"
1067          */
1068
1069         for (first = 0, i = _metrics.begin(), prev = 0; i != _metrics.end(); ++i) {
1070
1071                 if ((*i)->frame() > where) {
1072                         break;
1073                 }
1074
1075                 TempoSection* t;
1076
1077                 if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
1078                         if (!t->active()) {
1079                                 continue;
1080                         }
1081                         if (!first) {
1082                                 first = t;
1083                         }
1084                         prev = t;
1085                 }
1086         }
1087
1088         if (!prev) {
1089                 if (!first) {
1090                         error << string_compose (_("no tempo sections defined in tempo map - cannot change tempo @ %1"), where) << endmsg;
1091                         return;
1092                 }
1093
1094                 prev = first;
1095         }
1096
1097         /* reset */
1098
1099         {
1100                 Glib::Threads::RWLock::WriterLock lm (lock);
1101                 /* cannot move the first tempo section */
1102                 *((Tempo*)prev) = newtempo;
1103                 recompute_map (_metrics);
1104         }
1105
1106         PropertyChanged (PropertyChange ());
1107 }
1108
1109 const MeterSection&
1110 TempoMap::first_meter () const
1111 {
1112         const MeterSection *m = 0;
1113
1114         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1115                 if ((m = dynamic_cast<const MeterSection *> (*i)) != 0) {
1116                         return *m;
1117                 }
1118         }
1119
1120         fatal << _("programming error: no meter section in tempo map!") << endmsg;
1121         abort(); /*NOTREACHED*/
1122         return *m;
1123 }
1124
1125 MeterSection&
1126 TempoMap::first_meter ()
1127 {
1128         MeterSection *m = 0;
1129
1130         /* CALLER MUST HOLD LOCK */
1131
1132         for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1133                 if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
1134                         return *m;
1135                 }
1136         }
1137
1138         fatal << _("programming error: no tempo section in tempo map!") << endmsg;
1139         abort(); /*NOTREACHED*/
1140         return *m;
1141 }
1142
1143 const TempoSection&
1144 TempoMap::first_tempo () const
1145 {
1146         const TempoSection *t = 0;
1147
1148         /* CALLER MUST HOLD LOCK */
1149
1150         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1151                 if ((t = dynamic_cast<const TempoSection *> (*i)) != 0) {
1152                         if (!t->active()) {
1153                                 continue;
1154                         }
1155                         if (!t->movable()) {
1156                                 return *t;
1157                         }
1158                 }
1159         }
1160
1161         fatal << _("programming error: no tempo section in tempo map!") << endmsg;
1162         abort(); /*NOTREACHED*/
1163         return *t;
1164 }
1165
1166 TempoSection&
1167 TempoMap::first_tempo ()
1168 {
1169         TempoSection *t = 0;
1170
1171         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1172                 if ((t = dynamic_cast<TempoSection *> (*i)) != 0) {
1173                         if (!t->active()) {
1174                                 continue;
1175                         }
1176                         if (!t->movable()) {
1177                                 return *t;
1178                         }
1179                 }
1180         }
1181
1182         fatal << _("programming error: no tempo section in tempo map!") << endmsg;
1183         abort(); /*NOTREACHED*/
1184         return *t;
1185 }
1186 void
1187 TempoMap::recompute_tempos (Metrics& metrics)
1188 {
1189         TempoSection* prev_t = 0;
1190
1191         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1192                 TempoSection* t;
1193
1194                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1195                         if (!t->active()) {
1196                                 continue;
1197                         }
1198                         if (!t->movable()) {
1199                                 if (!prev_t) {
1200                                         t->set_pulse (0.0);
1201                                         prev_t = t;
1202                                         continue;
1203                                 }
1204                         }
1205                         if (prev_t) {
1206                                 if (t->position_lock_style() == AudioTime) {
1207                                         prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
1208                                         if (!t->locked_to_meter()) {
1209                                                 t->set_pulse (prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate));
1210                                         }
1211
1212                                 } else {
1213                                         prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
1214                                         t->set_frame (prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate));
1215
1216                                 }
1217                         }
1218                         prev_t = t;
1219                 }
1220         }
1221         prev_t->set_c_func (0.0);
1222 }
1223
1224 /* tempos must be positioned correctly.
1225    the current approach is to use a meter's bbt time as its base position unit.
1226    an audio-locked meter requires a recomputation of pulse and beat (but not bbt),
1227    while a music-locked meter requires recomputations of frame pulse and beat (but not bbt)
1228 */
1229 void
1230 TempoMap::recompute_meters (Metrics& metrics)
1231 {
1232         MeterSection* meter = 0;
1233         MeterSection* prev_m = 0;
1234
1235         for (Metrics::const_iterator mi = metrics.begin(); mi != metrics.end(); ++mi) {
1236                 if ((meter = dynamic_cast<MeterSection*> (*mi)) != 0) {
1237                         if (meter->position_lock_style() == AudioTime) {
1238                                 double pulse = 0.0;
1239                                 pair<double, BBT_Time> b_bbt;
1240                                 TempoSection* meter_locked_tempo = 0;
1241                                 for (Metrics::const_iterator ii = metrics.begin(); ii != metrics.end(); ++ii) {
1242                                         TempoSection* t;
1243                                         if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
1244                                                 if ((t->locked_to_meter() || !t->movable()) && t->frame() == meter->frame()) {
1245                                                         meter_locked_tempo = t;
1246                                                         break;
1247                                                 }
1248                                         }
1249                                 }
1250
1251                                 if (prev_m) {
1252                                         const double beats = (meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
1253                                         if (beats + prev_m->beat() != meter->beat()) {
1254                                                 /* reordering caused a bbt change */
1255                                                 b_bbt = make_pair (beats + prev_m->beat()
1256                                                                    , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
1257                                                 pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
1258
1259                                         } else if (meter->movable()) {
1260                                                 b_bbt = make_pair (meter->beat(), meter->bbt());
1261                                                 pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
1262                                         }
1263                                 } else {
1264                                         b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
1265                                 }
1266                                 if (meter_locked_tempo) {
1267                                         meter_locked_tempo->set_pulse (pulse);
1268                                 }
1269                                 meter->set_beat (b_bbt);
1270                                 meter->set_pulse (pulse);
1271
1272                         } else {
1273                                 /* MusicTime */
1274                                 double pulse = 0.0;
1275                                 pair<double, BBT_Time> new_beat;
1276                                 if (prev_m) {
1277                                         const double beats = (meter->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
1278                                         if (beats + prev_m->beat() != meter->beat()) {
1279                                                 /* reordering caused a bbt change */
1280                                                 new_beat = make_pair (beats + prev_m->beat()
1281                                                                    , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
1282                                         } else {
1283                                                 new_beat = make_pair (beats + prev_m->beat(), meter->bbt());
1284                                         }
1285                                         pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
1286                                 } else {
1287                                         /* shouldn't happen - the first is audio-locked */
1288                                         pulse = pulse_at_beat_locked (metrics, meter->beat());
1289                                         new_beat = make_pair (meter->beat(), meter->bbt());
1290                                 }
1291
1292                                 meter->set_beat (new_beat);
1293                                 meter->set_pulse (pulse);
1294                                 meter->set_frame (frame_at_pulse_locked (metrics, pulse));
1295                         }
1296
1297                         prev_m = meter;
1298                 }
1299         }
1300 }
1301
1302 void
1303 TempoMap::recompute_map (Metrics& metrics, framepos_t end)
1304 {
1305         /* CALLER MUST HOLD WRITE LOCK */
1306
1307         if (end < 0) {
1308
1309                 /* we will actually stop once we hit
1310                    the last metric.
1311                 */
1312                 end = max_framepos;
1313
1314         }
1315
1316         DEBUG_TRACE (DEBUG::TempoMath, string_compose ("recomputing tempo map, zero to %1\n", end));
1317
1318         if (end == 0) {
1319                 /* silly call from Session::process() during startup
1320                  */
1321                 return;
1322         }
1323
1324         recompute_tempos (metrics);
1325         recompute_meters (metrics);
1326 }
1327
1328 TempoMetric
1329 TempoMap::metric_at (framepos_t frame, Metrics::const_iterator* last) const
1330 {
1331         Glib::Threads::RWLock::ReaderLock lm (lock);
1332         TempoMetric m (first_meter(), first_tempo());
1333
1334         /* at this point, we are *guaranteed* to have m.meter and m.tempo pointing
1335            at something, because we insert the default tempo and meter during
1336            TempoMap construction.
1337
1338            now see if we can find better candidates.
1339         */
1340
1341         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1342
1343                 if ((*i)->frame() > frame) {
1344                         break;
1345                 }
1346
1347                 m.set_metric(*i);
1348
1349                 if (last) {
1350                         *last = i;
1351                 }
1352         }
1353
1354         return m;
1355 }
1356
1357 /* XX meters only */
1358 TempoMetric
1359 TempoMap::metric_at (BBT_Time bbt) const
1360 {
1361         Glib::Threads::RWLock::ReaderLock lm (lock);
1362         TempoMetric m (first_meter(), first_tempo());
1363
1364         /* at this point, we are *guaranteed* to have m.meter and m.tempo pointing
1365            at something, because we insert the default tempo and meter during
1366            TempoMap construction.
1367
1368            now see if we can find better candidates.
1369         */
1370
1371         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1372                 MeterSection* mw;
1373                 if ((mw = dynamic_cast<MeterSection*> (*i)) != 0) {
1374                         BBT_Time section_start (mw->bbt());
1375
1376                         if (section_start.bars > bbt.bars || (section_start.bars == bbt.bars && section_start.beats > bbt.beats)) {
1377                                 break;
1378                         }
1379
1380                         m.set_metric (*i);
1381                 }
1382         }
1383
1384         return m;
1385 }
1386
1387 double
1388 TempoMap::pulse_at_beat (const double& beat) const
1389 {
1390         Glib::Threads::RWLock::ReaderLock lm (lock);
1391         return pulse_at_beat_locked (_metrics, beat);
1392 }
1393
1394 double
1395 TempoMap::pulse_at_beat_locked (const Metrics& metrics, const double& beat) const
1396 {
1397         MeterSection* prev_m = 0;
1398
1399         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1400                 MeterSection* m;
1401                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1402                         if (prev_m && m->beat() > beat) {
1403                                 break;
1404                         }
1405                         prev_m = m;
1406                 }
1407
1408         }
1409         double const ret = prev_m->pulse() + ((beat - prev_m->beat()) / prev_m->note_divisor());
1410         return ret;
1411 }
1412
1413 double
1414 TempoMap::beat_at_pulse (const double& pulse) const
1415 {
1416         Glib::Threads::RWLock::ReaderLock lm (lock);
1417         return beat_at_pulse_locked (_metrics, pulse);
1418 }
1419
1420 double
1421 TempoMap::beat_at_pulse_locked (const Metrics& metrics, const double& pulse) const
1422 {
1423         MeterSection* prev_m = 0;
1424
1425         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1426                 MeterSection* m;
1427                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1428                         if (prev_m && m->pulse() > pulse) {
1429                                 if (((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > m->beat()) {
1430                                         break;
1431                                 }
1432                         }
1433                         prev_m = m;
1434                 }
1435         }
1436
1437         double const ret = ((pulse - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat();
1438         return ret;
1439 }
1440
1441 double
1442 TempoMap::pulse_at_frame (const framecnt_t& frame) const
1443 {
1444         Glib::Threads::RWLock::ReaderLock lm (lock);
1445         return pulse_at_frame_locked (_metrics, frame);
1446 }
1447
1448 /* tempo section based */
1449 double
1450 TempoMap::pulse_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
1451 {
1452         /* HOLD (at least) THE READER LOCK */
1453         TempoSection* prev_t = 0;
1454
1455         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1456                 TempoSection* t;
1457                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1458                         if (!t->active()) {
1459                                 continue;
1460                         }
1461                         if (prev_t && t->frame() > frame) {
1462                                 /*the previous ts is the one containing the frame */
1463                                 const double ret = prev_t->pulse_at_frame (frame, _frame_rate);
1464                                 return ret;
1465                         }
1466                         prev_t = t;
1467                 }
1468         }
1469
1470         /* treated as constant for this ts */
1471         const double pulses_in_section = (frame - prev_t->frame()) / prev_t->frames_per_pulse (_frame_rate);
1472
1473         return pulses_in_section + prev_t->pulse();
1474 }
1475
1476 framecnt_t
1477 TempoMap::frame_at_pulse (const double& pulse) const
1478 {
1479         Glib::Threads::RWLock::ReaderLock lm (lock);
1480         return frame_at_pulse_locked (_metrics, pulse);
1481 }
1482
1483 /* tempo section based */
1484 framecnt_t
1485 TempoMap::frame_at_pulse_locked (const Metrics& metrics, const double& pulse) const
1486 {
1487         /* HOLD THE READER LOCK */
1488
1489         const TempoSection* prev_t = 0;
1490
1491         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1492                 TempoSection* t;
1493
1494                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1495                         if (!t->active()) {
1496                                 continue;
1497                         }
1498                         if (prev_t && t->pulse() > pulse) {
1499                                 return prev_t->frame_at_pulse (pulse, _frame_rate);
1500                         }
1501
1502                         prev_t = t;
1503                 }
1504         }
1505         /* must be treated as constant, irrespective of _type */
1506         double const pulses_in_section = pulse - prev_t->pulse();
1507         double const dtime = pulses_in_section * prev_t->frames_per_pulse (_frame_rate);
1508
1509         framecnt_t const ret = (framecnt_t) floor (dtime) + prev_t->frame();
1510
1511         return ret;
1512 }
1513
1514 double
1515 TempoMap::beat_at_frame (const framecnt_t& frame) const
1516 {
1517         Glib::Threads::RWLock::ReaderLock lm (lock);
1518         return beat_at_frame_locked (_metrics, frame);
1519 }
1520
1521 /* meter / tempo section based */
1522 double
1523 TempoMap::beat_at_frame_locked (const Metrics& metrics, const framecnt_t& frame) const
1524 {
1525         const TempoSection& ts = tempo_section_at_locked (metrics, frame);
1526         MeterSection* prev_m = 0;
1527         MeterSection* next_m = 0;
1528
1529         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1530                 MeterSection* m;
1531                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1532                         if (prev_m && m->frame() > frame) {
1533                                 next_m = m;
1534                                 break;
1535                         }
1536                         prev_m = m;
1537                 }
1538         }
1539         if (frame < prev_m->frame()) {
1540                 return 0.0;
1541         }
1542         const double beat = prev_m->beat() + (ts.pulse_at_frame (frame, _frame_rate) - prev_m->pulse()) * prev_m->note_divisor();
1543
1544         if (next_m && next_m->beat() < beat) {
1545                 return next_m->beat();
1546         }
1547
1548         return beat;
1549 }
1550
1551 framecnt_t
1552 TempoMap::frame_at_beat (const double& beat) const
1553 {
1554         Glib::Threads::RWLock::ReaderLock lm (lock);
1555         return frame_at_beat_locked (_metrics, beat);
1556 }
1557
1558 /* meter section based */
1559 framecnt_t
1560 TempoMap::frame_at_beat_locked (const Metrics& metrics, const double& beat) const
1561 {
1562         const TempoSection& prev_t = tempo_section_at_beat_locked (metrics, beat);
1563         MeterSection* prev_m = 0;
1564
1565         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1566                 MeterSection* m;
1567                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1568                         if (prev_m && m->beat() > beat) {
1569                                 break;
1570                         }
1571                         prev_m = m;
1572                 }
1573         }
1574
1575         return prev_t.frame_at_pulse (((beat - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse(), _frame_rate);
1576 }
1577
1578 double
1579 TempoMap::bbt_to_beats (const Timecode::BBT_Time& bbt)
1580 {
1581         Glib::Threads::RWLock::ReaderLock lm (lock);
1582         return bbt_to_beats_locked (_metrics, bbt);
1583 }
1584
1585
1586 double
1587 TempoMap::bbt_to_beats_locked (const Metrics& metrics, const Timecode::BBT_Time& bbt) const
1588 {
1589         /* CALLER HOLDS READ LOCK */
1590
1591         MeterSection* prev_m = 0;
1592
1593         /* because audio-locked meters have 'fake' integral beats,
1594            there is no pulse offset here.
1595         */
1596         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1597                 MeterSection* m;
1598                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1599                         if (prev_m) {
1600                                 const double bars_to_m = (m->beat() - prev_m->beat()) / prev_m->divisions_per_bar();
1601                                 if ((bars_to_m + (prev_m->bbt().bars - 1)) > (bbt.bars - 1)) {
1602                                         break;
1603                                 }
1604                         }
1605                         prev_m = m;
1606                 }
1607         }
1608
1609         const double remaining_bars = bbt.bars - prev_m->bbt().bars;
1610         const double remaining_bars_in_beats = remaining_bars * prev_m->divisions_per_bar();
1611         const double ret = remaining_bars_in_beats + prev_m->beat() + (bbt.beats - 1) + (bbt.ticks / BBT_Time::ticks_per_beat);
1612
1613         return ret;
1614 }
1615
1616 Timecode::BBT_Time
1617 TempoMap::beats_to_bbt (const double& beats)
1618 {
1619         Glib::Threads::RWLock::ReaderLock lm (lock);
1620         return beats_to_bbt_locked (_metrics, beats);
1621 }
1622
1623 Timecode::BBT_Time
1624 TempoMap::beats_to_bbt_locked (const Metrics& metrics, const double& b) const
1625 {
1626         /* CALLER HOLDS READ LOCK */
1627         MeterSection* prev_m = 0;
1628         const double beats = max (0.0, b);
1629
1630         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1631                 MeterSection* m = 0;
1632
1633                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1634                         if (prev_m) {
1635                                 if (m->beat() > beats) {
1636                                         /* this is the meter after the one our beat is on*/
1637                                         break;
1638                                 }
1639                         }
1640
1641                         prev_m = m;
1642                 }
1643         }
1644
1645         const double beats_in_ms = beats - prev_m->beat();
1646         const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar());
1647         const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1);
1648         const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar());
1649         const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
1650
1651         BBT_Time ret;
1652
1653         ret.ticks = (uint32_t) floor (remaining_ticks + 0.5);
1654         ret.beats = (uint32_t) floor (remaining_beats);
1655         ret.bars = total_bars;
1656
1657         /* 0 0 0 to 1 1 0 - based mapping*/
1658         ++ret.bars;
1659         ++ret.beats;
1660
1661         if (ret.ticks >= BBT_Time::ticks_per_beat) {
1662                 ++ret.beats;
1663                 ret.ticks -= BBT_Time::ticks_per_beat;
1664         }
1665
1666         if (ret.beats >= prev_m->divisions_per_bar() + 1) {
1667                 ++ret.bars;
1668                 ret.beats = 1;
1669         }
1670
1671         return ret;
1672 }
1673
1674 Timecode::BBT_Time
1675 TempoMap::pulse_to_bbt (const double& pulse)
1676 {
1677         Glib::Threads::RWLock::ReaderLock lm (lock);
1678         MeterSection* prev_m = 0;
1679
1680         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
1681                 MeterSection* m = 0;
1682
1683                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1684
1685                         if (prev_m) {
1686                                 double const pulses_to_m = m->pulse() - prev_m->pulse();
1687                                 if (prev_m->pulse() + pulses_to_m > pulse) {
1688                                         /* this is the meter after the one our beat is on*/
1689                                         break;
1690                                 }
1691                         }
1692
1693                         prev_m = m;
1694                 }
1695         }
1696
1697         const double beats_in_ms = (pulse - prev_m->pulse()) * prev_m->note_divisor();
1698         const uint32_t bars_in_ms = (uint32_t) floor (beats_in_ms / prev_m->divisions_per_bar());
1699         const uint32_t total_bars = bars_in_ms + (prev_m->bbt().bars - 1);
1700         const double remaining_beats = beats_in_ms - (bars_in_ms * prev_m->divisions_per_bar());
1701         const double remaining_ticks = (remaining_beats - floor (remaining_beats)) * BBT_Time::ticks_per_beat;
1702
1703         BBT_Time ret;
1704
1705         ret.ticks = (uint32_t) floor (remaining_ticks + 0.5);
1706         ret.beats = (uint32_t) floor (remaining_beats);
1707         ret.bars = total_bars;
1708
1709         /* 0 0 0 to 1 1 0 mapping*/
1710         ++ret.bars;
1711         ++ret.beats;
1712
1713         if (ret.ticks >= BBT_Time::ticks_per_beat) {
1714                 ++ret.beats;
1715                 ret.ticks -= BBT_Time::ticks_per_beat;
1716         }
1717
1718         if (ret.beats >= prev_m->divisions_per_bar() + 1) {
1719                 ++ret.bars;
1720                 ret.beats = 1;
1721         }
1722
1723         return ret;
1724 }
1725
1726 void
1727 TempoMap::bbt_time (framepos_t frame, BBT_Time& bbt)
1728 {
1729
1730         if (frame < 0) {
1731                 bbt.bars = 1;
1732                 bbt.beats = 1;
1733                 bbt.ticks = 0;
1734                 warning << string_compose (_("tempo map asked for BBT time at frame %1\n"), frame) << endmsg;
1735                 return;
1736         }
1737         Glib::Threads::RWLock::ReaderLock lm (lock);
1738         const double beat = beat_at_frame_locked (_metrics, frame);
1739
1740         bbt = beats_to_bbt_locked (_metrics, beat);
1741 }
1742
1743 framepos_t
1744 TempoMap::frame_time (const BBT_Time& bbt)
1745 {
1746         if (bbt.bars < 1) {
1747                 warning << string_compose (_("tempo map asked for frame time at bar < 1  (%1)\n"), bbt) << endmsg;
1748                 return 0;
1749         }
1750
1751         if (bbt.beats < 1) {
1752                 throw std::logic_error ("beats are counted from one");
1753         }
1754         Glib::Threads::RWLock::ReaderLock lm (lock);
1755
1756         return frame_time_locked (_metrics, bbt);
1757 }
1758
1759 /* meter section based */
1760 framepos_t
1761 TempoMap::frame_time_locked (const Metrics& metrics, const BBT_Time& bbt) const
1762 {
1763         /* HOLD THE READER LOCK */
1764
1765         const framepos_t ret = frame_at_beat_locked (metrics, bbt_to_beats_locked (metrics, bbt));
1766         return ret;
1767 }
1768
1769 bool
1770 TempoMap::check_solved (const Metrics& metrics) const
1771 {
1772         TempoSection* prev_t = 0;
1773         MeterSection* prev_m = 0;
1774
1775         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1776                 TempoSection* t;
1777                 MeterSection* m;
1778                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1779                         if (!t->active()) {
1780                                 continue;
1781                         }
1782                         if (prev_t) {
1783                                 if ((t->frame() <= prev_t->frame()) || (t->pulse() <= prev_t->pulse())) {
1784                                         return false;
1785                                 }
1786
1787                                 /* precision check ensures pulses and frames align.*/
1788                                 if (t->frame() != prev_t->frame_at_pulse (t->pulse(), _frame_rate)) {
1789                                         if (!t->locked_to_meter()) {
1790                                                 return false;
1791                                         }
1792                                 }
1793                         }
1794                         prev_t = t;
1795                 }
1796
1797                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1798                         if (prev_m && m->position_lock_style() == AudioTime) {
1799                                 TempoSection* t = const_cast<TempoSection*>(&tempo_section_at_locked (metrics, m->frame() - 1));
1800                                 const double nascent_m_pulse = ((m->beat() - prev_m->beat()) / prev_m->note_divisor()) + prev_m->pulse();
1801                                 const framepos_t nascent_m_frame = t->frame_at_pulse (nascent_m_pulse, _frame_rate);
1802
1803                                 if (t && (nascent_m_frame > m->frame() || nascent_m_frame < 0)) {
1804                                         return false;
1805                                 }
1806                         }
1807
1808                         prev_m = m;
1809                 }
1810
1811         }
1812
1813         return true;
1814 }
1815
1816 bool
1817 TempoMap::set_active_tempos (const Metrics& metrics, const framepos_t& frame)
1818 {
1819         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
1820                 TempoSection* t;
1821                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1822                         if (!t->movable()) {
1823                                 t->set_active (true);
1824                                 continue;
1825                         }
1826                         if (t->movable() && t->active () && t->position_lock_style() == AudioTime && t->frame() < frame) {
1827                                 t->set_active (false);
1828                                 t->set_pulse (0.0);
1829                         } else if (t->movable() && t->position_lock_style() == AudioTime && t->frame() > frame) {
1830                                 t->set_active (true);
1831                         } else if (t->movable() && t->position_lock_style() == AudioTime && t->frame() == frame) {
1832                                 return false;
1833                         }
1834                 }
1835         }
1836         return true;
1837 }
1838
1839 bool
1840 TempoMap::solve_map_frame (Metrics& imaginary, TempoSection* section, const framepos_t& frame)
1841 {
1842         TempoSection* prev_t = 0;
1843         TempoSection* section_prev = 0;
1844         framepos_t first_m_frame = 0;
1845
1846         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
1847                 MeterSection* m;
1848                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
1849                         if (!m->movable()) {
1850                                 first_m_frame = m->frame();
1851                                 break;
1852                         }
1853                 }
1854         }
1855         if (section->movable() && frame <= first_m_frame) {
1856                 return false;
1857         }
1858
1859         section->set_active (true);
1860         section->set_frame (frame);
1861
1862         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
1863                 TempoSection* t;
1864                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1865
1866                         if (!t->active()) {
1867                                 continue;
1868                         }
1869                         if (prev_t) {
1870                                 if (t == section) {
1871                                         section_prev = prev_t;
1872                                         continue;
1873                                 }
1874                                 if (t->position_lock_style() == MusicTime) {
1875                                         prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
1876                                         t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
1877                                 } else {
1878                                         prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
1879                                         if (!t->locked_to_meter()) {
1880                                                 t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
1881                                         }
1882                                 }
1883                         }
1884                         prev_t = t;
1885                 }
1886         }
1887
1888         if (section_prev) {
1889                 section_prev->set_c_func (section_prev->compute_c_func_frame (section->pulses_per_minute(), frame, _frame_rate));
1890                 if (!section->locked_to_meter()) {
1891                         section->set_pulse (section_prev->pulse_at_frame (frame, _frame_rate));
1892                 }
1893         }
1894
1895         recompute_tempos (imaginary);
1896
1897         if (check_solved (imaginary)) {
1898                 return true;
1899         }
1900
1901         MetricSectionFrameSorter fcmp;
1902         imaginary.sort (fcmp);
1903
1904         recompute_tempos (imaginary);
1905
1906         if (check_solved (imaginary)) {
1907                 return true;
1908         }
1909
1910         return false;
1911 }
1912
1913 bool
1914 TempoMap::solve_map_pulse (Metrics& imaginary, TempoSection* section, const double& pulse)
1915 {
1916         TempoSection* prev_t = 0;
1917         TempoSection* section_prev = 0;
1918
1919         section->set_pulse (pulse);
1920
1921         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
1922                 TempoSection* t;
1923                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
1924                         if (!t->active()) {
1925                                 continue;
1926                         }
1927                         if (!t->movable()) {
1928                                 t->set_pulse (0.0);
1929                                 prev_t = t;
1930                                 continue;
1931                         }
1932                         if (prev_t) {
1933                                 if (t == section) {
1934                                         section_prev = prev_t;
1935                                         continue;
1936                                 }
1937                                 if (t->position_lock_style() == MusicTime) {
1938                                         prev_t->set_c_func (prev_t->compute_c_func_pulse (t->pulses_per_minute(), t->pulse(), _frame_rate));
1939                                         t->set_frame (prev_t->frame_at_pulse (t->pulse(), _frame_rate));
1940                                 } else {
1941                                         prev_t->set_c_func (prev_t->compute_c_func_frame (t->pulses_per_minute(), t->frame(), _frame_rate));
1942                                         if (!t->locked_to_meter()) {
1943                                                 t->set_pulse (prev_t->pulse_at_frame (t->frame(), _frame_rate));
1944                                         }
1945                                 }
1946                         }
1947                         prev_t = t;
1948                 }
1949         }
1950
1951         if (section_prev) {
1952                 section_prev->set_c_func (section_prev->compute_c_func_pulse (section->pulses_per_minute(), pulse, _frame_rate));
1953                 section->set_frame (section_prev->frame_at_pulse (pulse, _frame_rate));
1954         }
1955
1956         recompute_tempos (imaginary);
1957
1958         if (check_solved (imaginary)) {
1959                 return true;
1960         }
1961
1962         MetricSectionSorter cmp;
1963         imaginary.sort (cmp);
1964
1965         recompute_tempos (imaginary);
1966         /* Reordering
1967          * XX need a restriction here, but only for this case,
1968          * as audio locked tempos don't interact in the same way.
1969          *
1970          * With music-locked tempos, the solution to cross-dragging can fly off the screen
1971          * e.g.
1972          * |50 bpm                        |250 bpm |60 bpm
1973          *                drag 250 to the pulse after 60->
1974          * a clue: dragging the second 60 <- past the 250 would cause no such problem.
1975          */
1976         if (check_solved (imaginary)) {
1977                 return true;
1978         }
1979
1980         return false;
1981 }
1982
1983 bool
1984 TempoMap::solve_map_frame (Metrics& imaginary, MeterSection* section, const framepos_t& frame)
1985 {
1986         /* disallow moving first meter past any subsequent one, and any movable meter before the first one */
1987         const MeterSection* other =  &meter_section_at_locked (imaginary, frame);
1988         if ((!section->movable() && other->movable()) || (!other->movable() && section->movable() && other->frame() >= frame)) {
1989                 return false;
1990         }
1991
1992         if (!section->movable()) {
1993                 /* lock the first tempo to our first meter */
1994                 if (!set_active_tempos (imaginary, frame)) {
1995                         return false;
1996                 }
1997         }
1998
1999         /* it would make sense to bail out if there is no audio-locked meter,
2000            however it may be desirable to move a music-locked meter by frame at some point.
2001         */
2002         TempoSection* meter_locked_tempo = 0;
2003         for (Metrics::const_iterator ii = imaginary.begin(); ii != imaginary.end(); ++ii) {
2004                 TempoSection* t;
2005                 if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
2006                         if ((t->locked_to_meter() || !t->movable()) && t->frame() == section->frame()) {
2007                                 meter_locked_tempo = t;
2008                                 break;
2009                         }
2010                 }
2011         }
2012
2013         if (!meter_locked_tempo) {
2014                 return false;
2015         }
2016
2017         MeterSection* prev_m = 0;
2018         Metrics future_map;
2019         TempoSection* tempo_copy = copy_metrics_and_point (imaginary, future_map, meter_locked_tempo);
2020         bool solved = false;
2021
2022         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
2023                 MeterSection* m;
2024                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
2025                         if (m == section){
2026                                 if (prev_m && section->movable()) {
2027                                         const double beats = (pulse_at_frame_locked (imaginary, frame) - prev_m->pulse()) * prev_m->note_divisor();
2028                                         if (beats + prev_m->beat() < section->beat()) {
2029                                                 /* set the frame/pulse corresponding to its musical position,
2030                                                  * as an earlier time than this has been requested.
2031                                                 */
2032                                                 const double new_pulse = ((section->beat() - prev_m->beat())
2033                                                                           / prev_m->note_divisor()) + prev_m->pulse();
2034
2035                                                 const framepos_t smallest_frame = frame_at_pulse_locked (future_map, new_pulse);
2036
2037                                                 if ((solved = solve_map_frame (future_map, tempo_copy, smallest_frame))) {
2038                                                         meter_locked_tempo->set_pulse (new_pulse);
2039                                                         solve_map_frame (imaginary, meter_locked_tempo, smallest_frame);
2040                                                         section->set_frame (smallest_frame);
2041                                                         section->set_pulse (new_pulse);
2042                                                 } else {
2043                                                         solved = false;
2044                                                 }
2045
2046                                                 Metrics::const_iterator d = future_map.begin();
2047                                                 while (d != future_map.end()) {
2048                                                         delete (*d);
2049                                                         ++d;
2050                                                 }
2051
2052                                                 if (!solved) {
2053                                                         return false;
2054                                                 }
2055                                         } else {
2056                                                 /* all is ok. set section's tempo */
2057                                                 MeterSection* meter_copy = const_cast<MeterSection*> (&meter_section_at_locked (future_map, section->frame()));
2058                                                 meter_copy->set_frame (frame);
2059
2060                                                 if ((solved = solve_map_frame (future_map, tempo_copy, frame))) {
2061                                                         section->set_frame (frame);
2062                                                         meter_locked_tempo->set_pulse (((section->beat() - prev_m->beat())
2063                                                                                                 / prev_m->note_divisor()) + prev_m->pulse());
2064                                                         solve_map_frame (imaginary, meter_locked_tempo, frame);
2065                                                 } else {
2066                                                         solved = false;
2067                                                 }
2068
2069                                                 Metrics::const_iterator d = future_map.begin();
2070                                                 while (d != future_map.end()) {
2071                                                         delete (*d);
2072                                                         ++d;
2073                                                 }
2074
2075                                                 if (!solved) {
2076                                                         return false;
2077                                                 }
2078                                         }
2079                                 } else {
2080                                         /* not movable (first meter atm) */
2081
2082                                         tempo_copy->set_frame (frame);
2083                                         tempo_copy->set_pulse (0.0);
2084
2085                                         if ((solved = solve_map_frame (future_map, tempo_copy, frame))) {
2086                                                 section->set_frame (frame);
2087                                                 meter_locked_tempo->set_frame (frame);
2088                                                 meter_locked_tempo->set_pulse (0.0);
2089                                                 solve_map_frame (imaginary, meter_locked_tempo, frame);
2090                                         } else {
2091                                                 solved = false;
2092                                         }
2093
2094                                         Metrics::const_iterator d = future_map.begin();
2095                                         while (d != future_map.end()) {
2096                                                 delete (*d);
2097                                                 ++d;
2098                                         }
2099
2100                                         if (!solved) {
2101                                                 return false;
2102                                         }
2103
2104                                         pair<double, BBT_Time> b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
2105                                         section->set_beat (b_bbt);
2106                                         section->set_pulse (0.0);
2107
2108                                 }
2109                                 break;
2110                         }
2111
2112                         prev_m = m;
2113                 }
2114         }
2115
2116         MetricSectionFrameSorter fcmp;
2117         imaginary.sort (fcmp);
2118
2119         recompute_meters (imaginary);
2120
2121         return true;
2122 }
2123
2124 bool
2125 TempoMap::solve_map_bbt (Metrics& imaginary, MeterSection* section, const BBT_Time& when)
2126 {
2127         /* disallow setting section to an existing meter's bbt */
2128         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
2129                 MeterSection* m;
2130                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
2131                         if (m != section && m->bbt().bars == when.bars) {
2132                                 return false;
2133                         }
2134                 }
2135         }
2136
2137         MeterSection* prev_m = 0;
2138         MeterSection* section_prev = 0;
2139
2140         for (Metrics::iterator i = imaginary.begin(); i != imaginary.end(); ++i) {
2141                 MeterSection* m;
2142                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
2143                         pair<double, BBT_Time> b_bbt;
2144                         double new_pulse = 0.0;
2145
2146                         if (prev_m && m->bbt().bars > when.bars && !section_prev){
2147                                 section_prev = prev_m;
2148                                 const double beats = (when.bars - section_prev->bbt().bars) * section_prev->divisions_per_bar();
2149                                 const double pulse = (beats / section_prev->note_divisor()) + section_prev->pulse();
2150                                 pair<double, BBT_Time> b_bbt = make_pair (beats + section_prev->beat(), when);
2151
2152                                 section->set_beat (b_bbt);
2153                                 section->set_pulse (pulse);
2154                                 section->set_frame (frame_at_pulse_locked (imaginary, pulse));
2155                                 prev_m = section;
2156                                 continue;
2157                         }
2158
2159                         if (m->position_lock_style() == AudioTime) {
2160                                 TempoSection* meter_locked_tempo = 0;
2161
2162                                 for (Metrics::const_iterator ii = imaginary.begin(); ii != imaginary.end(); ++ii) {
2163                                         TempoSection* t;
2164                                         if ((t = dynamic_cast<TempoSection*> (*ii)) != 0) {
2165                                                 if ((t->locked_to_meter() || !t->movable()) && t->frame() == m->frame()) {
2166                                                         meter_locked_tempo = t;
2167                                                         break;
2168                                                 }
2169                                         }
2170                                 }
2171
2172                                 if (!meter_locked_tempo) {
2173                                         return false;
2174                                 }
2175
2176                                 if (prev_m) {
2177                                         const double beats = ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar());
2178
2179                                         if (beats + prev_m->beat() != m->beat()) {
2180                                                 /* tempo/ meter change caused a change in beat (bar). */
2181                                                 b_bbt = make_pair (beats + prev_m->beat()
2182                                                                    , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
2183                                                 new_pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
2184                                         } else if (m->movable()) {
2185                                                 b_bbt = make_pair (m->beat(), m->bbt());
2186                                                 new_pulse = prev_m->pulse() + (beats / prev_m->note_divisor());
2187                                         }
2188                                 } else {
2189                                         b_bbt = make_pair (0.0, BBT_Time (1, 1, 0));
2190                                 }
2191
2192                                 meter_locked_tempo->set_pulse (new_pulse);
2193                                 m->set_beat (b_bbt);
2194                                 m->set_pulse (new_pulse);
2195
2196                         } else {
2197                                 /* MusicTime */
2198                                 const double beats = ((m->bbt().bars - prev_m->bbt().bars) * prev_m->divisions_per_bar());
2199                                 if (beats + prev_m->beat() != m->beat()) {
2200                                         /* tempo/ meter change caused a change in beat (bar). */
2201                                         b_bbt = make_pair (beats + prev_m->beat()
2202                                                            , BBT_Time ((beats / prev_m->divisions_per_bar()) + prev_m->bbt().bars, 1, 0));
2203                                 } else {
2204                                         b_bbt = make_pair (beats + prev_m->beat()
2205                                                            , m->bbt());
2206                                 }
2207                                 new_pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
2208                                 m->set_beat (b_bbt);
2209                                 m->set_pulse (new_pulse);
2210                                 m->set_frame (frame_at_pulse_locked (imaginary, new_pulse));
2211                         }
2212
2213                         prev_m = m;
2214                 }
2215         }
2216
2217         if (!section_prev) {
2218
2219                 const double beats = (when.bars - prev_m->bbt().bars) * prev_m->divisions_per_bar();
2220                 const double pulse = (beats / prev_m->note_divisor()) + prev_m->pulse();
2221                 pair<double, BBT_Time> b_bbt = make_pair (beats + prev_m->beat(), when);
2222
2223                 section->set_beat (b_bbt);
2224                 section->set_pulse (pulse);
2225                 section->set_frame (frame_at_pulse_locked (imaginary, pulse));
2226         }
2227
2228         MetricSectionSorter cmp;
2229         imaginary.sort (cmp);
2230
2231         recompute_meters (imaginary);
2232
2233         return true;
2234 }
2235
2236 /** places a copy of _metrics into copy and returns a pointer
2237  *  to section's equivalent in copy.
2238  */
2239 TempoSection*
2240 TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, TempoSection* section)
2241 {
2242         TempoSection* ret = 0;
2243
2244         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
2245                 TempoSection* t;
2246                 MeterSection* m;
2247                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2248                         if (t == section) {
2249                                 ret = new TempoSection (*t);
2250                                 copy.push_back (ret);
2251                                 continue;
2252                         }
2253
2254                         TempoSection* cp = new TempoSection (*t);
2255                         copy.push_back (cp);
2256                 }
2257                 if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
2258                         MeterSection* cp = new MeterSection (*m);
2259                         copy.push_back (cp);
2260                 }
2261         }
2262
2263         return ret;
2264 }
2265
2266 MeterSection*
2267 TempoMap::copy_metrics_and_point (const Metrics& metrics, Metrics& copy, MeterSection* section)
2268 {
2269         MeterSection* ret = 0;
2270
2271         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
2272                 TempoSection* t;
2273                 MeterSection* m;
2274                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2275                         TempoSection* cp = new TempoSection (*t);
2276                         copy.push_back (cp);
2277                 }
2278
2279                 if ((m = dynamic_cast<MeterSection *> (*i)) != 0) {
2280                         if (m == section) {
2281                                 ret = new MeterSection (*m);
2282                                 copy.push_back (ret);
2283                                 continue;
2284                         }
2285                         MeterSection* cp = new MeterSection (*m);
2286                         copy.push_back (cp);
2287                 }
2288         }
2289
2290         return ret;
2291 }
2292
2293 bool
2294 TempoMap::can_solve_bbt (TempoSection* ts, const BBT_Time& bbt)
2295 {
2296         Metrics copy;
2297         TempoSection* tempo_copy = 0;
2298
2299         {
2300                 Glib::Threads::RWLock::ReaderLock lm (lock);
2301                 tempo_copy = copy_metrics_and_point (_metrics, copy, ts);
2302                 if (!tempo_copy) {
2303                         return false;
2304                 }
2305         }
2306
2307         const double beat = bbt_to_beats_locked (copy, bbt);
2308         const bool ret = solve_map_pulse (copy, tempo_copy, pulse_at_beat_locked (copy, beat));
2309
2310         Metrics::const_iterator d = copy.begin();
2311         while (d != copy.end()) {
2312                 delete (*d);
2313                 ++d;
2314         }
2315
2316         return ret;
2317 }
2318
2319 /**
2320 * This is for a gui that needs to know the pulse or frame of a tempo section if it were to be moved to some bbt time,
2321 * taking any possible reordering as a consequence of this into account.
2322 * @param section - the section to be altered
2323 * @param bbt - the bbt where the altered tempo will fall
2324 * @return returns - the position in pulses and frames (as a pair) where the new tempo section will lie.
2325 */
2326 pair<double, framepos_t>
2327 TempoMap::predict_tempo_position (TempoSection* section, const BBT_Time& bbt)
2328 {
2329         Metrics future_map;
2330         pair<double, framepos_t> ret = make_pair (0.0, 0);
2331
2332         Glib::Threads::RWLock::ReaderLock lm (lock);
2333
2334         TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, section);
2335
2336         const double beat = bbt_to_beats_locked (future_map, bbt);
2337
2338         if (solve_map_pulse (future_map, tempo_copy, pulse_at_beat_locked (future_map, beat))) {
2339                 ret.first = tempo_copy->pulse();
2340                 ret.second = tempo_copy->frame();
2341         } else {
2342                 ret.first = section->pulse();
2343                 ret.second = section->frame();
2344         }
2345
2346         Metrics::const_iterator d = future_map.begin();
2347         while (d != future_map.end()) {
2348                 delete (*d);
2349                 ++d;
2350         }
2351         return ret;
2352 }
2353
2354 void
2355 TempoMap::gui_move_tempo (TempoSection* ts, const pair<double, framepos_t>& pulse)
2356 {
2357         Metrics future_map;
2358
2359         if (ts->position_lock_style() == MusicTime) {
2360                 {
2361                         Glib::Threads::RWLock::WriterLock lm (lock);
2362                         TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
2363                         if (solve_map_pulse (future_map, tempo_copy, pulse.first)) {
2364                                 solve_map_pulse (_metrics, ts, pulse.first);
2365                                 recompute_meters (_metrics);
2366                         }
2367                 }
2368
2369         } else {
2370
2371                 {
2372                         Glib::Threads::RWLock::WriterLock lm (lock);
2373                         TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
2374                         if (solve_map_frame (future_map, tempo_copy, pulse.second)) {
2375                                 solve_map_frame (_metrics, ts, pulse.second);
2376                                 recompute_meters (_metrics);
2377                         }
2378                 }
2379         }
2380
2381         Metrics::const_iterator d = future_map.begin();
2382         while (d != future_map.end()) {
2383                 delete (*d);
2384                 ++d;
2385         }
2386
2387         MetricPositionChanged (); // Emit Signal
2388 }
2389
2390 void
2391 TempoMap::gui_move_meter (MeterSection* ms, const framepos_t& frame)
2392 {
2393         Metrics future_map;
2394
2395         if (ms->position_lock_style() == AudioTime) {
2396
2397                 {
2398                         Glib::Threads::RWLock::WriterLock lm (lock);
2399                         MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
2400
2401                         if (solve_map_frame (future_map, copy, frame)) {
2402                                 solve_map_frame (_metrics, ms, frame);
2403                                 recompute_tempos (_metrics);
2404                         }
2405                 }
2406         } else {
2407                 {
2408                         Glib::Threads::RWLock::WriterLock lm (lock);
2409                         MeterSection* copy = copy_metrics_and_point (_metrics, future_map, ms);
2410
2411                         const double beat = beat_at_frame_locked (_metrics, frame);
2412                         const Timecode::BBT_Time bbt = beats_to_bbt_locked (_metrics, beat);
2413
2414                         if (solve_map_bbt (future_map, copy, bbt)) {
2415                                 solve_map_bbt (_metrics, ms, bbt);
2416                                 recompute_tempos (_metrics);
2417                         }
2418                 }
2419         }
2420
2421         Metrics::const_iterator d = future_map.begin();
2422         while (d != future_map.end()) {
2423                 delete (*d);
2424                 ++d;
2425         }
2426
2427         MetricPositionChanged (); // Emit Signal
2428 }
2429
2430 bool
2431 TempoMap::gui_change_tempo (TempoSection* ts, const Tempo& bpm)
2432 {
2433         Metrics future_map;
2434         bool can_solve = false;
2435         {
2436                 Glib::Threads::RWLock::WriterLock lm (lock);
2437                 TempoSection* tempo_copy = copy_metrics_and_point (_metrics, future_map, ts);
2438                 tempo_copy->set_beats_per_minute (bpm.beats_per_minute());
2439                 recompute_tempos (future_map);
2440
2441                 if (check_solved (future_map)) {
2442                         ts->set_beats_per_minute (bpm.beats_per_minute());
2443                         recompute_map (_metrics);
2444                         can_solve = true;
2445                 }
2446         }
2447
2448         Metrics::const_iterator d = future_map.begin();
2449         while (d != future_map.end()) {
2450                 delete (*d);
2451                 ++d;
2452         }
2453         if (can_solve) {
2454                 MetricPositionChanged (); // Emit Signal
2455         }
2456         return can_solve;
2457 }
2458
2459 void
2460 TempoMap::gui_dilate_tempo (TempoSection* ts, const framepos_t& frame, const framepos_t& end_frame, const double& pulse)
2461 {
2462         /*
2463           Ts (future prev_t)   Tnext
2464           |                    |
2465           |     [drag^]        |
2466           |----------|----------
2467                 e_f  pulse(frame)
2468         */
2469
2470         Metrics future_map;
2471
2472         {
2473                 Glib::Threads::RWLock::WriterLock lm (lock);
2474
2475                 if (!ts) {
2476                         return;
2477                 }
2478
2479                 TempoSection* prev_t = copy_metrics_and_point (_metrics, future_map, ts);
2480                 TempoSection* prev_to_prev_t = 0;
2481                 const frameoffset_t fr_off = end_frame - frame;
2482
2483                 if (prev_t && prev_t->pulse() > 0.0) {
2484                         prev_to_prev_t = const_cast<TempoSection*>(&tempo_section_at_locked (future_map, prev_t->frame() - 1));
2485                 }
2486
2487                 TempoSection* next_t = 0;
2488                 for (Metrics::iterator i = future_map.begin(); i != future_map.end(); ++i) {
2489                         TempoSection* t = 0;
2490                         if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2491                                 if (t->frame() > ts->frame()) {
2492                                         next_t = t;
2493                                         break;
2494                                 }
2495                         }
2496                 }
2497
2498                 /* the change in frames is the result of changing the slope of at most 2 previous tempo sections.
2499                    constant to constant is straightforward, as the tempo prev to prev_t has constant slope.
2500                 */
2501                 double contribution = 0.0;
2502                 double start_pulse = prev_t->pulse_at_frame (frame, _frame_rate);
2503
2504                 if (next_t && prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
2505                         contribution = (prev_t->frame() - prev_to_prev_t->frame()) / (double) (next_t->frame() - prev_to_prev_t->frame());
2506                 }
2507
2508                 frameoffset_t prev_t_frame_contribution = fr_off - (contribution * (double) fr_off);
2509                 double end_pulse = prev_t->pulse_at_frame (end_frame, _frame_rate);
2510                 double new_bpm;
2511
2512                 if (prev_t->type() == TempoSection::Constant || prev_t->c_func() == 0.0) {
2513
2514                         if (prev_t->position_lock_style() == MusicTime) {
2515                                 if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
2516
2517                                         new_bpm = prev_t->beats_per_minute() * ((frame - prev_to_prev_t->frame())
2518                                                                                 / (double) ((frame + prev_t_frame_contribution) - prev_to_prev_t->frame()));
2519
2520                                 } else {
2521                                         /* prev to prev is irrelevant */
2522
2523                                         if (start_pulse != prev_t->pulse()) {
2524                                                 new_bpm = prev_t->beats_per_minute() * ((start_pulse - prev_t->pulse()) / (end_pulse - prev_t->pulse()));
2525                                         } else {
2526                                                 new_bpm = prev_t->beats_per_minute();
2527                                         }
2528                                 }
2529                         } else {
2530                                 /* AudioTime */
2531                                 if (prev_to_prev_t && prev_to_prev_t->type() == TempoSection::Ramp) {
2532                                         new_bpm = prev_t->beats_per_minute() * ((frame - prev_t->frame())
2533                                                                                 / (double) ((frame + prev_t_frame_contribution) - prev_t->frame()));
2534                                 } else {
2535                                         /* prev_to_prev_t is irrelevant */
2536
2537                                         if (end_frame != prev_t->frame()) {
2538                                                 new_bpm = prev_t->beats_per_minute() * ((frame - prev_t->frame()) / (double) (end_frame - prev_t->frame()));
2539                                         } else {
2540                                                 new_bpm = prev_t->beats_per_minute();
2541                                         }
2542                                 }
2543                         }
2544                 } else {
2545
2546                         double frame_ratio;
2547                         double pulse_ratio;
2548                         const framepos_t pulse_pos = prev_t->frame_at_pulse (pulse, _frame_rate);
2549
2550                         if (prev_to_prev_t) {
2551
2552                                 frame_ratio = (((pulse_pos - fr_off) - prev_to_prev_t->frame()) / (double) ((pulse_pos) - prev_to_prev_t->frame()));
2553                                 pulse_ratio = ((start_pulse - prev_to_prev_t->pulse()) / (end_pulse - prev_to_prev_t->pulse()));
2554                         } else {
2555
2556                                 frame_ratio = (((pulse_pos - fr_off) - prev_t->frame()) / (double) ((pulse_pos) - prev_t->frame()));
2557                                 pulse_ratio = (start_pulse / end_pulse);
2558                         }
2559                         new_bpm = prev_t->beats_per_minute() * (pulse_ratio * frame_ratio);
2560                 }
2561
2562                 prev_t->set_beats_per_minute (new_bpm);
2563                 recompute_tempos (future_map);
2564                 recompute_meters (future_map);
2565
2566                 if (check_solved (future_map)) {
2567                         ts->set_beats_per_minute (new_bpm);
2568                         recompute_tempos (_metrics);
2569                         recompute_meters (_metrics);
2570                 }
2571         }
2572
2573         Metrics::const_iterator d = future_map.begin();
2574         while (d != future_map.end()) {
2575                 delete (*d);
2576                 ++d;
2577         }
2578
2579         MetricPositionChanged (); // Emit Signal
2580 }
2581
2582 framecnt_t
2583 TempoMap::bbt_duration_at (framepos_t pos, const BBT_Time& bbt, int dir)
2584 {
2585         Glib::Threads::RWLock::ReaderLock lm (lock);
2586
2587         const double tick_at_time = beat_at_frame_locked (_metrics, pos) * BBT_Time::ticks_per_beat;
2588         const double bbt_ticks = bbt.ticks + (bbt.beats * BBT_Time::ticks_per_beat);
2589         const double total_beats = (tick_at_time + bbt_ticks) / BBT_Time::ticks_per_beat;
2590
2591         return frame_at_beat_locked (_metrics, total_beats);
2592 }
2593
2594 framepos_t
2595 TempoMap::round_to_bar (framepos_t fr, RoundMode dir)
2596 {
2597         return round_to_type (fr, dir, Bar);
2598 }
2599
2600 framepos_t
2601 TempoMap::round_to_beat (framepos_t fr, RoundMode dir)
2602 {
2603         return round_to_type (fr, dir, Beat);
2604 }
2605
2606 framepos_t
2607 TempoMap::round_to_beat_subdivision (framepos_t fr, int sub_num, RoundMode dir)
2608 {
2609         Glib::Threads::RWLock::ReaderLock lm (lock);
2610         uint32_t ticks = (uint32_t) floor (beat_at_frame_locked (_metrics, fr) * BBT_Time::ticks_per_beat);
2611         uint32_t beats = (uint32_t) floor (ticks / BBT_Time::ticks_per_beat);
2612         uint32_t ticks_one_subdivisions_worth = (uint32_t) BBT_Time::ticks_per_beat / sub_num;
2613
2614         ticks -= beats * BBT_Time::ticks_per_beat;
2615
2616         if (dir > 0) {
2617                 /* round to next (or same iff dir == RoundUpMaybe) */
2618
2619                 uint32_t mod = ticks % ticks_one_subdivisions_worth;
2620
2621                 if (mod == 0 && dir == RoundUpMaybe) {
2622                         /* right on the subdivision, which is fine, so do nothing */
2623
2624                 } else if (mod == 0) {
2625                         /* right on the subdivision, so the difference is just the subdivision ticks */
2626                         ticks += ticks_one_subdivisions_worth;
2627
2628                 } else {
2629                         /* not on subdivision, compute distance to next subdivision */
2630
2631                         ticks += ticks_one_subdivisions_worth - mod;
2632                 }
2633
2634                 if (ticks >= BBT_Time::ticks_per_beat) {
2635                         ticks -= BBT_Time::ticks_per_beat;
2636                 }
2637         } else if (dir < 0) {
2638
2639                 /* round to previous (or same iff dir == RoundDownMaybe) */
2640
2641                 uint32_t difference = ticks % ticks_one_subdivisions_worth;
2642
2643                 if (difference == 0 && dir == RoundDownAlways) {
2644                         /* right on the subdivision, but force-rounding down,
2645                            so the difference is just the subdivision ticks */
2646                         difference = ticks_one_subdivisions_worth;
2647                 }
2648
2649                 if (ticks < difference) {
2650                         ticks = BBT_Time::ticks_per_beat - ticks;
2651                 } else {
2652                         ticks -= difference;
2653                 }
2654
2655         } else {
2656                 /* round to nearest */
2657                 double rem;
2658
2659                 /* compute the distance to the previous and next subdivision */
2660
2661                 if ((rem = fmod ((double) ticks, (double) ticks_one_subdivisions_worth)) > ticks_one_subdivisions_worth/2.0) {
2662
2663                         /* closer to the next subdivision, so shift forward */
2664
2665                         ticks = lrint (ticks + (ticks_one_subdivisions_worth - rem));
2666
2667                         DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("moved forward to %1\n", ticks));
2668
2669                         if (ticks > BBT_Time::ticks_per_beat) {
2670                                 ++beats;
2671                                 ticks -= BBT_Time::ticks_per_beat;
2672                                 DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("fold beat to %1\n", beats));
2673                         }
2674
2675                 } else if (rem > 0) {
2676
2677                         /* closer to previous subdivision, so shift backward */
2678
2679                         if (rem > ticks) {
2680                                 if (beats == 0) {
2681                                         /* can't go backwards past zero, so ... */
2682                                         return 0;
2683                                 }
2684                                 /* step back to previous beat */
2685                                 --beats;
2686                                 ticks = lrint (BBT_Time::ticks_per_beat - rem);
2687                                 DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("step back beat to %1\n", beats));
2688                         } else {
2689                                 ticks = lrint (ticks - rem);
2690                                 DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("moved backward to %1\n", ticks));
2691                         }
2692                 } else {
2693                         /* on the subdivision, do nothing */
2694                 }
2695         }
2696
2697         const framepos_t ret_frame = frame_at_beat_locked (_metrics, beats + (ticks / BBT_Time::ticks_per_beat));
2698
2699         return ret_frame;
2700 }
2701
2702 void
2703 TempoMap::round_bbt (BBT_Time& when, const int32_t& sub_num, RoundMode dir)
2704 {
2705         if (sub_num == -1) {
2706                 if (dir > 0) {
2707                         ++when.bars;
2708                         when.beats = 1;
2709                         when.ticks = 0;
2710                 } else if (dir < 0) {
2711                         when.beats = 1;
2712                         when.ticks = 0;
2713                 } else {
2714                         const double bpb = meter_section_at_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
2715                         if ((double) when.beats > bpb / 2.0) {
2716                                 ++when.bars;
2717                         }
2718                         when.beats = 1;
2719                         when.ticks = 0;
2720                 }
2721
2722                 return;
2723
2724         } else if (sub_num == 0) {
2725                 const double bpb = meter_section_at_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
2726                 if ((double) when.ticks > BBT_Time::ticks_per_beat / 2.0) {
2727                         ++when.beats;
2728                         while ((double) when.beats > bpb) {
2729                                 ++when.bars;
2730                                 when.beats -= (uint32_t) floor (bpb);
2731                         }
2732                 }
2733                 when.ticks = 0;
2734
2735                 return;
2736         }
2737
2738         const uint32_t ticks_one_subdivisions_worth = BBT_Time::ticks_per_beat / sub_num;
2739
2740         if (dir > 0) {
2741                 /* round to next (or same iff dir == RoundUpMaybe) */
2742
2743                 uint32_t mod = when.ticks % ticks_one_subdivisions_worth;
2744
2745                 if (mod == 0 && dir == RoundUpMaybe) {
2746                         /* right on the subdivision, which is fine, so do nothing */
2747
2748                 } else if (mod == 0) {
2749                         /* right on the subdivision, so the difference is just the subdivision ticks */
2750                         when.ticks += ticks_one_subdivisions_worth;
2751
2752                 } else {
2753                         /* not on subdivision, compute distance to next subdivision */
2754
2755                         when.ticks += ticks_one_subdivisions_worth - mod;
2756                 }
2757
2758                 if (when.ticks >= BBT_Time::ticks_per_beat) {
2759                         ++when.beats;
2760                         const double bpb = meter_section_at_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
2761                         if ((double) when.beats > bpb) {
2762                                 ++when.bars;
2763                                 when.beats = 1;
2764                         }
2765                         when.ticks -= BBT_Time::ticks_per_beat;
2766                 }
2767
2768         } else if (dir < 0) {
2769                 /* round to previous (or same iff dir == RoundDownMaybe) */
2770
2771                 uint32_t difference = when.ticks % ticks_one_subdivisions_worth;
2772
2773                 if (difference == 0 && dir == RoundDownAlways) {
2774                         /* right on the subdivision, but force-rounding down,
2775                            so the difference is just the subdivision ticks */
2776                         difference = ticks_one_subdivisions_worth;
2777                 }
2778
2779                 if (when.ticks < difference) {
2780                         --when.beats;
2781                         const double bpb = meter_section_at_beat (bbt_to_beats_locked (_metrics, when)).divisions_per_bar();
2782                         if ((double) when.beats < bpb) {
2783                                 --when.bars;
2784                                 //when.beats = 1;
2785                         }
2786                         when.ticks = BBT_Time::ticks_per_beat - when.ticks;
2787                 } else {
2788                         when.ticks -= difference;
2789                 }
2790
2791         } else {
2792                 /* round to nearest */  double rem;
2793                 if ((rem = fmod ((double) when.ticks, (double) ticks_one_subdivisions_worth)) > (ticks_one_subdivisions_worth / 2.0)) {
2794                         /* closer to the next subdivision, so shift forward */
2795
2796                         when.ticks = when.ticks + (ticks_one_subdivisions_worth - rem);
2797
2798                         if (when.ticks > Timecode::BBT_Time::ticks_per_beat) {
2799                                 ++when.beats;
2800                                 when.ticks -= Timecode::BBT_Time::ticks_per_beat;
2801                         }
2802
2803                 } else if (rem > 0) {
2804                         /* closer to previous subdivision, so shift backward */
2805
2806                         if (rem > when.ticks) {
2807                                 if (when.beats == 0) {
2808                                         /* can't go backwards past zero, so ... */
2809                                 }
2810                                 /* step back to previous beat */
2811                                 --when.beats;
2812                                 when.ticks = Timecode::BBT_Time::ticks_per_beat - rem;
2813                         } else {
2814                                 when.ticks = when.ticks - rem;
2815                         }
2816                 }
2817         }
2818 }
2819
2820 framepos_t
2821 TempoMap::round_to_type (framepos_t frame, RoundMode dir, BBTPointType type)
2822 {
2823         Glib::Threads::RWLock::ReaderLock lm (lock);
2824
2825         const double beat_at_framepos = beat_at_frame_locked (_metrics, frame);
2826         BBT_Time bbt (beats_to_bbt_locked (_metrics, beat_at_framepos));
2827
2828         switch (type) {
2829         case Bar:
2830                 if (dir < 0) {
2831                         /* find bar previous to 'frame' */
2832                         bbt.beats = 1;
2833                         bbt.ticks = 0;
2834                         return frame_time_locked (_metrics, bbt);
2835
2836                 } else if (dir > 0) {
2837                         /* find bar following 'frame' */
2838                         ++bbt.bars;
2839                         bbt.beats = 1;
2840                         bbt.ticks = 0;
2841                         return frame_time_locked (_metrics, bbt);
2842                 } else {
2843                         /* true rounding: find nearest bar */
2844                         framepos_t raw_ft = frame_time_locked (_metrics, bbt);
2845                         bbt.beats = 1;
2846                         bbt.ticks = 0;
2847                         framepos_t prev_ft = frame_time_locked (_metrics, bbt);
2848                         ++bbt.bars;
2849                         framepos_t next_ft = frame_time_locked (_metrics, bbt);
2850
2851                         if ((raw_ft - prev_ft) > (next_ft - prev_ft) / 2) {
2852                                 return next_ft;
2853                         } else {
2854                                 return prev_ft;
2855                         }
2856                 }
2857
2858                 break;
2859
2860         case Beat:
2861                 if (dir < 0) {
2862                         return frame_at_beat_locked (_metrics, floor (beat_at_framepos));
2863                 } else if (dir > 0) {
2864                         return frame_at_beat_locked (_metrics, ceil (beat_at_framepos));
2865                 } else {
2866                         return frame_at_beat_locked (_metrics, floor (beat_at_framepos + 0.5));
2867                 }
2868                 break;
2869         }
2870
2871         return 0;
2872 }
2873
2874 void
2875 TempoMap::get_grid (vector<TempoMap::BBTPoint>& points,
2876                     framepos_t lower, framepos_t upper)
2877 {
2878         Glib::Threads::RWLock::ReaderLock lm (lock);
2879         int32_t cnt = ceil (beat_at_frame_locked (_metrics, lower));
2880         framecnt_t pos = 0;
2881         /* although the map handles negative beats, bbt doesn't. */
2882         if (cnt < 0.0) {
2883                 cnt = 0.0;
2884         }
2885         while (pos < upper) {
2886                 pos = frame_at_beat_locked (_metrics, cnt);
2887                 const TempoSection tempo = tempo_section_at_locked (_metrics, pos);
2888                 const MeterSection meter = meter_section_at_locked (_metrics, pos);
2889                 const BBT_Time bbt = beats_to_bbt (cnt);
2890                 points.push_back (BBTPoint (meter, tempo_at_locked (_metrics, pos), pos, bbt.bars, bbt.beats, tempo.c_func()));
2891                 ++cnt;
2892         }
2893 }
2894
2895 const TempoSection&
2896 TempoMap::tempo_section_at (framepos_t frame) const
2897 {
2898         Glib::Threads::RWLock::ReaderLock lm (lock);
2899         return tempo_section_at_locked (_metrics, frame);
2900 }
2901
2902 const TempoSection&
2903 TempoMap::tempo_section_at_locked (const Metrics& metrics, framepos_t frame) const
2904 {
2905         Metrics::const_iterator i;
2906         TempoSection* prev = 0;
2907
2908         for (i = metrics.begin(); i != metrics.end(); ++i) {
2909                 TempoSection* t;
2910
2911                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2912                         if (!t->active()) {
2913                                 continue;
2914                         }
2915                         if (prev && t->frame() > frame) {
2916                                 break;
2917                         }
2918
2919                         prev = t;
2920                 }
2921         }
2922
2923         if (prev == 0) {
2924                 fatal << endmsg;
2925                 abort(); /*NOTREACHED*/
2926         }
2927
2928         return *prev;
2929 }
2930
2931 const TempoSection&
2932 TempoMap::tempo_section_at_beat_locked (const Metrics& metrics, const double& beat) const
2933 {
2934         TempoSection* prev_t = 0;
2935         const MeterSection* prev_m = &meter_section_at_beat_locked (metrics, beat);
2936
2937         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
2938                 TempoSection* t;
2939                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2940                         if (prev_t && ((t->pulse() - prev_m->pulse()) * prev_m->note_divisor()) + prev_m->beat() > beat) {
2941                                 break;
2942                         }
2943                         prev_t = t;
2944                 }
2945
2946         }
2947         return *prev_t;
2948 }
2949
2950 const TempoSection&
2951 TempoMap::tempo_section_at_pulse_locked (const Metrics& metrics, const double& pulse) const
2952 {
2953         TempoSection* prev_t = 0;
2954
2955         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
2956                 TempoSection* t;
2957                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2958                         if (prev_t && t->pulse() > pulse) {
2959                                 break;
2960                         }
2961                         prev_t = t;
2962                 }
2963
2964         }
2965         return *prev_t;
2966 }
2967
2968 /* don't use this to calculate length (the tempo is only correct for this frame).
2969    do that stuff based on the beat_at_frame and frame_at_beat api
2970 */
2971 double
2972 TempoMap::frames_per_beat_at (const framepos_t& frame, const framecnt_t& sr) const
2973 {
2974         Glib::Threads::RWLock::ReaderLock lm (lock);
2975
2976         const TempoSection* ts_at = &tempo_section_at_locked (_metrics, frame);
2977         const TempoSection* ts_after = 0;
2978         Metrics::const_iterator i;
2979
2980         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
2981                 TempoSection* t;
2982
2983                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
2984                         if (!t->active()) {
2985                                 continue;
2986                         }
2987                         if ((*i)->frame() > frame) {
2988                                 ts_after = t;
2989                                 break;
2990                         }
2991                 }
2992         }
2993
2994         if (ts_after) {
2995                 return  (60.0 * _frame_rate) / (ts_at->tempo_at_frame (frame, _frame_rate));
2996         }
2997         /* must be treated as constant tempo */
2998         return ts_at->frames_per_beat (_frame_rate);
2999 }
3000
3001 const Tempo
3002 TempoMap::tempo_at_locked (const Metrics& metrics, const framepos_t& frame) const
3003 {
3004         TempoSection* prev_t = 0;
3005
3006         Metrics::const_iterator i;
3007
3008         for (i = _metrics.begin(); i != _metrics.end(); ++i) {
3009                 TempoSection* t;
3010                 if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
3011                         if (!t->active()) {
3012                                 continue;
3013                         }
3014                         if ((prev_t) && t->frame() > frame) {
3015                                 /* t is the section past frame */
3016                                 const double ret_bpm = prev_t->tempo_at_frame (frame, _frame_rate) * prev_t->note_type();
3017                                 const Tempo ret_tempo (ret_bpm, prev_t->note_type());
3018                                 return ret_tempo;
3019                         }
3020                         prev_t = t;
3021                 }
3022         }
3023
3024         const double ret = prev_t->beats_per_minute();
3025         const Tempo ret_tempo (ret, prev_t->note_type ());
3026
3027         return ret_tempo;
3028 }
3029
3030 const Tempo
3031 TempoMap::tempo_at (const framepos_t& frame) const
3032 {
3033         Glib::Threads::RWLock::ReaderLock lm (lock);
3034         return tempo_at_locked (_metrics, frame);
3035 }
3036
3037 const MeterSection&
3038 TempoMap::meter_section_at_locked (const Metrics& metrics, framepos_t frame) const
3039 {
3040         Metrics::const_iterator i;
3041         MeterSection* prev = 0;
3042
3043         for (i = metrics.begin(); i != metrics.end(); ++i) {
3044                 MeterSection* m;
3045
3046                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
3047
3048                         if (prev && (*i)->frame() > frame) {
3049                                 break;
3050                         }
3051
3052                         prev = m;
3053                 }
3054         }
3055
3056         if (prev == 0) {
3057                 fatal << endmsg;
3058                 abort(); /*NOTREACHED*/
3059         }
3060
3061         return *prev;
3062 }
3063
3064
3065 const MeterSection&
3066 TempoMap::meter_section_at (framepos_t frame) const
3067 {
3068         Glib::Threads::RWLock::ReaderLock lm (lock);
3069         return meter_section_at_locked (_metrics, frame);
3070 }
3071
3072 const MeterSection&
3073 TempoMap::meter_section_at_beat_locked (const Metrics& metrics, const double& beat) const
3074 {
3075         MeterSection* prev_m = 0;
3076
3077         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
3078                 MeterSection* m;
3079                 if ((m = dynamic_cast<MeterSection*> (*i)) != 0) {
3080                         if (prev_m && m->beat() > beat) {
3081                                 break;
3082                         }
3083                         prev_m = m;
3084                 }
3085
3086         }
3087         return *prev_m;
3088 }
3089
3090 const MeterSection&
3091 TempoMap::meter_section_at_beat (double beat) const
3092 {
3093         Glib::Threads::RWLock::ReaderLock lm (lock);
3094         return meter_section_at_beat_locked (_metrics, beat);
3095 }
3096
3097 const Meter&
3098 TempoMap::meter_at (framepos_t frame) const
3099 {
3100         TempoMetric m (metric_at (frame));
3101         return m.meter();
3102 }
3103
3104 void
3105 TempoMap::fix_legacy_session ()
3106 {
3107         MeterSection* prev_m = 0;
3108         TempoSection* prev_t = 0;
3109
3110         for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3111                 MeterSection* m;
3112                 TempoSection* t;
3113
3114                 if ((m = dynamic_cast<MeterSection*>(*i)) != 0) {
3115                         if (!m->movable()) {
3116                                 pair<double, BBT_Time> bbt = make_pair (0.0, BBT_Time (1, 1, 0));
3117                                 m->set_beat (bbt);
3118                                 m->set_pulse (0.0);
3119                                 m->set_frame (0);
3120                                 m->set_position_lock_style (AudioTime);
3121                                 prev_m = m;
3122                                 continue;
3123                         }
3124                         if (prev_m) {
3125                                 pair<double, BBT_Time> start = make_pair (((m->bbt().bars - 1) * prev_m->note_divisor())
3126                                                                           + (m->bbt().beats - 1)
3127                                                                           + (m->bbt().ticks / BBT_Time::ticks_per_beat)
3128                                                                           , m->bbt());
3129                                 m->set_beat (start);
3130                                 const double start_beat = ((m->bbt().bars - 1) * prev_m->note_divisor())
3131                                         + (m->bbt().beats - 1)
3132                                         + (m->bbt().ticks / BBT_Time::ticks_per_beat);
3133                                 m->set_pulse (start_beat / prev_m->note_divisor());
3134                         }
3135                         prev_m = m;
3136                 } else if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
3137
3138                         if (!t->active()) {
3139                                 continue;
3140                         }
3141
3142                         if (!t->movable()) {
3143                                 t->set_pulse (0.0);
3144                                 t->set_frame (0);
3145                                 t->set_position_lock_style (AudioTime);
3146                                 prev_t = t;
3147                                 continue;
3148                         }
3149
3150                         if (prev_t) {
3151                                 const double beat = ((t->legacy_bbt().bars - 1) * ((prev_m) ? prev_m->note_divisor() : 4.0))
3152                                         + (t->legacy_bbt().beats - 1)
3153                                         + (t->legacy_bbt().ticks / BBT_Time::ticks_per_beat);
3154                                 if (prev_m) {
3155                                         t->set_pulse (beat / prev_m->note_divisor());
3156                                 } else {
3157                                         /* really shouldn't happen but.. */
3158                                         t->set_pulse (beat / 4.0);
3159                                 }
3160                         }
3161                         prev_t = t;
3162                 }
3163         }
3164 }
3165
3166 XMLNode&
3167 TempoMap::get_state ()
3168 {
3169         Metrics::const_iterator i;
3170         XMLNode *root = new XMLNode ("TempoMap");
3171
3172         {
3173                 Glib::Threads::RWLock::ReaderLock lm (lock);
3174                 for (i = _metrics.begin(); i != _metrics.end(); ++i) {
3175                         root->add_child_nocopy ((*i)->get_state());
3176                 }
3177         }
3178
3179         return *root;
3180 }
3181
3182 int
3183 TempoMap::set_state (const XMLNode& node, int /*version*/)
3184 {
3185         {
3186                 Glib::Threads::RWLock::WriterLock lm (lock);
3187
3188                 XMLNodeList nlist;
3189                 XMLNodeConstIterator niter;
3190                 Metrics old_metrics (_metrics);
3191                 _metrics.clear();
3192
3193                 nlist = node.children();
3194
3195                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
3196                         XMLNode* child = *niter;
3197
3198                         if (child->name() == TempoSection::xml_state_node_name) {
3199
3200                                 try {
3201                                         TempoSection* ts = new TempoSection (*child);
3202                                         _metrics.push_back (ts);
3203                                 }
3204
3205                                 catch (failed_constructor& err){
3206                                         error << _("Tempo map: could not set new state, restoring old one.") << endmsg;
3207                                         _metrics = old_metrics;
3208                                         break;
3209                                 }
3210
3211                         } else if (child->name() == MeterSection::xml_state_node_name) {
3212
3213                                 try {
3214                                         MeterSection* ms = new MeterSection (*child);
3215                                         _metrics.push_back (ms);
3216                                 }
3217
3218                                 catch (failed_constructor& err) {
3219                                         error << _("Tempo map: could not set new state, restoring old one.") << endmsg;
3220                                         _metrics = old_metrics;
3221                                         break;
3222                                 }
3223                         }
3224                 }
3225
3226                 if (niter == nlist.end()) {
3227                         MetricSectionSorter cmp;
3228                         _metrics.sort (cmp);
3229                 }
3230
3231                 /* check for legacy sessions where bbt was the base musical unit for tempo */
3232                 for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3233                         TempoSection* t;
3234                         if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
3235                                 if (t->legacy_bbt().bars != 0) {
3236                                         fix_legacy_session();
3237                                         break;
3238                                 }
3239                                 break;
3240                         }
3241                 }
3242
3243                 /* check for multiple tempo/meters at the same location, which
3244                    ardour2 somehow allowed.
3245                 */
3246
3247                 Metrics::iterator prev = _metrics.end();
3248                 for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3249                         if (prev != _metrics.end()) {
3250                                 MeterSection* ms;
3251                                 MeterSection* prev_m;
3252                                 TempoSection* ts;
3253                                 TempoSection* prev_t;
3254                                 if ((prev_m = dynamic_cast<MeterSection*>(*prev)) != 0 && (ms = dynamic_cast<MeterSection*>(*i)) != 0) {
3255                                         if (prev_m->pulse() == ms->pulse()) {
3256                                                 cerr << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg;
3257                                                 error << string_compose (_("Multiple meter definitions found at %1"), prev_m->pulse()) << endmsg;
3258                                                 return -1;
3259                                         }
3260                                 } else if ((prev_t = dynamic_cast<TempoSection*>(*prev)) != 0 && (ts = dynamic_cast<TempoSection*>(*i)) != 0) {
3261                                         if (prev_t->pulse() == ts->pulse()) {
3262                                                 cerr << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg;
3263                                                 error << string_compose (_("Multiple tempo definitions found at %1"), prev_t->pulse()) << endmsg;
3264                                                 return -1;
3265                                         }
3266                                 }
3267                         }
3268                         prev = i;
3269                 }
3270
3271                 recompute_map (_metrics);
3272         }
3273
3274         PropertyChanged (PropertyChange ());
3275
3276         return 0;
3277 }
3278
3279 void
3280 TempoMap::dump (const Metrics& metrics, std::ostream& o) const
3281 {
3282         Glib::Threads::RWLock::ReaderLock lm (lock, Glib::Threads::TRY_LOCK);
3283         const MeterSection* m;
3284         const TempoSection* t;
3285         const TempoSection* prev_t = 0;
3286
3287         for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) {
3288
3289                 if ((t = dynamic_cast<const TempoSection*>(*i)) != 0) {
3290                         o << "Tempo @ " << *i << t->beats_per_minute() << " BPM (pulse = 1/" << t->note_type() << ") at " << t->pulse() << " frame= " << t->frame() << " (movable? "
3291                           << t->movable() << ')' << " pos lock: " << enum_2_string (t->position_lock_style()) << std::endl;
3292                         o << "current      : " << t->beats_per_minute() << " | " << t->pulse() << " | " << t->frame() << std::endl;
3293                         if (prev_t) {
3294                                 o << "previous     : " << prev_t->beats_per_minute() << " | " << prev_t->pulse() << " | " << prev_t->frame() << std::endl;
3295                                 o << "calculated   : " << prev_t->tempo_at_pulse (t->pulse()) *  prev_t->note_type() << " | " << prev_t->pulse_at_tempo (t->pulses_per_minute(), t->frame(), _frame_rate) <<  " | " << prev_t->frame_at_tempo (t->pulses_per_minute(), t->pulse(), _frame_rate) << std::endl;
3296                         }
3297                         prev_t = t;
3298                 } else if ((m = dynamic_cast<const MeterSection*>(*i)) != 0) {
3299                         o << "Meter @ " << *i << ' ' << m->divisions_per_bar() << '/' << m->note_divisor() << " at " << m->bbt() << " frame= " << m->frame()
3300                           << " pulse: " << m->pulse() <<  " beat : " << m->beat() << " pos lock: " << enum_2_string (m->position_lock_style()) << " (movable? " << m->movable() << ')' << endl;
3301                 }
3302         }
3303         o << "------" << std::endl;
3304 }
3305
3306 int
3307 TempoMap::n_tempos() const
3308 {
3309         Glib::Threads::RWLock::ReaderLock lm (lock);
3310         int cnt = 0;
3311
3312         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3313                 if (dynamic_cast<const TempoSection*>(*i) != 0) {
3314                         cnt++;
3315                 }
3316         }
3317
3318         return cnt;
3319 }
3320
3321 int
3322 TempoMap::n_meters() const
3323 {
3324         Glib::Threads::RWLock::ReaderLock lm (lock);
3325         int cnt = 0;
3326
3327         for (Metrics::const_iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3328                 if (dynamic_cast<const MeterSection*>(*i) != 0) {
3329                         cnt++;
3330                 }
3331         }
3332
3333         return cnt;
3334 }
3335
3336 void
3337 TempoMap::insert_time (framepos_t where, framecnt_t amount)
3338 {
3339         {
3340                 Glib::Threads::RWLock::WriterLock lm (lock);
3341                 for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3342                         if ((*i)->frame() >= where && (*i)->movable ()) {
3343                                 (*i)->set_frame ((*i)->frame() + amount);
3344                         }
3345                 }
3346
3347                 /* now reset the BBT time of all metrics, based on their new
3348                  * audio time. This is the only place where we do this reverse
3349                  * timestamp.
3350                  */
3351
3352                 Metrics::iterator i;
3353                 const MeterSection* meter;
3354                 const TempoSection* tempo;
3355                 MeterSection *m;
3356                 TempoSection *t;
3357
3358                 meter = &first_meter ();
3359                 tempo = &first_tempo ();
3360
3361                 BBT_Time start;
3362                 BBT_Time end;
3363
3364                 // cerr << "\n###################### TIMESTAMP via AUDIO ##############\n" << endl;
3365
3366                 bool first = true;
3367                 MetricSection* prev = 0;
3368
3369                 for (i = _metrics.begin(); i != _metrics.end(); ++i) {
3370
3371                         BBT_Time bbt;
3372                         //TempoMetric metric (*meter, *tempo);
3373                         MeterSection* ms = const_cast<MeterSection*>(meter);
3374                         TempoSection* ts = const_cast<TempoSection*>(tempo);
3375                         if (prev) {
3376                                 if (ts){
3377                                         if ((t = dynamic_cast<TempoSection*>(prev)) != 0) {
3378                                                 if (!t->active()) {
3379                                                         continue;
3380                                                 }
3381                                                 ts->set_pulse (t->pulse());
3382                                         }
3383                                         if ((m = dynamic_cast<MeterSection*>(prev)) != 0) {
3384                                                 ts->set_pulse (m->pulse());
3385                                         }
3386                                         ts->set_frame (prev->frame());
3387
3388                                 }
3389                                 if (ms) {
3390                                         if ((m = dynamic_cast<MeterSection*>(prev)) != 0) {
3391                                                 pair<double, BBT_Time> start = make_pair (m->beat(), m->bbt());
3392                                                 ms->set_beat (start);
3393                                                 ms->set_pulse (m->pulse());
3394                                         }
3395                                         if ((t = dynamic_cast<TempoSection*>(prev)) != 0) {
3396                                                 if (!t->active()) {
3397                                                         continue;
3398                                                 }
3399                                                 const double beat = beat_at_pulse_locked (_metrics, t->pulse());
3400                                                 pair<double, BBT_Time> start = make_pair (beat, beats_to_bbt_locked (_metrics, beat));
3401                                                 ms->set_beat (start);
3402                                                 ms->set_pulse (t->pulse());
3403                                         }
3404                                         ms->set_frame (prev->frame());
3405                                 }
3406
3407                         } else {
3408                                 // metric will be at frames=0 bbt=1|1|0 by default
3409                                 // which is correct for our purpose
3410                         }
3411
3412                         // cerr << bbt << endl;
3413
3414                         if ((t = dynamic_cast<TempoSection*>(*i)) != 0) {
3415                                 if (!t->active()) {
3416                                         continue;
3417                                 }
3418                                 t->set_pulse (pulse_at_frame_locked (_metrics, m->frame()));
3419                                 tempo = t;
3420                                 // cerr << "NEW TEMPO, frame = " << (*i)->frame() << " beat = " << (*i)->pulse() <<endl;
3421                         } else if ((m = dynamic_cast<MeterSection*>(*i)) != 0) {
3422                                 bbt_time (m->frame(), bbt);
3423
3424                                 // cerr << "timestamp @ " << (*i)->frame() << " with " << bbt.bars << "|" << bbt.beats << "|" << bbt.ticks << " => ";
3425
3426                                 if (first) {
3427                                         first = false;
3428                                 } else {
3429
3430                                         if (bbt.ticks > BBT_Time::ticks_per_beat/2) {
3431                                                 /* round up to next beat */
3432                                                 bbt.beats += 1;
3433                                         }
3434
3435                                         bbt.ticks = 0;
3436
3437                                         if (bbt.beats != 1) {
3438                                                 /* round up to next bar */
3439                                                 bbt.bars += 1;
3440                                                 bbt.beats = 1;
3441                                         }
3442                                 }
3443                                 pair<double, BBT_Time> start = make_pair (beat_at_frame_locked (_metrics, m->frame()), bbt);
3444                                 m->set_beat (start);
3445                                 m->set_pulse (pulse_at_frame_locked (_metrics, m->frame()));
3446                                 meter = m;
3447                                 // cerr << "NEW METER, frame = " << (*i)->frame() << " beat = " << (*i)->pulse() <<endl;
3448                         } else {
3449                                 fatal << _("programming error: unhandled MetricSection type") << endmsg;
3450                                 abort(); /*NOTREACHED*/
3451                         }
3452
3453                         prev = (*i);
3454                 }
3455
3456                 recompute_map (_metrics);
3457         }
3458
3459
3460         PropertyChanged (PropertyChange ());
3461 }
3462 bool
3463 TempoMap::remove_time (framepos_t where, framecnt_t amount)
3464 {
3465         bool moved = false;
3466
3467         std::list<MetricSection*> metric_kill_list;
3468
3469         TempoSection* last_tempo = NULL;
3470         MeterSection* last_meter = NULL;
3471         bool tempo_after = false; // is there a tempo marker at the first sample after the removed range?
3472         bool meter_after = false; // is there a meter marker likewise?
3473         {
3474                 Glib::Threads::RWLock::WriterLock lm (lock);
3475                 for (Metrics::iterator i = _metrics.begin(); i != _metrics.end(); ++i) {
3476                         if ((*i)->frame() >= where && (*i)->frame() < where+amount) {
3477                                 metric_kill_list.push_back(*i);
3478                                 TempoSection *lt = dynamic_cast<TempoSection*> (*i);
3479                                 if (lt)
3480                                         last_tempo = lt;
3481                                 MeterSection *lm = dynamic_cast<MeterSection*> (*i);
3482                                 if (lm)
3483                                         last_meter = lm;
3484                         }
3485                         else if ((*i)->frame() >= where) {
3486                                 // TODO: make sure that moved tempo/meter markers are rounded to beat/bar boundaries
3487                                 (*i)->set_frame ((*i)->frame() - amount);
3488                                 if ((*i)->frame() == where) {
3489                                         // marker was immediately after end of range
3490                                         tempo_after = dynamic_cast<TempoSection*> (*i);
3491                                         meter_after = dynamic_cast<MeterSection*> (*i);
3492                                 }
3493                                 moved = true;
3494                         }
3495                 }
3496
3497                 //find the last TEMPO and METER metric (if any) and move it to the cut point so future stuff is correct
3498                 if (last_tempo && !tempo_after) {
3499                         metric_kill_list.remove(last_tempo);
3500                         last_tempo->set_frame(where);
3501                         moved = true;
3502                 }
3503                 if (last_meter && !meter_after) {
3504                         metric_kill_list.remove(last_meter);
3505                         last_meter->set_frame(where);
3506                         moved = true;
3507                 }
3508
3509                 //remove all the remaining metrics
3510                 for (std::list<MetricSection*>::iterator i = metric_kill_list.begin(); i != metric_kill_list.end(); ++i) {
3511                         _metrics.remove(*i);
3512                         moved = true;
3513                 }
3514
3515                 if (moved) {
3516                         recompute_map (_metrics);
3517                 }
3518         }
3519         PropertyChanged (PropertyChange ());
3520         return moved;
3521 }
3522
3523 /** Add some (fractional) beats to a session frame position, and return the result in frames.
3524  *  pos can be -ve, if required.
3525  */
3526 framepos_t
3527 TempoMap::framepos_plus_beats (framepos_t pos, Evoral::Beats beats) const
3528 {
3529         return frame_at_beat (beat_at_frame (pos) + beats.to_double());
3530 }
3531
3532 /** Subtract some (fractional) beats from a frame position, and return the result in frames */
3533 framepos_t
3534 TempoMap::framepos_minus_beats (framepos_t pos, Evoral::Beats beats) const
3535 {
3536         return frame_at_beat (beat_at_frame (pos) - beats.to_double());
3537 }
3538
3539 /** Add the BBT interval op to pos and return the result */
3540 framepos_t
3541 TempoMap::framepos_plus_bbt (framepos_t pos, BBT_Time op) const
3542 {
3543         Glib::Threads::RWLock::ReaderLock lm (lock);
3544
3545         BBT_Time pos_bbt = beats_to_bbt_locked (_metrics, beat_at_frame_locked (_metrics, pos));
3546         pos_bbt.ticks += op.ticks;
3547         if (pos_bbt.ticks >= BBT_Time::ticks_per_beat) {
3548                 ++pos_bbt.beats;
3549                 pos_bbt.ticks -= BBT_Time::ticks_per_beat;
3550         }
3551         pos_bbt.beats += op.beats;
3552         /* the meter in effect will start on the bar */
3553         double divisions_per_bar = meter_section_at_beat (bbt_to_beats_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
3554         while (pos_bbt.beats >= divisions_per_bar + 1) {
3555                 ++pos_bbt.bars;
3556                 divisions_per_bar = meter_section_at_beat (bbt_to_beats_locked (_metrics, BBT_Time (pos_bbt.bars + op.bars, 1, 0))).divisions_per_bar();
3557                 pos_bbt.beats -= divisions_per_bar;
3558         }
3559         pos_bbt.bars += op.bars;
3560
3561         return frame_time_locked (_metrics, pos_bbt);
3562 }
3563
3564 /** Count the number of beats that are equivalent to distance when going forward,
3565     starting at pos.
3566 */
3567 Evoral::Beats
3568 TempoMap::framewalk_to_beats (framepos_t pos, framecnt_t distance) const
3569 {
3570         return Evoral::Beats (beat_at_frame (pos + distance) - beat_at_frame (pos));
3571 }
3572
3573 struct bbtcmp {
3574     bool operator() (const BBT_Time& a, const BBT_Time& b) {
3575             return a < b;
3576     }
3577 };
3578
3579 std::ostream&
3580 operator<< (std::ostream& o, const Meter& m) {
3581         return o << m.divisions_per_bar() << '/' << m.note_divisor();
3582 }
3583
3584 std::ostream&
3585 operator<< (std::ostream& o, const Tempo& t) {
3586         return o << t.beats_per_minute() << " 1/" << t.note_type() << "'s per minute";
3587 }
3588
3589 std::ostream&
3590 operator<< (std::ostream& o, const MetricSection& section) {
3591
3592         o << "MetricSection @ " << section.frame() << ' ';
3593
3594         const TempoSection* ts;
3595         const MeterSection* ms;
3596
3597         if ((ts = dynamic_cast<const TempoSection*> (&section)) != 0) {
3598                 o << *((const Tempo*) ts);
3599         } else if ((ms = dynamic_cast<const MeterSection*> (&section)) != 0) {
3600                 o << *((const Meter*) ms);
3601         }
3602
3603         return o;
3604 }