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