libs/ardour/location.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <algorithm>
  21 #include <set>
  22 #include <cstdio> /* for sprintf */
  23 #include <unistd.h>
  24 #include <cerrno>
  25 #include <ctime>
  26 #include <list>
  27
  28 #include "pbd/convert.h"
  29 #include "pbd/stl_delete.h"
  30 #include "pbd/xml++.h"
  31 #include "pbd/enumwriter.h"
  32
  33 #include "ardour/location.h"
  34 #include "ardour/midi_scene_change.h"
  35 #include "ardour/session.h"
  36 #include "ardour/audiofilesource.h"
  37 #include "ardour/tempo.h"
  38
  39 #include "i18n.h"
  40
  41 using namespace std;
  42 using namespace ARDOUR;
  43 using namespace PBD;
  44
  45 PBD::Signal0<void> Location::scene_changed;
  46 PBD::Signal1<void,Location*> Location::name_changed;
  47 PBD::Signal1<void,Location*> Location::end_changed;
  48 PBD::Signal1<void,Location*> Location::start_changed;
  49 PBD::Signal1<void,Location*> Location::flags_changed;
  50 PBD::Signal1<void,Location*> Location::lock_changed;
  51 PBD::Signal1<void,Location*> Location::position_lock_style_changed;
  52 PBD::Signal1<void,Location*> Location::changed;
  53
  54 Location::Location (Session& s)
  55         : SessionHandleRef (s)
  56         , _start (0)
  57         , _end (0)
  58         , _flags (Flags (0))
  59         , _locked (false)
  60         , _position_lock_style (AudioTime)
  61 {
  62         assert (_start >= 0);
  63         assert (_end >= 0);
  64 }
  65
  66 /** Construct a new Location, giving it the position lock style determined by glue-new-markers-to-bars-and-beats */
  67 Location::Location (Session& s, framepos_t sample_start, framepos_t sample_end, const std::string &name, Flags bits)
  68         : SessionHandleRef (s)
  69         , _name (name)
  70         , _start (sample_start)
  71         , _end (sample_end)
  72         , _flags (bits)
  73         , _locked (false)
  74         , _position_lock_style (s.config.get_glue_new_markers_to_bars_and_beats() ? MusicTime : AudioTime)
  75
  76 {
  77         recompute_bbt_from_frames ();
  78
  79         assert (_start >= 0);
  80         assert (_end >= 0);
  81 }
  82
  83 Location::Location (const Location& other)
  84         : SessionHandleRef (other._session)
  85         , StatefulDestructible()
  86         , _name (other._name)
  87         , _start (other._start)
  88         , _bbt_start (other._bbt_start)
  89         , _end (other._end)
  90         , _bbt_end (other._bbt_end)
  91         , _flags (other._flags)
  92         , _position_lock_style (other._position_lock_style)
  93
  94 {
  95         /* copy is not locked even if original was */
  96
  97         _locked = false;
  98
  99         assert (_start >= 0);
 100         assert (_end >= 0);
 101
 102         /* scene change is NOT COPIED */
 103 }
 104
 105 Location::Location (Session& s, const XMLNode& node)
 106         : SessionHandleRef (s)
 107         , _position_lock_style (AudioTime)
 108 {
 109         /* Note: _position_lock_style is initialised above in case set_state doesn't set it
 110            (for 2.X session file compatibility).
 111         */
 112
 113         if (set_state (node, Stateful::loading_state_version)) {
 114                 throw failed_constructor ();
 115         }
 116
 117         assert (_start >= 0);
 118         assert (_end >= 0);
 119 }
 120
 121 bool
 122 Location::operator== (const Location& other)
 123 {
 124         if (_name != other._name ||
 125             _start != other._start ||
 126             _end != other._end ||
 127             _bbt_start != other._bbt_start ||
 128             _bbt_end != other._bbt_end ||
 129             _flags != other._flags ||
 130             _position_lock_style != other._position_lock_style) {
 131                 return false;
 132         }
 133         return true;
 134 }
 135
 136 Location*
 137 Location::operator= (const Location& other)
 138 {
 139         if (this == &other) {
 140                 return this;
 141         }
 142
 143         _name = other._name;
 144         _start = other._start;
 145         _bbt_start = other._bbt_start;
 146         _end = other._end;
 147         _bbt_end = other._bbt_end;
 148         _flags = other._flags;
 149         _position_lock_style = other._position_lock_style;
 150
 151         /* XXX need to copy scene change */
 152
 153         /* copy is not locked even if original was */
 154
 155         _locked = false;
 156
 157         /* "changed" not emitted on purpose */
 158
 159         assert (_start >= 0);
 160         assert (_end >= 0);
 161
 162         return this;
 163 }
 164
 165 /** Set location name
 166  */
 167
 168 void
 169 Location::set_name (const std::string& str)
 170 {
 171         _name = str;
 172
 173         name_changed (this); /* EMIT SIGNAL */
 174         NameChanged  (); /* EMIT SIGNAL */
 175 }
 176
 177 /** Set start position.
 178  *  @param s New start.
 179  *  @param force true to force setting, even if the given new start is after the current end.
 180  *  @param allow_bbt_recompute True to recompute BBT start time from the new given start time.
 181  */
 182 int
 183 Location::set_start (framepos_t s, bool force, bool allow_bbt_recompute)
 184 {
 185         if (s < 0) {
 186                 return -1;
 187         }
 188
 189         if (_locked) {
 190                 return -1;
 191         }
 192
 193         if (!force) {
 194                 if (((is_auto_punch() || is_auto_loop()) && s >= _end) || (!is_mark() && s > _end)) {
 195                         return -1;
 196                 }
 197         }
 198
 199         if (is_mark()) {
 200                 if (_start != s) {
 201                         _start = s;
 202                         _end = s;
 203                         if (allow_bbt_recompute) {
 204                                 recompute_bbt_from_frames ();
 205                         }
 206
 207                         start_changed (this); /* EMIT SIGNAL */
 208                         StartChanged (); /* EMIT SIGNAL */
 209                         end_changed (this); /* EMIT SIGNAL */
 210                         EndChanged (); /* EMIT SIGNAL */
 211                 }
 212
 213                 /* moving the start (position) of a marker with a scene change
 214                    requires an update in the Scene Changer.
 215                 */
 216
 217                 if (_scene_change) {
 218                         scene_changed (); /* EMIT SIGNAL */
 219                 }
 220
 221                 assert (_start >= 0);
 222                 assert (_end >= 0);
 223
 224                 return 0;
 225         } else if (!force) {
 226                 /* range locations must exceed a minimum duration */
 227                 if (_end - s < Config->get_range_location_minimum()) {
 228                         return -1;
 229                 }
 230         }
 231
 232         if (s != _start) {
 233
 234                 framepos_t const old = _start;
 235
 236                 _start = s;
 237                 if (allow_bbt_recompute) {
 238                         recompute_bbt_from_frames ();
 239                 }
 240                 start_changed (this); /* EMIT SIGNAL */
 241                 StartChanged (); /* EMIT SIGNAL */
 242
 243                 if (is_session_range ()) {
 244                         Session::StartTimeChanged (old); /* EMIT SIGNAL */
 245                         AudioFileSource::set_header_position_offset (s);
 246                 }
 247         }
 248
 249         assert (_start >= 0);
 250
 251         return 0;
 252 }
 253
 254 /** Set end position.
 255  *  @param s New end.
 256  *  @param force true to force setting, even if the given new end is before the current start.
 257  *  @param allow_bbt_recompute True to recompute BBT end time from the new given end time.
 258  */
 259 int
 260 Location::set_end (framepos_t e, bool force, bool allow_bbt_recompute)
 261 {
 262         if (e < 0) {
 263                 return -1;
 264         }
 265
 266         if (_locked) {
 267                 return -1;
 268         }
 269
 270         if (!force) {
 271                 if (((is_auto_punch() || is_auto_loop()) && e <= _start) || e < _start) {
 272                         return -1;
 273                 }
 274         }
 275
 276         if (is_mark()) {
 277                 if (_start != e) {
 278                         _start = e;
 279                         _end = e;
 280                         if (allow_bbt_recompute) {
 281                                 recompute_bbt_from_frames ();
 282                         }
 283                         start_changed (this); /* EMIT SIGNAL */
 284                         StartChanged (); /* EMIT SIGNAL */
 285                         end_changed (this); /* EMIT SIGNAL */
 286                         EndChanged (); /* EMIT SIGNAL */
 287                 }
 288
 289                 assert (_start >= 0);
 290                 assert (_end >= 0);
 291
 292                 return 0;
 293         } else if (!force) {
 294                 /* range locations must exceed a minimum duration */
 295                 if (e - _start < Config->get_range_location_minimum()) {
 296                         return -1;
 297                 }
 298         }
 299
 300         if (e != _end) {
 301
 302                 framepos_t const old = _end;
 303
 304                 _end = e;
 305                 if (allow_bbt_recompute) {
 306                         recompute_bbt_from_frames ();
 307                 }
 308
 309                 end_changed(this); /* EMIT SIGNAL */
 310                 EndChanged(); /* EMIT SIGNAL */
 311
 312                 if (is_session_range()) {
 313                         Session::EndTimeChanged (old); /* EMIT SIGNAL */
 314                 }
 315         }
 316
 317         assert (_end >= 0);
 318
 319         return 0;
 320 }
 321
 322 int
 323 Location::set (framepos_t s, framepos_t e, bool allow_bbt_recompute)
 324 {
 325         if (s < 0 || e < 0) {
 326                 return -1;
 327         }
 328
 329         /* check validity */
 330         if (((is_auto_punch() || is_auto_loop()) && s >= e) || (!is_mark() && s > e)) {
 331                 return -1;
 332         }
 333
 334         bool start_change = false;
 335         bool end_change = false;
 336
 337         if (is_mark()) {
 338
 339                 if (_start != s) {
 340                         _start = s;
 341                         _end = s;
 342
 343                         if (allow_bbt_recompute) {
 344                                 recompute_bbt_from_frames ();
 345                         }
 346
 347                         start_change = true;
 348                         end_change = true;
 349                 }
 350
 351                 assert (_start >= 0);
 352                 assert (_end >= 0);
 353
 354         } else {
 355
 356                 /* range locations must exceed a minimum duration */
 357                 if (e - s < Config->get_range_location_minimum()) {
 358                         return -1;
 359                 }
 360
 361                 if (s != _start) {
 362
 363                         framepos_t const old = _start;
 364                         _start = s;
 365
 366                         if (allow_bbt_recompute) {
 367                                 recompute_bbt_from_frames ();
 368                         }
 369
 370                         start_change = true;
 371
 372                         if (is_session_range ()) {
 373                                 Session::StartTimeChanged (old); /* EMIT SIGNAL */
 374                                 AudioFileSource::set_header_position_offset (s);
 375                         }
 376                 }
 377
 378
 379                 if (e != _end) {
 380
 381                         framepos_t const old = _end;
 382                         _end = e;
 383
 384                         if (allow_bbt_recompute) {
 385                                 recompute_bbt_from_frames ();
 386                         }
 387
 388                         end_change = true;
 389
 390                         if (is_session_range()) {
 391                                 Session::EndTimeChanged (old); /* EMIT SIGNAL */
 392                         }
 393                 }
 394
 395                 assert (_end >= 0);
 396         }
 397
 398         if (start_change) {
 399                 start_changed(this); /* EMIT SIGNAL */
 400                 StartChanged(); /* EMIT SIGNAL */
 401         }
 402
 403         if (end_change) {
 404                 end_changed(this); /* EMIT SIGNAL */
 405                 EndChanged(); /* EMIT SIGNAL */
 406         }
 407
 408         if (start_change && end_change) {
 409                 changed (this);
 410                 Changed ();
 411         }
 412
 413         return 0;
 414 }
 415
 416 int
 417 Location::move_to (framepos_t pos)
 418 {
 419         if (pos < 0) {
 420                 return -1;
 421         }
 422
 423         if (_locked) {
 424                 return -1;
 425         }
 426
 427         if (_start != pos) {
 428                 _start = pos;
 429                 _end = _start + length();
 430                 recompute_bbt_from_frames ();
 431
 432                 changed (this); /* EMIT SIGNAL */
 433                 Changed (); /* EMIT SIGNAL */
 434         }
 435
 436         assert (_start >= 0);
 437         assert (_end >= 0);
 438
 439         return 0;
 440 }
 441
 442 void
 443 Location::set_hidden (bool yn, void*)
 444 {
 445         if (set_flag_internal (yn, IsHidden)) {
 446                 flags_changed (this); /* EMIT SIGNAL */
 447                 FlagsChanged ();
 448         }
 449 }
 450
 451 void
 452 Location::set_cd (bool yn, void*)
 453 {
 454         // XXX this really needs to be session start
 455         // but its not available here - leave to GUI
 456
 457         if (yn && _start == 0) {
 458                 error << _("You cannot put a CD marker at this position") << endmsg;
 459                 return;
 460         }
 461
 462         if (set_flag_internal (yn, IsCDMarker)) {
 463                 flags_changed (this); /* EMIT SIGNAL */
 464                 FlagsChanged ();
 465         }
 466 }
 467
 468 void
 469 Location::set_is_range_marker (bool yn, void*)
 470 {
 471         if (set_flag_internal (yn, IsRangeMarker)) {
 472                 flags_changed (this);
 473                 FlagsChanged (); /* EMIT SIGNAL */
 474         }
 475 }
 476
 477 void
 478 Location::set_skip (bool yn)
 479 {
 480         if (is_range_marker() && length() > 0) {
 481                 if (set_flag_internal (yn, IsSkip)) {
 482                         flags_changed (this);
 483                         FlagsChanged ();
 484                 }
 485         }
 486 }
 487
 488 void
 489 Location::set_skipping (bool yn)
 490 {
 491         if (is_range_marker() && is_skip() && length() > 0) {
 492                 if (set_flag_internal (yn, IsSkipping)) {
 493                         flags_changed (this);
 494                         FlagsChanged ();
 495                 }
 496         }
 497 }
 498
 499 void
 500 Location::set_auto_punch (bool yn, void*)
 501 {
 502         if (is_mark() || _start == _end) {
 503                 return;
 504         }
 505
 506         if (set_flag_internal (yn, IsAutoPunch)) {
 507                 flags_changed (this); /* EMIT SIGNAL */
 508                 FlagsChanged (); /* EMIT SIGNAL */
 509         }
 510 }
 511
 512 void
 513 Location::set_auto_loop (bool yn, void*)
 514 {
 515         if (is_mark() || _start == _end) {
 516                 return;
 517         }
 518
 519         if (set_flag_internal (yn, IsAutoLoop)) {
 520                 flags_changed (this); /* EMIT SIGNAL */
 521                 FlagsChanged (); /* EMIT SIGNAL */
 522         }
 523 }
 524
 525 bool
 526 Location::set_flag_internal (bool yn, Flags flag)
 527 {
 528         if (yn) {
 529                 if (!(_flags & flag)) {
 530                         _flags = Flags (_flags | flag);
 531                         return true;
 532                 }
 533         } else {
 534                 if (_flags & flag) {
 535                         _flags = Flags (_flags & ~flag);
 536                         return true;
 537                 }
 538         }
 539         return false;
 540 }
 541
 542 void
 543 Location::set_mark (bool yn)
 544 {
 545         /* This function is private, and so does not emit signals */
 546
 547         if (_start != _end) {
 548                 return;
 549         }
 550
 551         set_flag_internal (yn, IsMark);
 552 }
 553
 554
 555 XMLNode&
 556 Location::cd_info_node(const string & name, const string & value)
 557 {
 558         XMLNode* root = new XMLNode("CD-Info");
 559
 560         root->add_property("name", name);
 561         root->add_property("value", value);
 562
 563         return *root;
 564 }
 565
 566
 567 XMLNode&
 568 Location::get_state ()
 569 {
 570         XMLNode *node = new XMLNode ("Location");
 571         char buf[64];
 572
 573         typedef map<string, string>::const_iterator CI;
 574
 575         for(CI m = cd_info.begin(); m != cd_info.end(); ++m){
 576                 node->add_child_nocopy(cd_info_node(m->first, m->second));
 577         }
 578
 579         id().print (buf, sizeof (buf));
 580         node->add_property("id", buf);
 581         node->add_property ("name", name());
 582         snprintf (buf, sizeof (buf), "%" PRId64, start());
 583         node->add_property ("start", buf);
 584         snprintf (buf, sizeof (buf), "%" PRId64, end());
 585         node->add_property ("end", buf);
 586         node->add_property ("flags", enum_2_string (_flags));
 587         node->add_property ("locked", (_locked ? "yes" : "no"));
 588         node->add_property ("position-lock-style", enum_2_string (_position_lock_style));
 589
 590         if (_scene_change) {
 591                 node->add_child_nocopy (_scene_change->get_state());
 592         }
 593
 594         return *node;
 595 }
 596
 597 int
 598 Location::set_state (const XMLNode& node, int version)
 599 {
 600         const XMLProperty *prop;
 601
 602         XMLNodeList cd_list = node.children();
 603         XMLNodeConstIterator cd_iter;
 604         XMLNode *cd_node;
 605
 606         string cd_name;
 607         string cd_value;
 608
 609         if (node.name() != "Location") {
 610                 error << _("incorrect XML node passed to Location::set_state") << endmsg;
 611                 return -1;
 612         }
 613
 614         if (!set_id (node)) {
 615                 warning << _("XML node for Location has no ID information") << endmsg;
 616         }
 617
 618         if ((prop = node.property ("name")) == 0) {
 619                 error << _("XML node for Location has no name information") << endmsg;
 620                 return -1;
 621         }
 622
 623         set_name (prop->value());
 624
 625         if ((prop = node.property ("start")) == 0) {
 626                 error << _("XML node for Location has no start information") << endmsg;
 627                 return -1;
 628         }
 629
 630         /* can't use set_start() here, because _end
 631            may make the value of _start illegal.
 632         */
 633
 634         sscanf (prop->value().c_str(), "%" PRId64, &_start);
 635
 636         if ((prop = node.property ("end")) == 0) {
 637                 error << _("XML node for Location has no end information") << endmsg;
 638                 return -1;
 639         }
 640
 641         sscanf (prop->value().c_str(), "%" PRId64, &_end);
 642
 643         if ((prop = node.property ("flags")) == 0) {
 644                 error << _("XML node for Location has no flags information") << endmsg;
 645                 return -1;
 646         }
 647
 648         Flags old_flags (_flags);
 649         _flags = Flags (string_2_enum (prop->value(), _flags));
 650
 651         if (old_flags != _flags) {
 652                 FlagsChanged ();
 653         }
 654
 655         if ((prop = node.property ("locked")) != 0) {
 656                 _locked = string_is_affirmative (prop->value());
 657         } else {
 658                 _locked = false;
 659         }
 660
 661         for (cd_iter = cd_list.begin(); cd_iter != cd_list.end(); ++cd_iter) {
 662
 663                 cd_node = *cd_iter;
 664
 665                 if (cd_node->name() != "CD-Info") {
 666                         continue;
 667                 }
 668
 669                 if ((prop = cd_node->property ("name")) != 0) {
 670                         cd_name = prop->value();
 671                 } else {
 672                         throw failed_constructor ();
 673                 }
 674
 675                 if ((prop = cd_node->property ("value")) != 0) {
 676                         cd_value = prop->value();
 677                 } else {
 678                         throw failed_constructor ();
 679                 }
 680
 681
 682                 cd_info[cd_name] = cd_value;
 683         }
 684
 685         if ((prop = node.property ("position-lock-style")) != 0) {
 686                 _position_lock_style = PositionLockStyle (string_2_enum (prop->value(), _position_lock_style));
 687         }
 688
 689         XMLNode* scene_child = find_named_node (node, SceneChange::xml_node_name);
 690
 691         if (scene_child) {
 692                 _scene_change = SceneChange::factory (*scene_child, version);
 693         }
 694
 695         recompute_bbt_from_frames ();
 696
 697         changed (this); /* EMIT SIGNAL */
 698         Changed (); /* EMIT SIGNAL */
 699
 700         assert (_start >= 0);
 701         assert (_end >= 0);
 702
 703         return 0;
 704 }
 705
 706 void
 707 Location::set_position_lock_style (PositionLockStyle ps)
 708 {
 709         if (_position_lock_style == ps) {
 710                 return;
 711         }
 712
 713         _position_lock_style = ps;
 714
 715         recompute_bbt_from_frames ();
 716
 717         position_lock_style_changed (this); /* EMIT SIGNAL */
 718         PositionLockStyleChanged (); /* EMIT SIGNAL */
 719 }
 720
 721 void
 722 Location::recompute_bbt_from_frames ()
 723 {
 724         if (_position_lock_style != MusicTime) {
 725                 return;
 726         }
 727
 728         _session.bbt_time (_start, _bbt_start);
 729         _session.bbt_time (_end, _bbt_end);
 730 }
 731
 732 void
 733 Location::recompute_frames_from_bbt ()
 734 {
 735         if (_position_lock_style != MusicTime) {
 736                 return;
 737         }
 738
 739         TempoMap& map (_session.tempo_map());
 740         set (map.frame_time (_bbt_start), map.frame_time (_bbt_end), false);
 741 }
 742
 743 void
 744 Location::lock ()
 745 {
 746         _locked = true;
 747         lock_changed (this);
 748         LockChanged ();
 749 }
 750
 751 void
 752 Location::unlock ()
 753 {
 754         _locked = false;
 755         lock_changed (this);
 756         LockChanged ();
 757 }
 758
 759 void
 760 Location::set_scene_change (boost::shared_ptr<SceneChange>  sc)
 761 {
 762         _scene_change = sc;
 763
 764         scene_changed (); /* EMIT SIGNAL */
 765 }
 766
 767 /*---------------------------------------------------------------------- */
 768
 769 Locations::Locations (Session& s)
 770         : SessionHandleRef (s)
 771 {
 772         current_location = 0;
 773 }
 774
 775 Locations::~Locations ()
 776 {
 777         for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 778                 LocationList::iterator tmp = i;
 779                 ++tmp;
 780                 delete *i;
 781                 i = tmp;
 782         }
 783 }
 784
 785 int
 786 Locations::set_current (Location *loc, bool want_lock)
 787 {
 788         int ret;
 789
 790         if (want_lock) {
 791                 Glib::Threads::Mutex::Lock lm (lock);
 792                 ret = set_current_unlocked (loc);
 793         } else {
 794                 ret = set_current_unlocked (loc);
 795         }
 796
 797         if (ret == 0) {
 798                 current_changed (current_location); /* EMIT SIGNAL */
 799         }
 800         return ret;
 801 }
 802
 803 int
 804 Locations::next_available_name(string& result,string base)
 805 {
 806         LocationList::iterator i;
 807         string::size_type l;
 808         int suffix;
 809         char buf[32];
 810         std::map<uint32_t,bool> taken;
 811         uint32_t n;
 812
 813         result = base;
 814         l = base.length();
 815
 816         if (!base.empty()) {
 817
 818                 /* find all existing names that match "base", and store
 819                    the numeric part of them (if any) in the map "taken"
 820                 */
 821
 822                 for (i = locations.begin(); i != locations.end(); ++i) {
 823
 824                         const string& temp ((*i)->name());
 825
 826                         if (!temp.find (base,0)) {
 827                                 /* grab what comes after the "base" as if it was
 828                                    a number, and assuming that works OK,
 829                                    store it in "taken" so that we know it
 830                                    has been used.
 831                                 */
 832                                 if ((suffix = atoi (temp.substr(l))) != 0) {
 833                                         taken.insert (make_pair (suffix,true));
 834                                 }
 835                         }
 836                 }
 837         }
 838
 839         /* Now search for an un-used suffix to add to "base". This
 840            will find "holes" in the numbering sequence when a location
 841            was deleted.
 842
 843            This must start at 1, both for human-numbering reasons
 844            and also because the call to atoi() above would return
 845            zero if there is no recognizable numeric suffix, causing
 846            "base 0" not to be inserted into the "taken" map.
 847         */
 848
 849         n = 1;
 850
 851         while (n < UINT32_MAX) {
 852                 if (taken.find (n) == taken.end()) {
 853                         snprintf (buf, sizeof(buf), "%d", n);
 854                         result += buf;
 855                         return 1;
 856                 }
 857                 ++n;
 858         }
 859
 860         return 0;
 861 }
 862
 863 int
 864 Locations::set_current_unlocked (Location *loc)
 865 {
 866         if (find (locations.begin(), locations.end(), loc) == locations.end()) {
 867                 error << _("Locations: attempt to use unknown location as selected location") << endmsg;
 868                 return -1;
 869         }
 870
 871         current_location = loc;
 872         return 0;
 873 }
 874
 875 void
 876 Locations::clear ()
 877 {
 878         {
 879                 Glib::Threads::Mutex::Lock lm (lock);
 880
 881                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 882
 883                         LocationList::iterator tmp = i;
 884                         ++tmp;
 885
 886                         if (!(*i)->is_session_range()) {
 887                                 delete *i;
 888                                 locations.erase (i);
 889                         }
 890
 891                         i = tmp;
 892                 }
 893
 894                 current_location = 0;
 895         }
 896
 897         changed (); /* EMIT SIGNAL */
 898         current_changed (0); /* EMIT SIGNAL */
 899 }
 900
 901 void
 902 Locations::clear_markers ()
 903 {
 904         {
 905                 Glib::Threads::Mutex::Lock lm (lock);
 906                 LocationList::iterator tmp;
 907
 908                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 909                         tmp = i;
 910                         ++tmp;
 911
 912                         if ((*i)->is_mark() && !(*i)->is_session_range()) {
 913                                 delete *i;
 914                                 locations.erase (i);
 915                         }
 916
 917                         i = tmp;
 918                 }
 919         }
 920
 921         changed (); /* EMIT SIGNAL */
 922 }
 923
 924 void
 925 Locations::clear_ranges ()
 926 {
 927         {
 928                 Glib::Threads::Mutex::Lock lm (lock);
 929                 LocationList::iterator tmp;
 930
 931                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 932
 933                         tmp = i;
 934                         ++tmp;
 935
 936                         /* We do not remove these ranges as part of this
 937                          * operation
 938                          */
 939
 940                         if ((*i)->is_auto_punch() ||
 941                             (*i)->is_auto_loop() ||
 942                             (*i)->is_session_range()) {
 943                                 i = tmp;
 944                                 continue;
 945                         }
 946
 947                         if (!(*i)->is_mark()) {
 948                                 delete *i;
 949                                 locations.erase (i);
 950
 951                         }
 952
 953                         i = tmp;
 954                 }
 955
 956                 current_location = 0;
 957         }
 958
 959         changed ();
 960         current_changed (0); /* EMIT SIGNAL */
 961 }
 962
 963 void
 964 Locations::add (Location *loc, bool make_current)
 965 {
 966         assert (loc);
 967
 968         {
 969                 Glib::Threads::Mutex::Lock lm (lock);
 970                 locations.push_back (loc);
 971
 972                 if (make_current) {
 973                         current_location = loc;
 974                 }
 975         }
 976
 977         added (loc); /* EMIT SIGNAL */
 978
 979         if (make_current) {
 980                 current_changed (current_location); /* EMIT SIGNAL */
 981         }
 982
 983         if (loc->is_session_range()) {
 984                 Session::StartTimeChanged (0);
 985                 Session::EndTimeChanged (1);
 986         }
 987 }
 988
 989 void
 990 Locations::remove (Location *loc)
 991 {
 992         bool was_removed = false;
 993         bool was_current = false;
 994         LocationList::iterator i;
 995
 996         if (loc->is_session_range()) {
 997                 return;
 998         }
 999
1000         {
1001                 Glib::Threads::Mutex::Lock lm (lock);
1002
1003                 for (i = locations.begin(); i != locations.end(); ++i) {
1004                         if ((*i) == loc) {
1005                                 delete *i;
1006                                 locations.erase (i);
1007                                 was_removed = true;
1008                                 if (current_location == loc) {
1009                                         current_location = 0;
1010                                         was_current = true;
1011                                 }
1012                                 break;
1013                         }
1014                 }
1015         }
1016
1017         if (was_removed) {
1018
1019                 removed (loc); /* EMIT SIGNAL */
1020
1021                 if (was_current) {
1022                         current_changed (0); /* EMIT SIGNAL */
1023                 }
1024         }
1025 }
1026
1027 XMLNode&
1028 Locations::get_state ()
1029 {
1030         XMLNode *node = new XMLNode ("Locations");
1031         LocationList::iterator iter;
1032         Glib::Threads::Mutex::Lock lm (lock);
1033
1034         for (iter = locations.begin(); iter != locations.end(); ++iter) {
1035                 node->add_child_nocopy ((*iter)->get_state ());
1036         }
1037
1038         return *node;
1039 }
1040
1041 int
1042 Locations::set_state (const XMLNode& node, int version)
1043 {
1044         if (node.name() != "Locations") {
1045                 error << _("incorrect XML mode passed to Locations::set_state") << endmsg;
1046                 return -1;
1047         }
1048
1049         XMLNodeList nlist = node.children();
1050
1051         /* build up a new locations list in here */
1052         LocationList new_locations;
1053
1054         current_location = 0;
1055
1056         Location* session_range_location = 0;
1057         if (version < 3000) {
1058                 session_range_location = new Location (_session, 0, 0, _("session"), Location::IsSessionRange);
1059                 new_locations.push_back (session_range_location);
1060         }
1061
1062         {
1063                 Glib::Threads::Mutex::Lock lm (lock);
1064
1065                 XMLNodeConstIterator niter;
1066                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1067
1068                         try {
1069
1070                                 XMLProperty const * prop_id = (*niter)->property ("id");
1071                                 assert (prop_id);
1072                                 PBD::ID id (prop_id->value ());
1073
1074                                 LocationList::const_iterator i = locations.begin();
1075                                 while (i != locations.end () && (*i)->id() != id) {
1076                                         ++i;
1077                                 }
1078
1079                                 Location* loc;
1080                                 if (i != locations.end()) {
1081                                         /* we can re-use an old Location object */
1082                                         loc = *i;
1083
1084                                         // changed locations will be updated by Locations::changed signal
1085                                         loc->set_state (**niter, version);
1086                                 } else {
1087                                         loc = new Location (_session, **niter);
1088                                 }
1089
1090                                 bool add = true;
1091
1092                                 if (version < 3000) {
1093                                         /* look for old-style IsStart / IsEnd properties in this location;
1094                                            if they are present, update the session_range_location accordingly
1095                                         */
1096                                         XMLProperty const * prop = (*niter)->property ("flags");
1097                                         if (prop) {
1098                                                 string v = prop->value ();
1099                                                 while (1) {
1100                                                         string::size_type const c = v.find_first_of (',');
1101                                                         string const s = v.substr (0, c);
1102                                                         if (s == X_("IsStart")) {
1103                                                                 session_range_location->set_start (loc->start(), true);
1104                                                                 add = false;
1105                                                         } else if (s == X_("IsEnd")) {
1106                                                                 session_range_location->set_end (loc->start(), true);
1107                                                                 add = false;
1108                                                         }
1109
1110                                                         if (c == string::npos) {
1111                                                                 break;
1112                                                         }
1113
1114                                                         v = v.substr (c + 1);
1115                                                 }
1116                                         }
1117                                 }
1118
1119                                 if (add) {
1120                                         new_locations.push_back (loc);
1121                                 }
1122                         }
1123
1124                         catch (failed_constructor& err) {
1125                                 error << _("could not load location from session file - ignored") << endmsg;
1126                         }
1127                 }
1128
1129                 /* We may have some unused locations in the old list. */
1130                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
1131                         LocationList::iterator tmp = i;
1132                         ++tmp;
1133
1134                         LocationList::iterator n = new_locations.begin();
1135                         bool found = false;
1136
1137                         while (n != new_locations.end ()) {
1138                                 if ((*i)->id() == (*n)->id()) {
1139                                         found = true;
1140                                         break;
1141                                 }
1142                                 ++n;
1143                         }
1144
1145                         if (!found) {
1146                                 delete *i;
1147                                 locations.erase (i);
1148                         }
1149
1150                         i = tmp;
1151                 }
1152
1153                 locations = new_locations;
1154
1155                 if (locations.size()) {
1156                         current_location = locations.front();
1157                 } else {
1158                         current_location = 0;
1159                 }
1160         }
1161
1162         changed (); /* EMIT SIGNAL */
1163
1164         return 0;
1165 }
1166
1167
1168 typedef std::pair<framepos_t,Location*> LocationPair;
1169
1170 struct LocationStartEarlierComparison
1171 {
1172         bool operator() (LocationPair a, LocationPair b) {
1173                 return a.first < b.first;
1174         }
1175 };
1176
1177 struct LocationStartLaterComparison
1178 {
1179         bool operator() (LocationPair a, LocationPair b) {
1180                 return a.first > b.first;
1181         }
1182 };
1183
1184 framepos_t
1185 Locations::first_mark_before (framepos_t frame, bool include_special_ranges)
1186 {
1187         Glib::Threads::Mutex::Lock lm (lock);
1188         vector<LocationPair> locs;
1189
1190         for (LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
1191                 locs.push_back (make_pair ((*i)->start(), (*i)));
1192                 if (!(*i)->is_mark()) {
1193                         locs.push_back (make_pair ((*i)->end(), (*i)));
1194                 }
1195         }
1196
1197         LocationStartLaterComparison cmp;
1198         sort (locs.begin(), locs.end(), cmp);
1199
1200         /* locs is sorted in ascending order */
1201
1202         for (vector<LocationPair>::iterator i = locs.begin(); i != locs.end(); ++i) {
1203                 if ((*i).second->is_hidden()) {
1204                         continue;
1205                 }
1206                 if (!include_special_ranges && ((*i).second->is_auto_loop() || (*i).second->is_auto_punch())) {
1207                         continue;
1208                 }
1209                 if ((*i).first < frame) {
1210                         return (*i).first;
1211                 }
1212         }
1213
1214         return -1;
1215 }
1216
1217 Location*
1218 Locations::mark_at (framepos_t pos, framecnt_t slop) const
1219 {
1220         Glib::Threads::Mutex::Lock lm (lock);
1221         Location* closest = 0;
1222         frameoffset_t mindelta = max_framepos;
1223         frameoffset_t delta;
1224
1225         /* locations are not necessarily stored in linear time order so we have
1226          * to iterate across all of them to find the one closest to a give point.
1227          */
1228
1229         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1230
1231                 if ((*i)->is_mark()) {
1232                         if (pos > (*i)->start()) {
1233                                 delta = pos - (*i)->start();
1234                         } else {
1235                                 delta = (*i)->start() - pos;
1236                         }
1237
1238                         if (slop == 0 && delta == 0) {
1239                                 /* special case: no slop, and direct hit for position */
1240                                 return *i;
1241                         }
1242
1243                         if (delta <= slop) {
1244                                 if (delta < mindelta) {
1245                                         closest = *i;
1246                                         mindelta = delta;
1247                                 }
1248                         }
1249                 }
1250         }
1251
1252         return closest;
1253 }
1254
1255 framepos_t
1256 Locations::first_mark_after (framepos_t frame, bool include_special_ranges)
1257 {
1258         Glib::Threads::Mutex::Lock lm (lock);
1259         vector<LocationPair> locs;
1260
1261         for (LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
1262                 locs.push_back (make_pair ((*i)->start(), (*i)));
1263                 if (!(*i)->is_mark()) {
1264                         locs.push_back (make_pair ((*i)->end(), (*i)));
1265                 }
1266         }
1267
1268         LocationStartEarlierComparison cmp;
1269         sort (locs.begin(), locs.end(), cmp);
1270
1271         /* locs is sorted in reverse order */
1272
1273         for (vector<LocationPair>::iterator i = locs.begin(); i != locs.end(); ++i) {
1274                 if ((*i).second->is_hidden()) {
1275                         continue;
1276                 }
1277                 if (!include_special_ranges && ((*i).second->is_auto_loop() || (*i).second->is_auto_punch())) {
1278                         continue;
1279                 }
1280                 if ((*i).first > frame) {
1281                         return (*i).first;
1282                 }
1283         }
1284
1285         return -1;
1286 }
1287
1288 /** Look for the `marks' (either locations which are marks, or start/end points of range markers) either
1289  *  side of a frame.  Note that if frame is exactly on a `mark', that mark will not be considered for returning
1290  *  as before/after.
1291  *  @param frame Frame to look for.
1292  *  @param before Filled in with the position of the last `mark' before `frame' (or max_framepos if none exists)
1293  *  @param after Filled in with the position of the next `mark' after `frame' (or max_framepos if none exists)
1294  */
1295 void
1296 Locations::marks_either_side (framepos_t const frame, framepos_t& before, framepos_t& after) const
1297 {
1298         before = after = max_framepos;
1299
1300         LocationList locs;
1301
1302         {
1303                 Glib::Threads::Mutex::Lock lm (lock);
1304                 locs = locations;
1305         }
1306
1307         /* Get a list of positions; don't store any that are exactly on our requested position */
1308
1309         std::list<framepos_t> positions;
1310
1311         for (LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1312                 if (((*i)->is_auto_loop() || (*i)->is_auto_punch())) {
1313                         continue;
1314                 }
1315
1316                 if (!(*i)->is_hidden()) {
1317                         if ((*i)->is_mark ()) {
1318                                 if ((*i)->start() != frame) {
1319                                         positions.push_back ((*i)->start ());
1320                                 }
1321                         } else {
1322                                 if ((*i)->start() != frame) {
1323                                         positions.push_back ((*i)->start ());
1324                                 }
1325                                 if ((*i)->end() != frame) {
1326                                         positions.push_back ((*i)->end ());
1327                                 }
1328                         }
1329                 }
1330         }
1331
1332         if (positions.empty ()) {
1333                 return;
1334         }
1335
1336         positions.sort ();
1337
1338         std::list<framepos_t>::iterator i = positions.begin ();
1339         while (i != positions.end () && *i < frame) {
1340                 ++i;
1341         }
1342
1343         if (i == positions.end ()) {
1344                 /* run out of marks */
1345                 before = positions.back ();
1346                 return;
1347         }
1348
1349         after = *i;
1350
1351         if (i == positions.begin ()) {
1352                 /* none before */
1353                 return;
1354         }
1355
1356         --i;
1357         before = *i;
1358 }
1359
1360 Location*
1361 Locations::session_range_location () const
1362 {
1363         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1364                 if ((*i)->is_session_range()) {
1365                         return const_cast<Location*> (*i);
1366                 }
1367         }
1368         return 0;
1369 }
1370
1371 Location*
1372 Locations::auto_loop_location () const
1373 {
1374         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1375                 if ((*i)->is_auto_loop()) {
1376                         return const_cast<Location*> (*i);
1377                 }
1378         }
1379         return 0;
1380 }
1381
1382 Location*
1383 Locations::auto_punch_location () const
1384 {
1385         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1386                 if ((*i)->is_auto_punch()) {
1387                         return const_cast<Location*> (*i);
1388                 }
1389         }
1390         return 0;
1391 }
1392
1393 uint32_t
1394 Locations::num_range_markers () const
1395 {
1396         uint32_t cnt = 0;
1397         Glib::Threads::Mutex::Lock lm (lock);
1398         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1399                 if ((*i)->is_range_marker()) {
1400                         ++cnt;
1401                 }
1402         }
1403         return cnt;
1404 }
1405
1406 Location *
1407 Locations::get_location_by_id(PBD::ID id)
1408 {
1409         LocationList::iterator it;
1410         for (it  = locations.begin(); it != locations.end(); ++it)
1411                 if (id == (*it)->id())
1412                         return *it;
1413
1414         return 0;
1415 }
1416
1417 void
1418 Locations::find_all_between (framepos_t start, framepos_t end, LocationList& ll, Location::Flags flags)
1419 {
1420         Glib::Threads::Mutex::Lock lm (lock);
1421
1422         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1423                 if ((flags == 0 || (*i)->matches (flags)) &&
1424                     ((*i)->start() >= start && (*i)->end() < end)) {
1425                         ll.push_back (*i);
1426                 }
1427         }
1428 }
1429