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         if (_scene_change != sc) {
 763                 _scene_change = sc;
 764
 765                 scene_changed (); /* EMIT SIGNAL */
 766                 SceneChangeChanged (); /* EMIT SIGNAL */
 767         }
 768 }
 769
 770 /*---------------------------------------------------------------------- */
 771
 772 Locations::Locations (Session& s)
 773         : SessionHandleRef (s)
 774 {
 775         current_location = 0;
 776 }
 777
 778 Locations::~Locations ()
 779 {
 780         for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 781                 LocationList::iterator tmp = i;
 782                 ++tmp;
 783                 delete *i;
 784                 i = tmp;
 785         }
 786 }
 787
 788 int
 789 Locations::set_current (Location *loc, bool want_lock)
 790 {
 791         int ret;
 792
 793         if (want_lock) {
 794                 Glib::Threads::Mutex::Lock lm (lock);
 795                 ret = set_current_unlocked (loc);
 796         } else {
 797                 ret = set_current_unlocked (loc);
 798         }
 799
 800         if (ret == 0) {
 801                 current_changed (current_location); /* EMIT SIGNAL */
 802         }
 803         return ret;
 804 }
 805
 806 int
 807 Locations::next_available_name(string& result,string base)
 808 {
 809         LocationList::iterator i;
 810         string::size_type l;
 811         int suffix;
 812         char buf[32];
 813         std::map<uint32_t,bool> taken;
 814         uint32_t n;
 815
 816         result = base;
 817         l = base.length();
 818
 819         if (!base.empty()) {
 820
 821                 /* find all existing names that match "base", and store
 822                    the numeric part of them (if any) in the map "taken"
 823                 */
 824
 825                 for (i = locations.begin(); i != locations.end(); ++i) {
 826
 827                         const string& temp ((*i)->name());
 828
 829                         if (!temp.find (base,0)) {
 830                                 /* grab what comes after the "base" as if it was
 831                                    a number, and assuming that works OK,
 832                                    store it in "taken" so that we know it
 833                                    has been used.
 834                                 */
 835                                 if ((suffix = atoi (temp.substr(l))) != 0) {
 836                                         taken.insert (make_pair (suffix,true));
 837                                 }
 838                         }
 839                 }
 840         }
 841
 842         /* Now search for an un-used suffix to add to "base". This
 843            will find "holes" in the numbering sequence when a location
 844            was deleted.
 845
 846            This must start at 1, both for human-numbering reasons
 847            and also because the call to atoi() above would return
 848            zero if there is no recognizable numeric suffix, causing
 849            "base 0" not to be inserted into the "taken" map.
 850         */
 851
 852         n = 1;
 853
 854         while (n < UINT32_MAX) {
 855                 if (taken.find (n) == taken.end()) {
 856                         snprintf (buf, sizeof(buf), "%d", n);
 857                         result += buf;
 858                         return 1;
 859                 }
 860                 ++n;
 861         }
 862
 863         return 0;
 864 }
 865
 866 int
 867 Locations::set_current_unlocked (Location *loc)
 868 {
 869         if (find (locations.begin(), locations.end(), loc) == locations.end()) {
 870                 error << _("Locations: attempt to use unknown location as selected location") << endmsg;
 871                 return -1;
 872         }
 873
 874         current_location = loc;
 875         return 0;
 876 }
 877
 878 void
 879 Locations::clear ()
 880 {
 881         {
 882                 Glib::Threads::Mutex::Lock lm (lock);
 883
 884                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 885
 886                         LocationList::iterator tmp = i;
 887                         ++tmp;
 888
 889                         if (!(*i)->is_session_range()) {
 890                                 delete *i;
 891                                 locations.erase (i);
 892                         }
 893
 894                         i = tmp;
 895                 }
 896
 897                 current_location = 0;
 898         }
 899
 900         changed (); /* EMIT SIGNAL */
 901         current_changed (0); /* EMIT SIGNAL */
 902 }
 903
 904 void
 905 Locations::clear_markers ()
 906 {
 907         {
 908                 Glib::Threads::Mutex::Lock lm (lock);
 909                 LocationList::iterator tmp;
 910
 911                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 912                         tmp = i;
 913                         ++tmp;
 914
 915                         if ((*i)->is_mark() && !(*i)->is_session_range()) {
 916                                 delete *i;
 917                                 locations.erase (i);
 918                         }
 919
 920                         i = tmp;
 921                 }
 922         }
 923
 924         changed (); /* EMIT SIGNAL */
 925 }
 926
 927 void
 928 Locations::clear_ranges ()
 929 {
 930         {
 931                 Glib::Threads::Mutex::Lock lm (lock);
 932                 LocationList::iterator tmp;
 933
 934                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 935
 936                         tmp = i;
 937                         ++tmp;
 938
 939                         /* We do not remove these ranges as part of this
 940                          * operation
 941                          */
 942
 943                         if ((*i)->is_auto_punch() ||
 944                             (*i)->is_auto_loop() ||
 945                             (*i)->is_session_range()) {
 946                                 i = tmp;
 947                                 continue;
 948                         }
 949
 950                         if (!(*i)->is_mark()) {
 951                                 delete *i;
 952                                 locations.erase (i);
 953
 954                         }
 955
 956                         i = tmp;
 957                 }
 958
 959                 current_location = 0;
 960         }
 961
 962         changed ();
 963         current_changed (0); /* EMIT SIGNAL */
 964 }
 965
 966 void
 967 Locations::add (Location *loc, bool make_current)
 968 {
 969         assert (loc);
 970
 971         {
 972                 Glib::Threads::Mutex::Lock lm (lock);
 973                 locations.push_back (loc);
 974
 975                 if (make_current) {
 976                         current_location = loc;
 977                 }
 978         }
 979
 980         added (loc); /* EMIT SIGNAL */
 981
 982         if (make_current) {
 983                 current_changed (current_location); /* EMIT SIGNAL */
 984         }
 985
 986         if (loc->is_session_range()) {
 987                 Session::StartTimeChanged (0);
 988                 Session::EndTimeChanged (1);
 989         }
 990 }
 991
 992 void
 993 Locations::remove (Location *loc)
 994 {
 995         bool was_removed = false;
 996         bool was_current = false;
 997         LocationList::iterator i;
 998
 999         if (loc->is_session_range()) {
1000                 return;
1001         }
1002
1003         {
1004                 Glib::Threads::Mutex::Lock lm (lock);
1005
1006                 for (i = locations.begin(); i != locations.end(); ++i) {
1007                         if ((*i) == loc) {
1008                                 delete *i;
1009                                 locations.erase (i);
1010                                 was_removed = true;
1011                                 if (current_location == loc) {
1012                                         current_location = 0;
1013                                         was_current = true;
1014                                 }
1015                                 break;
1016                         }
1017                 }
1018         }
1019
1020         if (was_removed) {
1021
1022                 removed (loc); /* EMIT SIGNAL */
1023
1024                 if (was_current) {
1025                         current_changed (0); /* EMIT SIGNAL */
1026                 }
1027         }
1028 }
1029
1030 XMLNode&
1031 Locations::get_state ()
1032 {
1033         XMLNode *node = new XMLNode ("Locations");
1034         LocationList::iterator iter;
1035         Glib::Threads::Mutex::Lock lm (lock);
1036
1037         for (iter = locations.begin(); iter != locations.end(); ++iter) {
1038                 node->add_child_nocopy ((*iter)->get_state ());
1039         }
1040
1041         return *node;
1042 }
1043
1044 int
1045 Locations::set_state (const XMLNode& node, int version)
1046 {
1047         if (node.name() != "Locations") {
1048                 error << _("incorrect XML mode passed to Locations::set_state") << endmsg;
1049                 return -1;
1050         }
1051
1052         XMLNodeList nlist = node.children();
1053
1054         /* build up a new locations list in here */
1055         LocationList new_locations;
1056
1057         current_location = 0;
1058
1059         Location* session_range_location = 0;
1060         if (version < 3000) {
1061                 session_range_location = new Location (_session, 0, 0, _("session"), Location::IsSessionRange);
1062                 new_locations.push_back (session_range_location);
1063         }
1064
1065         {
1066                 Glib::Threads::Mutex::Lock lm (lock);
1067
1068                 XMLNodeConstIterator niter;
1069                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1070
1071                         try {
1072
1073                                 XMLProperty const * prop_id = (*niter)->property ("id");
1074                                 assert (prop_id);
1075                                 PBD::ID id (prop_id->value ());
1076
1077                                 LocationList::const_iterator i = locations.begin();
1078                                 while (i != locations.end () && (*i)->id() != id) {
1079                                         ++i;
1080                                 }
1081
1082                                 Location* loc;
1083                                 if (i != locations.end()) {
1084                                         /* we can re-use an old Location object */
1085                                         loc = *i;
1086
1087                                         // changed locations will be updated by Locations::changed signal
1088                                         loc->set_state (**niter, version);
1089                                 } else {
1090                                         loc = new Location (_session, **niter);
1091                                 }
1092
1093                                 bool add = true;
1094
1095                                 if (version < 3000) {
1096                                         /* look for old-style IsStart / IsEnd properties in this location;
1097                                            if they are present, update the session_range_location accordingly
1098                                         */
1099                                         XMLProperty const * prop = (*niter)->property ("flags");
1100                                         if (prop) {
1101                                                 string v = prop->value ();
1102                                                 while (1) {
1103                                                         string::size_type const c = v.find_first_of (',');
1104                                                         string const s = v.substr (0, c);
1105                                                         if (s == X_("IsStart")) {
1106                                                                 session_range_location->set_start (loc->start(), true);
1107                                                                 add = false;
1108                                                         } else if (s == X_("IsEnd")) {
1109                                                                 session_range_location->set_end (loc->start(), true);
1110                                                                 add = false;
1111                                                         }
1112
1113                                                         if (c == string::npos) {
1114                                                                 break;
1115                                                         }
1116
1117                                                         v = v.substr (c + 1);
1118                                                 }
1119                                         }
1120                                 }
1121
1122                                 if (add) {
1123                                         new_locations.push_back (loc);
1124                                 }
1125                         }
1126
1127                         catch (failed_constructor& err) {
1128                                 error << _("could not load location from session file - ignored") << endmsg;
1129                         }
1130                 }
1131
1132                 /* We may have some unused locations in the old list. */
1133                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
1134                         LocationList::iterator tmp = i;
1135                         ++tmp;
1136
1137                         LocationList::iterator n = new_locations.begin();
1138                         bool found = false;
1139
1140                         while (n != new_locations.end ()) {
1141                                 if ((*i)->id() == (*n)->id()) {
1142                                         found = true;
1143                                         break;
1144                                 }
1145                                 ++n;
1146                         }
1147
1148                         if (!found) {
1149                                 delete *i;
1150                                 locations.erase (i);
1151                         }
1152
1153                         i = tmp;
1154                 }
1155
1156                 locations = new_locations;
1157
1158                 if (locations.size()) {
1159                         current_location = locations.front();
1160                 } else {
1161                         current_location = 0;
1162                 }
1163         }
1164
1165         changed (); /* EMIT SIGNAL */
1166
1167         return 0;
1168 }
1169
1170
1171 typedef std::pair<framepos_t,Location*> LocationPair;
1172
1173 struct LocationStartEarlierComparison
1174 {
1175         bool operator() (LocationPair a, LocationPair b) {
1176                 return a.first < b.first;
1177         }
1178 };
1179
1180 struct LocationStartLaterComparison
1181 {
1182         bool operator() (LocationPair a, LocationPair b) {
1183                 return a.first > b.first;
1184         }
1185 };
1186
1187 framepos_t
1188 Locations::first_mark_before (framepos_t frame, bool include_special_ranges)
1189 {
1190         Glib::Threads::Mutex::Lock lm (lock);
1191         vector<LocationPair> locs;
1192
1193         for (LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
1194                 locs.push_back (make_pair ((*i)->start(), (*i)));
1195                 if (!(*i)->is_mark()) {
1196                         locs.push_back (make_pair ((*i)->end(), (*i)));
1197                 }
1198         }
1199
1200         LocationStartLaterComparison cmp;
1201         sort (locs.begin(), locs.end(), cmp);
1202
1203         /* locs is sorted in ascending order */
1204
1205         for (vector<LocationPair>::iterator i = locs.begin(); i != locs.end(); ++i) {
1206                 if ((*i).second->is_hidden()) {
1207                         continue;
1208                 }
1209                 if (!include_special_ranges && ((*i).second->is_auto_loop() || (*i).second->is_auto_punch())) {
1210                         continue;
1211                 }
1212                 if ((*i).first < frame) {
1213                         return (*i).first;
1214                 }
1215         }
1216
1217         return -1;
1218 }
1219
1220 Location*
1221 Locations::mark_at (framepos_t pos, framecnt_t slop) const
1222 {
1223         Glib::Threads::Mutex::Lock lm (lock);
1224         Location* closest = 0;
1225         frameoffset_t mindelta = max_framepos;
1226         frameoffset_t delta;
1227
1228         /* locations are not necessarily stored in linear time order so we have
1229          * to iterate across all of them to find the one closest to a give point.
1230          */
1231
1232         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1233
1234                 if ((*i)->is_mark()) {
1235                         if (pos > (*i)->start()) {
1236                                 delta = pos - (*i)->start();
1237                         } else {
1238                                 delta = (*i)->start() - pos;
1239                         }
1240
1241                         if (slop == 0 && delta == 0) {
1242                                 /* special case: no slop, and direct hit for position */
1243                                 return *i;
1244                         }
1245
1246                         if (delta <= slop) {
1247                                 if (delta < mindelta) {
1248                                         closest = *i;
1249                                         mindelta = delta;
1250                                 }
1251                         }
1252                 }
1253         }
1254
1255         return closest;
1256 }
1257
1258 framepos_t
1259 Locations::first_mark_after (framepos_t frame, bool include_special_ranges)
1260 {
1261         Glib::Threads::Mutex::Lock lm (lock);
1262         vector<LocationPair> locs;
1263
1264         for (LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
1265                 locs.push_back (make_pair ((*i)->start(), (*i)));
1266                 if (!(*i)->is_mark()) {
1267                         locs.push_back (make_pair ((*i)->end(), (*i)));
1268                 }
1269         }
1270
1271         LocationStartEarlierComparison cmp;
1272         sort (locs.begin(), locs.end(), cmp);
1273
1274         /* locs is sorted in reverse order */
1275
1276         for (vector<LocationPair>::iterator i = locs.begin(); i != locs.end(); ++i) {
1277                 if ((*i).second->is_hidden()) {
1278                         continue;
1279                 }
1280                 if (!include_special_ranges && ((*i).second->is_auto_loop() || (*i).second->is_auto_punch())) {
1281                         continue;
1282                 }
1283                 if ((*i).first > frame) {
1284                         return (*i).first;
1285                 }
1286         }
1287
1288         return -1;
1289 }
1290
1291 /** Look for the `marks' (either locations which are marks, or start/end points of range markers) either
1292  *  side of a frame.  Note that if frame is exactly on a `mark', that mark will not be considered for returning
1293  *  as before/after.
1294  *  @param frame Frame to look for.
1295  *  @param before Filled in with the position of the last `mark' before `frame' (or max_framepos if none exists)
1296  *  @param after Filled in with the position of the next `mark' after `frame' (or max_framepos if none exists)
1297  */
1298 void
1299 Locations::marks_either_side (framepos_t const frame, framepos_t& before, framepos_t& after) const
1300 {
1301         before = after = max_framepos;
1302
1303         LocationList locs;
1304
1305         {
1306                 Glib::Threads::Mutex::Lock lm (lock);
1307                 locs = locations;
1308         }
1309
1310         /* Get a list of positions; don't store any that are exactly on our requested position */
1311
1312         std::list<framepos_t> positions;
1313
1314         for (LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1315                 if (((*i)->is_auto_loop() || (*i)->is_auto_punch())) {
1316                         continue;
1317                 }
1318
1319                 if (!(*i)->is_hidden()) {
1320                         if ((*i)->is_mark ()) {
1321                                 if ((*i)->start() != frame) {
1322                                         positions.push_back ((*i)->start ());
1323                                 }
1324                         } else {
1325                                 if ((*i)->start() != frame) {
1326                                         positions.push_back ((*i)->start ());
1327                                 }
1328                                 if ((*i)->end() != frame) {
1329                                         positions.push_back ((*i)->end ());
1330                                 }
1331                         }
1332                 }
1333         }
1334
1335         if (positions.empty ()) {
1336                 return;
1337         }
1338
1339         positions.sort ();
1340
1341         std::list<framepos_t>::iterator i = positions.begin ();
1342         while (i != positions.end () && *i < frame) {
1343                 ++i;
1344         }
1345
1346         if (i == positions.end ()) {
1347                 /* run out of marks */
1348                 before = positions.back ();
1349                 return;
1350         }
1351
1352         after = *i;
1353
1354         if (i == positions.begin ()) {
1355                 /* none before */
1356                 return;
1357         }
1358
1359         --i;
1360         before = *i;
1361 }
1362
1363 Location*
1364 Locations::session_range_location () const
1365 {
1366         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1367                 if ((*i)->is_session_range()) {
1368                         return const_cast<Location*> (*i);
1369                 }
1370         }
1371         return 0;
1372 }
1373
1374 Location*
1375 Locations::auto_loop_location () const
1376 {
1377         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1378                 if ((*i)->is_auto_loop()) {
1379                         return const_cast<Location*> (*i);
1380                 }
1381         }
1382         return 0;
1383 }
1384
1385 Location*
1386 Locations::auto_punch_location () const
1387 {
1388         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1389                 if ((*i)->is_auto_punch()) {
1390                         return const_cast<Location*> (*i);
1391                 }
1392         }
1393         return 0;
1394 }
1395
1396 uint32_t
1397 Locations::num_range_markers () const
1398 {
1399         uint32_t cnt = 0;
1400         Glib::Threads::Mutex::Lock lm (lock);
1401         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1402                 if ((*i)->is_range_marker()) {
1403                         ++cnt;
1404                 }
1405         }
1406         return cnt;
1407 }
1408
1409 Location *
1410 Locations::get_location_by_id(PBD::ID id)
1411 {
1412         LocationList::iterator it;
1413         for (it  = locations.begin(); it != locations.end(); ++it)
1414                 if (id == (*it)->id())
1415                         return *it;
1416
1417         return 0;
1418 }
1419
1420 void
1421 Locations::find_all_between (framepos_t start, framepos_t end, LocationList& ll, Location::Flags flags)
1422 {
1423         Glib::Threads::Mutex::Lock lm (lock);
1424
1425         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1426                 if ((flags == 0 || (*i)->matches (flags)) &&
1427                     ((*i)->start() >= start && (*i)->end() < end)) {
1428                         ll.push_back (*i);
1429                 }
1430         }
1431 }
1432