libs/ardour/playlist.cc

   1 /*
   2     Copyright (C) 2000-2003 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 <stdint.h>
  21 #include <set>
  22 #include <fstream>
  23 #include <algorithm>
  24 #include <unistd.h>
  25 #include <cerrno>
  26 #include <string>
  27 #include <climits>
  28
  29 #include <boost/lexical_cast.hpp>
  30
  31 #include "pbd/failed_constructor.h"
  32 #include "pbd/stateful_diff_command.h"
  33 #include "pbd/xml++.h"
  34 #include "pbd/stacktrace.h"
  35
  36 #include "ardour/debug.h"
  37 #include "ardour/playlist.h"
  38 #include "ardour/session.h"
  39 #include "ardour/region.h"
  40 #include "ardour/region_factory.h"
  41 #include "ardour/playlist_factory.h"
  42 #include "ardour/transient_detector.h"
  43 #include "ardour/session_playlists.h"
  44
  45 #include "i18n.h"
  46
  47 using namespace std;
  48 using namespace ARDOUR;
  49 using namespace PBD;
  50
  51 namespace ARDOUR {
  52 namespace Properties {
  53 PBD::PropertyDescriptor<bool> regions;
  54 }
  55 }
  56
  57 struct ShowMeTheList {
  58     ShowMeTheList (boost::shared_ptr<Playlist> pl, const string& n) : playlist (pl), name (n) {}
  59     ~ShowMeTheList () {
  60             cerr << ">>>>" << name << endl; playlist->dump(); cerr << "<<<<" << name << endl << endl;
  61     };
  62     boost::shared_ptr<Playlist> playlist;
  63     string name;
  64 };
  65
  66 struct RegionSortByLayer {
  67     bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
  68             return a->layer() < b->layer();
  69     }
  70 };
  71
  72 struct RegionSortByLayerWithPending {
  73         bool operator () (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
  74
  75                 double p = a->layer ();
  76                 if (a->pending_explicit_relayer()) {
  77                         p += 0.5;
  78                 }
  79
  80                 double q = b->layer ();
  81                 if (b->pending_explicit_relayer()) {
  82                         q += 0.5;
  83                 }
  84
  85                 return p < q;
  86         }
  87 };
  88
  89 struct RegionSortByPosition {
  90     bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
  91             return a->position() < b->position();
  92     }
  93 };
  94
  95 struct RegionSortByLastLayerOp {
  96     bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
  97             return a->last_layer_op() < b->last_layer_op();
  98     }
  99 };
 100
 101 void
 102 Playlist::make_property_quarks ()
 103 {
 104         Properties::regions.property_id = g_quark_from_static_string (X_("regions"));
 105         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for regions = %1\n",         Properties::regions.property_id));
 106 }
 107
 108 RegionListProperty::RegionListProperty (Playlist& pl)
 109         : SequenceProperty<std::list<boost::shared_ptr<Region> > > (Properties::regions.property_id, boost::bind (&Playlist::update, &pl, _1))
 110         , _playlist (pl)
 111 {
 112
 113 }
 114
 115 RegionListProperty::RegionListProperty (RegionListProperty const & p)
 116         : PBD::SequenceProperty<std::list<boost::shared_ptr<Region> > > (p)
 117         , _playlist (p._playlist)
 118 {
 119
 120 }
 121
 122 RegionListProperty *
 123 RegionListProperty::clone () const
 124 {
 125         return new RegionListProperty (*this);
 126 }
 127
 128 RegionListProperty *
 129 RegionListProperty::create () const
 130 {
 131         return new RegionListProperty (_playlist);
 132 }
 133
 134 void
 135 RegionListProperty::get_content_as_xml (boost::shared_ptr<Region> region, XMLNode & node) const
 136 {
 137         /* All regions (even those which are deleted) have their state saved by other
 138            code, so we can just store ID here.
 139         */
 140
 141         node.add_property ("id", region->id().to_s ());
 142 }
 143
 144 boost::shared_ptr<Region>
 145 RegionListProperty::get_content_from_xml (XMLNode const & node) const
 146 {
 147         XMLProperty const * prop = node.property ("id");
 148         assert (prop);
 149
 150         PBD::ID id (prop->value ());
 151
 152         boost::shared_ptr<Region> ret = _playlist.region_by_id (id);
 153
 154         if (!ret) {
 155                 ret = RegionFactory::region_by_id (id);
 156         }
 157
 158         return ret;
 159 }
 160
 161 Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
 162         : SessionObject(sess, nom)
 163         , regions (*this)
 164         , _type(type)
 165 {
 166         init (hide);
 167         first_set_state = false;
 168         _name = nom;
 169         _set_sort_id ();
 170
 171 }
 172
 173 Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
 174         : SessionObject(sess, "unnamed playlist")
 175         , regions (*this)
 176         , _type(type)
 177
 178 {
 179 #ifndef NDEBUG
 180         const XMLProperty* prop = node.property("type");
 181         assert(!prop || DataType(prop->value()) == _type);
 182 #endif
 183
 184         init (hide);
 185         _name = "unnamed"; /* reset by set_state */
 186         _set_sort_id ();
 187
 188         /* set state called by derived class */
 189 }
 190
 191 Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
 192         : SessionObject(other->_session, namestr)
 193         , regions (*this)
 194         , _type(other->_type)
 195         , _orig_diskstream_id (other->_orig_diskstream_id)
 196 {
 197         init (hide);
 198
 199         RegionList tmp;
 200         other->copy_regions (tmp);
 201
 202         in_set_state++;
 203
 204         for (list<boost::shared_ptr<Region> >::iterator x = tmp.begin(); x != tmp.end(); ++x) {
 205                 add_region_internal( (*x), (*x)->position());
 206         }
 207
 208         in_set_state--;
 209
 210         _splicing  = other->_splicing;
 211         _nudging   = other->_nudging;
 212         _edit_mode = other->_edit_mode;
 213
 214         in_set_state = 0;
 215         first_set_state = false;
 216         in_flush = false;
 217         in_partition = false;
 218         subcnt = 0;
 219         _read_data_count = 0;
 220         _frozen = other->_frozen;
 221
 222         layer_op_counter = other->layer_op_counter;
 223         freeze_length = other->freeze_length;
 224 }
 225
 226 Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, framecnt_t cnt, string str, bool hide)
 227         : SessionObject(other->_session, str)
 228         , regions (*this)
 229         , _type(other->_type)
 230         , _orig_diskstream_id (other->_orig_diskstream_id)
 231 {
 232         RegionLock rlock2 (const_cast<Playlist*> (other.get()));
 233
 234         framepos_t end = start + cnt - 1;
 235
 236         init (hide);
 237
 238         in_set_state++;
 239
 240         for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
 241
 242                 boost::shared_ptr<Region> region;
 243                 boost::shared_ptr<Region> new_region;
 244                 frameoffset_t offset = 0;
 245                 framepos_t position = 0;
 246                 framecnt_t len = 0;
 247                 string    new_name;
 248                 OverlapType overlap;
 249
 250                 region = *i;
 251
 252                 overlap = region->coverage (start, end);
 253
 254                 switch (overlap) {
 255                 case OverlapNone:
 256                         continue;
 257
 258                 case OverlapInternal:
 259                         offset = start - region->position();
 260                         position = 0;
 261                         len = cnt;
 262                         break;
 263
 264                 case OverlapStart:
 265                         offset = 0;
 266                         position = region->position() - start;
 267                         len = end - region->position();
 268                         break;
 269
 270                 case OverlapEnd:
 271                         offset = start - region->position();
 272                         position = 0;
 273                         len = region->length() - offset;
 274                         break;
 275
 276                 case OverlapExternal:
 277                         offset = 0;
 278                         position = region->position() - start;
 279                         len = region->length();
 280                         break;
 281                 }
 282
 283                 RegionFactory::region_name (new_name, region->name(), false);
 284
 285                 PropertyList plist;
 286
 287                 plist.add (Properties::start, region->start() + offset);
 288                 plist.add (Properties::length, len);
 289                 plist.add (Properties::name, new_name);
 290                 plist.add (Properties::layer, region->layer());
 291
 292                 new_region = RegionFactory::RegionFactory::create (region, plist);
 293
 294                 add_region_internal (new_region, position);
 295         }
 296
 297         in_set_state--;
 298         first_set_state = false;
 299
 300         /* this constructor does NOT notify others (session) */
 301 }
 302
 303 void
 304 Playlist::use ()
 305 {
 306         ++_refcnt;
 307         InUse (true); /* EMIT SIGNAL */
 308 }
 309
 310 void
 311 Playlist::release ()
 312 {
 313         if (_refcnt > 0) {
 314                 _refcnt--;
 315         }
 316
 317         if (_refcnt == 0) {
 318                 InUse (false); /* EMIT SIGNAL */
 319         }
 320 }
 321
 322 void
 323 Playlist::copy_regions (RegionList& newlist) const
 324 {
 325         RegionLock rlock (const_cast<Playlist *> (this));
 326
 327         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 328                 newlist.push_back (RegionFactory::RegionFactory::create (*i, true));
 329         }
 330 }
 331
 332 void
 333 Playlist::init (bool hide)
 334 {
 335         add_property (regions);
 336         _xml_node_name = X_("Playlist");
 337
 338         g_atomic_int_set (&block_notifications, 0);
 339         g_atomic_int_set (&ignore_state_changes, 0);
 340         pending_contents_change = false;
 341         pending_length = false;
 342         pending_layering = false;
 343         first_set_state = true;
 344         _refcnt = 0;
 345         _hidden = hide;
 346         _splicing = false;
 347         _shuffling = false;
 348         _nudging = false;
 349         in_set_state = 0;
 350         in_update = false;
 351         _edit_mode = Config->get_edit_mode();
 352         in_flush = false;
 353         in_partition = false;
 354         subcnt = 0;
 355         _read_data_count = 0;
 356         _frozen = false;
 357         layer_op_counter = 0;
 358         freeze_length = 0;
 359         _explicit_relayering = false;
 360
 361         _session.history().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this));
 362         _session.history().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this));
 363
 364         ContentsChanged.connect_same_thread (*this, boost::bind (&Playlist::mark_session_dirty, this));
 365 }
 366
 367 Playlist::~Playlist ()
 368 {
 369         DEBUG_TRACE (DEBUG::Destruction, string_compose ("Playlist %1 destructor\n", _name));
 370
 371         {
 372                 RegionLock rl (this);
 373
 374                 for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
 375                         (*i)->set_playlist (boost::shared_ptr<Playlist>());
 376                 }
 377         }
 378
 379         /* GoingAway must be emitted by derived classes */
 380 }
 381
 382 void
 383 Playlist::_set_sort_id ()
 384 {
 385         /*
 386           Playlists are given names like <track name>.<id>
 387           or <track name>.<edit group name>.<id> where id
 388           is an integer. We extract the id and sort by that.
 389         */
 390
 391         size_t dot_position = _name.val().find_last_of(".");
 392
 393         if (dot_position == string::npos) {
 394                 _sort_id = 0;
 395         } else {
 396                 string t = _name.val().substr(dot_position + 1);
 397
 398                 try {
 399                         _sort_id = boost::lexical_cast<int>(t);
 400                 }
 401
 402                 catch (boost::bad_lexical_cast e) {
 403                         _sort_id = 0;
 404                 }
 405         }
 406 }
 407
 408 bool
 409 Playlist::set_name (const string& str)
 410 {
 411         /* in a typical situation, a playlist is being used
 412            by one diskstream and also is referenced by the
 413            Session. if there are more references than that,
 414            then don't change the name.
 415         */
 416
 417         if (_refcnt > 2) {
 418                 return false;
 419         }
 420
 421         bool ret =  SessionObject::set_name(str);
 422         if (ret) {
 423                 _set_sort_id ();
 424         }
 425         return ret;
 426 }
 427
 428 /***********************************************************************
 429  CHANGE NOTIFICATION HANDLING
 430
 431  Notifications must be delayed till the region_lock is released. This
 432  is necessary because handlers for the signals may need to acquire
 433  the lock (e.g. to read from the playlist).
 434  ***********************************************************************/
 435
 436 void
 437 Playlist::begin_undo ()
 438 {
 439         in_update = true;
 440         freeze ();
 441 }
 442
 443 void
 444 Playlist::end_undo ()
 445 {
 446         thaw (true);
 447         in_update = false;
 448 }
 449
 450 void
 451 Playlist::freeze ()
 452 {
 453         delay_notifications ();
 454         g_atomic_int_inc (&ignore_state_changes);
 455 }
 456
 457 /** @param from_undo true if this thaw is triggered by the end of an undo on this playlist */
 458 void
 459 Playlist::thaw (bool from_undo)
 460 {
 461         g_atomic_int_dec_and_test (&ignore_state_changes);
 462         release_notifications (from_undo);
 463 }
 464
 465
 466 void
 467 Playlist::delay_notifications ()
 468 {
 469         g_atomic_int_inc (&block_notifications);
 470         freeze_length = _get_extent().second;
 471 }
 472
 473 /** @param from_undo true if this release is triggered by the end of an undo on this playlist */
 474 void
 475 Playlist::release_notifications (bool from_undo)
 476 {
 477         if (g_atomic_int_dec_and_test (&block_notifications)) {
 478                 flush_notifications (from_undo);
 479         }
 480
 481 }
 482
 483 void
 484 Playlist::notify_contents_changed ()
 485 {
 486         if (holding_state ()) {
 487                 pending_contents_change = true;
 488         } else {
 489                 pending_contents_change = false;
 490                 ContentsChanged(); /* EMIT SIGNAL */
 491         }
 492 }
 493
 494 void
 495 Playlist::notify_layering_changed ()
 496 {
 497         if (holding_state ()) {
 498                 pending_layering = true;
 499         } else {
 500                 pending_layering = false;
 501                 LayeringChanged(); /* EMIT SIGNAL */
 502         }
 503 }
 504
 505 void
 506 Playlist::notify_region_removed (boost::shared_ptr<Region> r)
 507 {
 508         if (holding_state ()) {
 509                 pending_removes.insert (r);
 510                 pending_contents_change = true;
 511                 pending_length = true;
 512         } else {
 513                 /* this might not be true, but we have to act
 514                    as though it could be.
 515                 */
 516                 pending_length = false;
 517                 LengthChanged (); /* EMIT SIGNAL */
 518                 pending_contents_change = false;
 519                 RegionRemoved (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
 520                 ContentsChanged (); /* EMIT SIGNAL */
 521         }
 522 }
 523
 524 void
 525 Playlist::notify_region_moved (boost::shared_ptr<Region> r)
 526 {
 527         Evoral::RangeMove<framepos_t> const move (r->last_position (), r->length (), r->position ());
 528
 529         if (holding_state ()) {
 530
 531                 pending_range_moves.push_back (move);
 532
 533         } else {
 534
 535                 list< Evoral::RangeMove<framepos_t> > m;
 536                 m.push_back (move);
 537                 RangesMoved (m, false);
 538         }
 539
 540 }
 541
 542 void
 543 Playlist::notify_region_added (boost::shared_ptr<Region> r)
 544 {
 545         /* the length change might not be true, but we have to act
 546            as though it could be.
 547         */
 548
 549         if (holding_state()) {
 550                 pending_adds.insert (r);
 551                 pending_contents_change = true;
 552                 pending_length = true;
 553         } else {
 554                 r->clear_changes ();
 555                 pending_length = false;
 556                 LengthChanged (); /* EMIT SIGNAL */
 557                 pending_contents_change = false;
 558                 RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
 559                 ContentsChanged (); /* EMIT SIGNAL */
 560         }
 561 }
 562
 563 void
 564 Playlist::notify_length_changed ()
 565 {
 566         if (holding_state ()) {
 567                 pending_length = true;
 568         } else {
 569                 pending_length = false;
 570                 LengthChanged(); /* EMIT SIGNAL */
 571                 pending_contents_change = false;
 572                 ContentsChanged (); /* EMIT SIGNAL */
 573         }
 574 }
 575
 576 /** @param from_undo true if this flush is triggered by the end of an undo on this playlist */
 577 void
 578 Playlist::flush_notifications (bool from_undo)
 579 {
 580         set<boost::shared_ptr<Region> > dependent_checks_needed;
 581         set<boost::shared_ptr<Region> >::iterator s;
 582         uint32_t regions_changed = false;
 583         bool check_length = false;
 584         framecnt_t old_length = 0;
 585
 586         if (in_flush) {
 587                 return;
 588         }
 589
 590         in_flush = true;
 591
 592         if (!pending_bounds.empty() || !pending_removes.empty() || !pending_adds.empty()) {
 593                 regions_changed = true;
 594                 if (!pending_length) {
 595                         old_length = _get_extent ().second;
 596                         check_length = true;
 597                 }
 598         }
 599
 600         /* we have no idea what order the regions ended up in pending
 601            bounds (it could be based on selection order, for example).
 602            so, to preserve layering in the "most recently moved is higher"
 603            model, sort them by existing layer, then timestamp them.
 604         */
 605
 606         // RegionSortByLayer cmp;
 607         // pending_bounds.sort (cmp);
 608
 609         for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
 610                 if (_session.config.get_layer_model() == MoveAddHigher) {
 611                         timestamp_layer_op (*r);
 612                 }
 613                 dependent_checks_needed.insert (*r);
 614         }
 615
 616         for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
 617                 remove_dependents (*s);
 618                 // cerr << _name << " sends RegionRemoved\n";
 619                 RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
 620         }
 621
 622         for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
 623                 // cerr << _name << " sends RegionAdded\n";
 624                 /* don't emit RegionAdded signal until relayering is done,
 625                    so that the region is fully setup by the time
 626                    anyone hear's that its been added
 627                 */
 628                 dependent_checks_needed.insert (*s);
 629         }
 630
 631         if (check_length) {
 632                 if (old_length != _get_extent().second) {
 633                         pending_length = true;
 634                         // cerr << _name << " length has changed\n";
 635                 }
 636         }
 637
 638         if (pending_length || (freeze_length != _get_extent().second)) {
 639                 pending_length = false;
 640                 // cerr << _name << " sends LengthChanged\n";
 641                 LengthChanged(); /* EMIT SIGNAL */
 642         }
 643
 644         if (regions_changed || pending_contents_change) {
 645                 if (!in_set_state) {
 646                         relayer ();
 647                 }
 648                 pending_contents_change = false;
 649                 // cerr << _name << " sends 5 contents change @ " << get_microseconds() << endl;
 650                 ContentsChanged (); /* EMIT SIGNAL */
 651                 // cerr << _name << "done contents change @ " << get_microseconds() << endl;
 652         }
 653
 654         for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
 655                 (*s)->clear_changes ();
 656                 RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
 657         }
 658
 659         for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
 660                 check_dependents (*s, false);
 661         }
 662
 663         if (!pending_range_moves.empty ()) {
 664                 RangesMoved (pending_range_moves, from_undo);
 665         }
 666
 667         clear_pending ();
 668
 669         in_flush = false;
 670 }
 671
 672 void
 673 Playlist::clear_pending ()
 674 {
 675         pending_adds.clear ();
 676         pending_removes.clear ();
 677         pending_bounds.clear ();
 678         pending_range_moves.clear ();
 679         pending_contents_change = false;
 680         pending_length = false;
 681 }
 682
 683 /*************************************************************
 684   PLAYLIST OPERATIONS
 685  *************************************************************/
 686
 687 void
 688 Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition)
 689 {
 690         RegionLock rlock (this);
 691         times = fabs (times);
 692
 693         int itimes = (int) floor (times);
 694
 695         framepos_t pos = position;
 696
 697         if (times == 1 && auto_partition){
 698                 partition(pos - 1, (pos + region->length()), true);
 699         }
 700
 701         if (itimes >= 1) {
 702                 add_region_internal (region, pos);
 703                 pos += region->length();
 704                 --itimes;
 705         }
 706
 707
 708         /* note that itimes can be zero if we being asked to just
 709            insert a single fraction of the region.
 710         */
 711
 712         for (int i = 0; i < itimes; ++i) {
 713                 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
 714                 add_region_internal (copy, pos);
 715                 pos += region->length();
 716         }
 717
 718         framecnt_t length = 0;
 719
 720         if (floor (times) != times) {
 721                 length = (framecnt_t) floor (region->length() * (times - floor (times)));
 722                 string name;
 723                 RegionFactory::region_name (name, region->name(), false);
 724
 725                 {
 726                         PropertyList plist;
 727
 728                         plist.add (Properties::start, region->start());
 729                         plist.add (Properties::length, length);
 730                         plist.add (Properties::name, name);
 731                         plist.add (Properties::layer, region->layer());
 732
 733                         boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
 734                         add_region_internal (sub, pos);
 735                 }
 736         }
 737
 738         possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
 739 }
 740
 741 void
 742 Playlist::set_region_ownership ()
 743 {
 744         RegionLock rl (this);
 745         RegionList::iterator i;
 746         boost::weak_ptr<Playlist> pl (shared_from_this());
 747
 748         for (i = regions.begin(); i != regions.end(); ++i) {
 749                 (*i)->set_playlist (pl);
 750         }
 751 }
 752
 753 bool
 754 Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position)
 755 {
 756         if (region->data_type() != _type){
 757                 return false;
 758         }
 759
 760         RegionSortByPosition cmp;
 761
 762         framecnt_t old_length = 0;
 763
 764         if (!holding_state()) {
 765                  old_length = _get_extent().second;
 766         }
 767
 768         if (!first_set_state) {
 769                 boost::shared_ptr<Playlist> foo (shared_from_this());
 770                 region->set_playlist (boost::weak_ptr<Playlist>(foo));
 771         }
 772
 773         region->set_position (position, this);
 774
 775         timestamp_layer_op (region);
 776
 777         regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
 778         all_regions.insert (region);
 779
 780         possibly_splice_unlocked (position, region->length(), region);
 781
 782         if (!holding_state ()) {
 783                 /* layers get assigned from XML state, and are not reset during undo/redo */
 784                 relayer ();
 785         }
 786
 787         /* we need to notify the existence of new region before checking dependents. Ick. */
 788
 789         notify_region_added (region);
 790
 791         if (!holding_state ()) {
 792
 793                 check_dependents (region, false);
 794
 795                 if (old_length != _get_extent().second) {
 796                         notify_length_changed ();
 797                 }
 798         }
 799
 800         region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
 801
 802         return true;
 803 }
 804
 805 void
 806 Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos)
 807 {
 808         RegionLock rlock (this);
 809
 810         bool old_sp = _splicing;
 811         _splicing = true;
 812
 813         remove_region_internal (old);
 814         add_region_internal (newr, pos);
 815
 816         _splicing = old_sp;
 817
 818         possibly_splice_unlocked (pos, old->length() - newr->length());
 819 }
 820
 821 void
 822 Playlist::remove_region (boost::shared_ptr<Region> region)
 823 {
 824         RegionLock rlock (this);
 825         remove_region_internal (region);
 826 }
 827
 828 int
 829 Playlist::remove_region_internal (boost::shared_ptr<Region> region)
 830 {
 831         RegionList::iterator i;
 832         framecnt_t old_length = 0;
 833         int ret = -1;
 834
 835         if (!holding_state()) {
 836                 old_length = _get_extent().second;
 837         }
 838
 839         if (!in_set_state) {
 840                 /* unset playlist */
 841                 region->set_playlist (boost::weak_ptr<Playlist>());
 842         }
 843
 844         /* XXX should probably freeze here .... */
 845
 846         for (i = regions.begin(); i != regions.end(); ++i) {
 847                 if (*i == region) {
 848
 849                         framepos_t pos = (*i)->position();
 850                         framecnt_t distance = (*i)->length();
 851
 852                         regions.erase (i);
 853
 854                         possibly_splice_unlocked (pos, -distance);
 855
 856                         if (!holding_state ()) {
 857                                 relayer ();
 858                                 remove_dependents (region);
 859
 860                                 if (old_length != _get_extent().second) {
 861                                         notify_length_changed ();
 862                                 }
 863                         }
 864
 865                         notify_region_removed (region);
 866                         ret = 0;
 867                         break;
 868                 }
 869         }
 870
 871         return -1;
 872 }
 873
 874 void
 875 Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
 876 {
 877         if (Config->get_use_overlap_equivalency()) {
 878                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 879                         if ((*i)->overlap_equivalent (other)) {
 880                                 results.push_back ((*i));
 881                         }
 882                 }
 883         } else {
 884                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 885                         if ((*i)->equivalent (other)) {
 886                                 results.push_back ((*i));
 887                         }
 888                 }
 889         }
 890 }
 891
 892 void
 893 Playlist::get_region_list_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
 894 {
 895         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 896
 897                 if ((*i) && (*i)->region_list_equivalent (other)) {
 898                         results.push_back (*i);
 899                 }
 900         }
 901 }
 902
 903 void
 904 Playlist::partition (framepos_t start, framepos_t end, bool cut)
 905 {
 906         RegionList thawlist;
 907
 908         partition_internal (start, end, cut, thawlist);
 909
 910         for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
 911                 (*i)->resume_property_changes ();
 912         }
 913 }
 914
 915 void
 916 Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist)
 917 {
 918         RegionList new_regions;
 919
 920         {
 921                 RegionLock rlock (this);
 922
 923                 boost::shared_ptr<Region> region;
 924                 boost::shared_ptr<Region> current;
 925                 string new_name;
 926                 RegionList::iterator tmp;
 927                 OverlapType overlap;
 928                 framepos_t pos1, pos2, pos3, pos4;
 929
 930                 in_partition = true;
 931
 932                 /* need to work from a copy, because otherwise the regions we add during the process
 933                    get operated on as well.
 934                 */
 935
 936                 RegionList copy = regions.rlist();
 937
 938                 for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
 939
 940                         tmp = i;
 941                         ++tmp;
 942
 943                         current = *i;
 944
 945                         if (current->first_frame() >= start && current->last_frame() < end) {
 946
 947                                 if (cutting) {
 948                                         remove_region_internal (current);
 949                                 }
 950
 951                                 continue;
 952                         }
 953
 954                         /* coverage will return OverlapStart if the start coincides
 955                            with the end point. we do not partition such a region,
 956                            so catch this special case.
 957                         */
 958
 959                         if (current->first_frame() >= end) {
 960                                 continue;
 961                         }
 962
 963                         if ((overlap = current->coverage (start, end)) == OverlapNone) {
 964                                 continue;
 965                         }
 966
 967                         pos1 = current->position();
 968                         pos2 = start;
 969                         pos3 = end;
 970                         pos4 = current->last_frame();
 971
 972                         if (overlap == OverlapInternal) {
 973                                 /* split: we need 3 new regions, the front, middle and end.
 974                                    cut:   we need 2 regions, the front and end.
 975                                 */
 976
 977                                 /*
 978                                          start                 end
 979                           ---------------*************************------------
 980                                          P1  P2              P3  P4
 981                           SPLIT:
 982                           ---------------*****++++++++++++++++====------------
 983                           CUT
 984                           ---------------*****----------------====------------
 985
 986                                 */
 987
 988                                 if (!cutting) {
 989                                         /* "middle" ++++++ */
 990
 991                                         RegionFactory::region_name (new_name, current->name(), false);
 992
 993                                         PropertyList plist;
 994
 995                                         plist.add (Properties::start, current->start() + (pos2 - pos1));
 996                                         plist.add (Properties::length, pos3 - pos2);
 997                                         plist.add (Properties::name, new_name);
 998                                         plist.add (Properties::layer, regions.size());
 999                                         plist.add (Properties::automatic, true);
1000                                         plist.add (Properties::left_of_split, true);
1001                                         plist.add (Properties::right_of_split, true);
1002
1003                                         region = RegionFactory::create (current, plist);
1004                                         add_region_internal (region, start);
1005                                         new_regions.push_back (region);
1006                                 }
1007
1008                                 /* "end" ====== */
1009
1010                                 RegionFactory::region_name (new_name, current->name(), false);
1011
1012                                 PropertyList plist;
1013
1014                                 plist.add (Properties::start, current->start() + (pos3 - pos1));
1015                                 plist.add (Properties::length, pos4 - pos3);
1016                                 plist.add (Properties::name, new_name);
1017                                 plist.add (Properties::layer, regions.size());
1018                                 plist.add (Properties::automatic, true);
1019                                 plist.add (Properties::right_of_split, true);
1020
1021                                 region = RegionFactory::create (current, plist);
1022
1023                                 add_region_internal (region, end);
1024                                 new_regions.push_back (region);
1025
1026                                 /* "front" ***** */
1027
1028                                 current->suspend_property_changes ();
1029                                 thawlist.push_back (current);
1030                                 current->cut_end (pos2 - 1, this);
1031
1032                         } else if (overlap == OverlapEnd) {
1033
1034                                 /*
1035                                                               start           end
1036                                     ---------------*************************------------
1037                                                    P1           P2         P4   P3
1038                                     SPLIT:
1039                                     ---------------**************+++++++++++------------
1040                                     CUT:
1041                                     ---------------**************-----------------------
1042                                 */
1043
1044                                 if (!cutting) {
1045
1046                                         /* end +++++ */
1047
1048                                         RegionFactory::region_name (new_name, current->name(), false);
1049
1050                                         PropertyList plist;
1051
1052                                         plist.add (Properties::start, current->start() + (pos2 - pos1));
1053                                         plist.add (Properties::length, pos4 - pos2);
1054                                         plist.add (Properties::name, new_name);
1055                                         plist.add (Properties::layer, regions.size());
1056                                         plist.add (Properties::automatic, true);
1057                                         plist.add (Properties::left_of_split, true);
1058
1059                                         region = RegionFactory::create (current, plist);
1060
1061                                         add_region_internal (region, start);
1062                                         new_regions.push_back (region);
1063                                 }
1064
1065                                 /* front ****** */
1066
1067                                 current->suspend_property_changes ();
1068                                 thawlist.push_back (current);
1069                                 current->cut_end (pos2 - 1, this);
1070
1071                         } else if (overlap == OverlapStart) {
1072
1073                                 /* split: we need 2 regions: the front and the end.
1074                                    cut: just trim current to skip the cut area
1075                                 */
1076
1077                                 /*
1078                                                         start           end
1079                                     ---------------*************************------------
1080                                        P2          P1 P3                   P4
1081
1082                                     SPLIT:
1083                                     ---------------****+++++++++++++++++++++------------
1084                                     CUT:
1085                                     -------------------*********************------------
1086
1087                                 */
1088
1089                                 if (!cutting) {
1090                                         /* front **** */
1091                                         RegionFactory::region_name (new_name, current->name(), false);
1092
1093                                         PropertyList plist;
1094
1095                                         plist.add (Properties::start, current->start());
1096                                         plist.add (Properties::length, pos3 - pos1);
1097                                         plist.add (Properties::name, new_name);
1098                                         plist.add (Properties::layer, regions.size());
1099                                         plist.add (Properties::automatic, true);
1100                                         plist.add (Properties::right_of_split, true);
1101
1102                                         region = RegionFactory::create (current, plist);
1103
1104                                         add_region_internal (region, pos1);
1105                                         new_regions.push_back (region);
1106                                 }
1107
1108                                 /* end */
1109
1110                                 current->suspend_property_changes ();
1111                                 thawlist.push_back (current);
1112                                 current->trim_front (pos3, this);
1113                         } else if (overlap == OverlapExternal) {
1114
1115                                 /* split: no split required.
1116                                    cut: remove the region.
1117                                 */
1118
1119                                 /*
1120                                        start                                      end
1121                                     ---------------*************************------------
1122                                        P2          P1 P3                   P4
1123
1124                                     SPLIT:
1125                                     ---------------*************************------------
1126                                     CUT:
1127                                     ----------------------------------------------------
1128
1129                                 */
1130
1131                                 if (cutting) {
1132                                         remove_region_internal (current);
1133                                 }
1134
1135                                 new_regions.push_back (current);
1136                         }
1137                 }
1138
1139                 in_partition = false;
1140         }
1141
1142         for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) {
1143                 check_dependents (*i, false);
1144         }
1145 }
1146
1147 boost::shared_ptr<Playlist>
1148 Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t, framecnt_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
1149 {
1150         boost::shared_ptr<Playlist> ret;
1151         boost::shared_ptr<Playlist> pl;
1152         framepos_t start;
1153
1154         if (ranges.empty()) {
1155                 return boost::shared_ptr<Playlist>();
1156         }
1157
1158         start = ranges.front().start;
1159
1160         for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
1161
1162                 pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
1163
1164                 if (i == ranges.begin()) {
1165                         ret = pl;
1166                 } else {
1167
1168                         /* paste the next section into the nascent playlist,
1169                            offset to reflect the start of the first range we
1170                            chopped.
1171                         */
1172
1173                         ret->paste (pl, (*i).start - start, 1.0f);
1174                 }
1175         }
1176
1177         return ret;
1178 }
1179
1180 boost::shared_ptr<Playlist>
1181 Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
1182 {
1183         boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::cut;
1184         return cut_copy (pmf, ranges, result_is_hidden);
1185 }
1186
1187 boost::shared_ptr<Playlist>
1188 Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
1189 {
1190         boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::copy;
1191         return cut_copy (pmf, ranges, result_is_hidden);
1192 }
1193
1194 boost::shared_ptr<Playlist>
1195 Playlist::cut (framepos_t start, framecnt_t cnt, bool result_is_hidden)
1196 {
1197         boost::shared_ptr<Playlist> the_copy;
1198         RegionList thawlist;
1199         char buf[32];
1200
1201         snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
1202         string new_name = _name;
1203         new_name += '.';
1204         new_name += buf;
1205
1206         if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
1207                 return boost::shared_ptr<Playlist>();
1208         }
1209
1210         partition_internal (start, start+cnt-1, true, thawlist);
1211
1212         for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
1213                 (*i)->resume_property_changes();
1214         }
1215
1216         return the_copy;
1217 }
1218
1219 boost::shared_ptr<Playlist>
1220 Playlist::copy (framepos_t start, framecnt_t cnt, bool result_is_hidden)
1221 {
1222         char buf[32];
1223
1224         snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
1225         string new_name = _name;
1226         new_name += '.';
1227         new_name += buf;
1228
1229         cnt = min (_get_extent().second - start, cnt);
1230         return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
1231 }
1232
1233 int
1234 Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times)
1235 {
1236         times = fabs (times);
1237
1238         {
1239                 RegionLock rl1 (this);
1240                 RegionLock rl2 (other.get());
1241
1242                 framecnt_t const old_length = _get_extent().second;
1243
1244                 int itimes = (int) floor (times);
1245                 framepos_t pos = position;
1246                 framecnt_t const shift = other->_get_extent().second;
1247                 layer_t top_layer = regions.size();
1248
1249                 while (itimes--) {
1250                         for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
1251                                 boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
1252
1253                                 /* put these new regions on top of all existing ones, but preserve
1254                                    the ordering they had in the original playlist.
1255                                 */
1256
1257                                 copy_of_region->set_layer (copy_of_region->layer() + top_layer);
1258                                 cerr << "DEBUG: add new region at " << pos << endl;
1259                                 add_region_internal (copy_of_region, (*i)->position() + pos);
1260                         }
1261                         pos += shift;
1262                 }
1263
1264
1265                 /* XXX shall we handle fractional cases at some point? */
1266
1267                 if (old_length != _get_extent().second) {
1268                         notify_length_changed ();
1269                 }
1270
1271
1272         }
1273
1274         return 0;
1275 }
1276
1277
1278 void
1279 Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
1280 {
1281         times = fabs (times);
1282
1283         RegionLock rl (this);
1284         int itimes = (int) floor (times);
1285         framepos_t pos = position + 1;
1286
1287         while (itimes--) {
1288                 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
1289                 add_region_internal (copy, pos);
1290                 pos += region->length();
1291         }
1292
1293         if (floor (times) != times) {
1294                 framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times)));
1295                 string name;
1296                 RegionFactory::region_name (name, region->name(), false);
1297
1298                 {
1299                         PropertyList plist;
1300
1301                         plist.add (Properties::start, region->start());
1302                         plist.add (Properties::length, length);
1303                         plist.add (Properties::name, name);
1304
1305                         boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
1306                         add_region_internal (sub, pos);
1307                 }
1308         }
1309 }
1310
1311 void
1312 Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
1313 {
1314         RegionLock rlock (this);
1315         RegionList copy (regions.rlist());
1316         RegionList fixup;
1317
1318         for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
1319
1320                 if ((*r)->last_frame() < at) {
1321                         /* too early */
1322                         continue;
1323                 }
1324
1325                 if (at > (*r)->first_frame() && at < (*r)->last_frame()) {
1326                         /* intersected region */
1327                         if (!move_intersected) {
1328                                 continue;
1329                         }
1330                 }
1331
1332                 /* do not move regions glued to music time - that
1333                    has to be done separately.
1334                 */
1335
1336                 if (!ignore_music_glue && (*r)->position_lock_style() != AudioTime) {
1337                         fixup.push_back (*r);
1338                         continue;
1339                 }
1340
1341                 (*r)->set_position ((*r)->position() + distance, this);
1342         }
1343
1344         for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) {
1345                 (*r)->recompute_position_from_lock_style ();
1346         }
1347 }
1348
1349 void
1350 Playlist::split (framepos_t at)
1351 {
1352         RegionLock rlock (this);
1353         RegionList copy (regions.rlist());
1354
1355         /* use a copy since this operation can modify the region list
1356          */
1357
1358         for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
1359                 _split_region (*r, at);
1360         }
1361 }
1362
1363 void
1364 Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
1365 {
1366         RegionLock rl (this);
1367         _split_region (region, playlist_position);
1368 }
1369
1370 void
1371 Playlist::_split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
1372 {
1373         if (!region->covers (playlist_position)) {
1374                 return;
1375         }
1376
1377         if (region->position() == playlist_position ||
1378             region->last_frame() == playlist_position) {
1379                 return;
1380         }
1381
1382         boost::shared_ptr<Region> left;
1383         boost::shared_ptr<Region> right;
1384         frameoffset_t before;
1385         frameoffset_t after;
1386         string before_name;
1387         string after_name;
1388
1389         /* split doesn't change anything about length, so don't try to splice */
1390
1391         bool old_sp = _splicing;
1392         _splicing = true;
1393
1394         before = playlist_position - region->position();
1395         after = region->length() - before;
1396
1397         RegionFactory::region_name (before_name, region->name(), false);
1398
1399         {
1400                 PropertyList plist;
1401
1402                 plist.add (Properties::position, region->position ());
1403                 plist.add (Properties::length, before);
1404                 plist.add (Properties::name, before_name);
1405                 plist.add (Properties::left_of_split, true);
1406
1407                 /* note: we must use the version of ::create with an offset here,
1408                    since it supplies that offset to the Region constructor, which
1409                    is necessary to get audio region gain envelopes right.
1410                 */
1411                 left = RegionFactory::create (region, 0, plist);
1412         }
1413
1414         RegionFactory::region_name (after_name, region->name(), false);
1415
1416         {
1417                 PropertyList plist;
1418
1419                 plist.add (Properties::position, region->position() + before);
1420                 plist.add (Properties::length, after);
1421                 plist.add (Properties::name, after_name);
1422                 plist.add (Properties::right_of_split, true);
1423
1424                 /* same note as above */
1425                 right = RegionFactory::create (region, before, plist);
1426         }
1427
1428         add_region_internal (left, region->position());
1429         add_region_internal (right, region->position() + before);
1430
1431         uint64_t orig_layer_op = region->last_layer_op();
1432         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1433                 if ((*i)->last_layer_op() > orig_layer_op) {
1434                         (*i)->set_last_layer_op( (*i)->last_layer_op() + 1 );
1435                 }
1436         }
1437
1438         left->set_last_layer_op ( orig_layer_op );
1439         right->set_last_layer_op ( orig_layer_op + 1);
1440
1441         layer_op_counter++;
1442
1443         finalize_split_region (region, left, right);
1444
1445         remove_region_internal (region);
1446
1447         _splicing = old_sp;
1448 }
1449
1450 void
1451 Playlist::possibly_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
1452 {
1453         if (_splicing || in_set_state) {
1454                 /* don't respond to splicing moves or state setting */
1455                 return;
1456         }
1457
1458         if (_edit_mode == Splice) {
1459                 splice_locked (at, distance, exclude);
1460         }
1461 }
1462
1463 void
1464 Playlist::possibly_splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
1465 {
1466         if (_splicing || in_set_state) {
1467                 /* don't respond to splicing moves or state setting */
1468                 return;
1469         }
1470
1471         if (_edit_mode == Splice) {
1472                 splice_unlocked (at, distance, exclude);
1473         }
1474 }
1475
1476 void
1477 Playlist::splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
1478 {
1479         {
1480                 RegionLock rl (this);
1481                 core_splice (at, distance, exclude);
1482         }
1483 }
1484
1485 void
1486 Playlist::splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
1487 {
1488         core_splice (at, distance, exclude);
1489 }
1490
1491 void
1492 Playlist::core_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude)
1493 {
1494         _splicing = true;
1495
1496         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1497
1498                 if (exclude && (*i) == exclude) {
1499                         continue;
1500                 }
1501
1502                 if ((*i)->position() >= at) {
1503                         framepos_t new_pos = (*i)->position() + distance;
1504                         if (new_pos < 0) {
1505                                 new_pos = 0;
1506                         } else if (new_pos >= max_framepos - (*i)->length()) {
1507                                 new_pos = max_framepos - (*i)->length();
1508                         }
1509
1510                         (*i)->set_position (new_pos, this);
1511                 }
1512         }
1513
1514         _splicing = false;
1515
1516         notify_length_changed ();
1517 }
1518
1519 void
1520 Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
1521 {
1522         if (in_set_state || _splicing || _nudging || _shuffling) {
1523                 return;
1524         }
1525
1526         if (what_changed.contains (Properties::position)) {
1527
1528                 /* remove it from the list then add it back in
1529                    the right place again.
1530                 */
1531
1532                 RegionSortByPosition cmp;
1533
1534                 RegionList::iterator i = find (regions.begin(), regions.end(), region);
1535
1536                 if (i == regions.end()) {
1537                         /* the region bounds are being modified but its not currently
1538                            in the region list. we will use its bounds correctly when/if
1539                            it is added
1540                         */
1541                         return;
1542                 }
1543
1544                 regions.erase (i);
1545                 regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
1546         }
1547
1548         if (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) {
1549
1550                 frameoffset_t delta = 0;
1551
1552                 if (what_changed.contains (Properties::position)) {
1553                         delta = region->position() - region->last_position();
1554                 }
1555
1556                 if (what_changed.contains (Properties::length)) {
1557                         delta += region->length() - region->last_length();
1558                 }
1559
1560                 if (delta) {
1561                         possibly_splice (region->last_position() + region->last_length(), delta, region);
1562                 }
1563
1564                 if (holding_state ()) {
1565                         pending_bounds.push_back (region);
1566                 } else {
1567                         if (_session.config.get_layer_model() == MoveAddHigher) {
1568                                 /* it moved or changed length, so change the timestamp */
1569                                 timestamp_layer_op (region);
1570                         }
1571
1572                         notify_length_changed ();
1573                         relayer ();
1574                         check_dependents (region, false);
1575                 }
1576         }
1577 }
1578
1579 void
1580 Playlist::region_changed_proxy (const PropertyChange& what_changed, boost::weak_ptr<Region> weak_region)
1581 {
1582         boost::shared_ptr<Region> region (weak_region.lock());
1583
1584         if (!region) {
1585                 return;
1586         }
1587
1588         /* this makes a virtual call to the right kind of playlist ... */
1589
1590         region_changed (what_changed, region);
1591 }
1592
1593 bool
1594 Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
1595 {
1596         PropertyChange our_interests;
1597         PropertyChange bounds;
1598         PropertyChange pos_and_length;
1599         bool save = false;
1600
1601         if (in_set_state || in_flush) {
1602                 return false;
1603         }
1604
1605         our_interests.add (Properties::muted);
1606         our_interests.add (Properties::layer);
1607         our_interests.add (Properties::opaque);
1608
1609         bounds.add (Properties::start);
1610         bounds.add (Properties::position);
1611         bounds.add (Properties::length);
1612
1613         pos_and_length.add (Properties::position);
1614         pos_and_length.add (Properties::length);
1615
1616         if (what_changed.contains (bounds)) {
1617                 region_bounds_changed (what_changed, region);
1618                 save = !(_splicing || _nudging);
1619         }
1620
1621         if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) {
1622                 check_dependents (region, false);
1623         }
1624
1625         if (what_changed.contains (Properties::position) && !what_changed.contains (Properties::length)) {
1626                 notify_region_moved (region);
1627         }
1628
1629
1630         /* don't notify about layer changes, since we are the only object that can initiate
1631            them, and we notify in ::relayer()
1632         */
1633
1634         if (what_changed.contains (our_interests)) {
1635                 save = true;
1636         }
1637
1638         return save;
1639 }
1640
1641 void
1642 Playlist::drop_regions ()
1643 {
1644         RegionLock rl (this);
1645         regions.clear ();
1646         all_regions.clear ();
1647 }
1648
1649 void
1650 Playlist::clear (bool with_signals)
1651 {
1652         {
1653                 RegionLock rl (this);
1654
1655                 region_state_changed_connections.drop_connections ();
1656
1657                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1658                         pending_removes.insert (*i);
1659                 }
1660
1661                 regions.clear ();
1662
1663                 for (set<boost::shared_ptr<Region> >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) {
1664                         remove_dependents (*s);
1665                 }
1666         }
1667
1668         if (with_signals) {
1669
1670                 for (set<boost::shared_ptr<Region> >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) {
1671                         RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
1672                 }
1673
1674                 pending_removes.clear ();
1675                 pending_length = false;
1676                 LengthChanged ();
1677                 pending_contents_change = false;
1678                 ContentsChanged ();
1679         }
1680
1681 }
1682
1683 /***********************************************************************
1684  FINDING THINGS
1685  **********************************************************************/
1686
1687 Playlist::RegionList *
1688 Playlist::regions_at (framepos_t frame)
1689
1690 {
1691         RegionLock rlock (this);
1692         return find_regions_at (frame);
1693 }
1694
1695 uint32_t
1696 Playlist::count_regions_at (framepos_t frame)
1697 {
1698         RegionLock rlock (this);
1699         uint32_t cnt = 0;
1700
1701         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1702                 if ((*i)->covers (frame)) {
1703                         cnt++;
1704                 }
1705         }
1706
1707         return cnt;
1708 }
1709
1710 boost::shared_ptr<Region>
1711 Playlist::top_region_at (framepos_t frame)
1712
1713 {
1714         RegionLock rlock (this);
1715         RegionList *rlist = find_regions_at (frame);
1716         boost::shared_ptr<Region> region;
1717
1718         if (rlist->size()) {
1719                 RegionSortByLayer cmp;
1720                 rlist->sort (cmp);
1721                 region = rlist->back();
1722         }
1723
1724         delete rlist;
1725         return region;
1726 }
1727
1728 boost::shared_ptr<Region>
1729 Playlist::top_unmuted_region_at (framepos_t frame)
1730
1731 {
1732         RegionLock rlock (this);
1733         RegionList *rlist = find_regions_at (frame);
1734
1735         for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
1736
1737                 RegionList::iterator tmp = i;
1738                 ++tmp;
1739
1740                 if ((*i)->muted()) {
1741                         rlist->erase (i);
1742                 }
1743
1744                 i = tmp;
1745         }
1746
1747         boost::shared_ptr<Region> region;
1748
1749         if (rlist->size()) {
1750                 RegionSortByLayer cmp;
1751                 rlist->sort (cmp);
1752                 region = rlist->back();
1753         }
1754
1755         delete rlist;
1756         return region;
1757 }
1758
1759 Playlist::RegionList*
1760 Playlist::regions_to_read (framepos_t start, framepos_t end)
1761 {
1762         /* Caller must hold lock */
1763
1764         RegionList covering;
1765         set<framepos_t> to_check;
1766         set<boost::shared_ptr<Region> > unique;
1767
1768         to_check.insert (start);
1769         to_check.insert (end);
1770
1771         DEBUG_TRACE (DEBUG::AudioPlayback, ">>>>> REGIONS TO READ\n");
1772
1773         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1774
1775                 /* find all/any regions that span start+end */
1776
1777                 switch ((*i)->coverage (start, end)) {
1778                 case OverlapNone:
1779                         break;
1780
1781                 case OverlapInternal:
1782                         covering.push_back (*i);
1783                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OInternal)\n", (*i)->name()));
1784                         break;
1785
1786                 case OverlapStart:
1787                         to_check.insert ((*i)->position());
1788                         if ((*i)->position() != 0) {
1789                                 to_check.insert ((*i)->position()-1);
1790                         }
1791                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
1792                         covering.push_back (*i);
1793                         break;
1794
1795                 case OverlapEnd:
1796                         to_check.insert ((*i)->last_frame());
1797                         to_check.insert ((*i)->last_frame()+1);
1798                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OEnd)\n", (*i)->name()));
1799                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
1800                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
1801                         covering.push_back (*i);
1802                         break;
1803
1804                 case OverlapExternal:
1805                         covering.push_back (*i);
1806                         to_check.insert ((*i)->position());
1807                         if ((*i)->position() != 0) {
1808                                 to_check.insert ((*i)->position()-1);
1809                         }
1810                         to_check.insert ((*i)->last_frame());
1811                         to_check.insert ((*i)->last_frame()+1);
1812                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OExt)\n", (*i)->name()));
1813                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
1814                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
1815                         break;
1816                 }
1817
1818                 /* don't go too far */
1819
1820                 if ((*i)->position() > end) {
1821                         break;
1822                 }
1823         }
1824
1825         RegionList* rlist = new RegionList;
1826
1827         /* find all the regions that cover each position .... */
1828
1829         if (covering.size() == 1) {
1830
1831                 rlist->push_back (covering.front());
1832                 DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("Just one covering region (%1)\n", covering.front()->name()));
1833
1834         } else {
1835
1836                 RegionList here;
1837                 for (set<framepos_t>::iterator t = to_check.begin(); t != to_check.end(); ++t) {
1838
1839                         here.clear ();
1840
1841                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("++++ Considering %1\n", *t));
1842
1843                         for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) {
1844
1845                                 if ((*x)->covers (*t)) {
1846                                         here.push_back (*x);
1847                                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 covers %2\n",
1848                                                                                            (*x)->name(),
1849                                                                                            (*t)));
1850                                 } else {
1851                                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 does NOT covers %2\n",
1852                                                                                            (*x)->name(),
1853                                                                                            (*t)));
1854                                 }
1855
1856                         }
1857
1858                         RegionSortByLayer cmp;
1859                         here.sort (cmp);
1860
1861                         /* ... and get the top/transparent regions at "here" */
1862
1863                         for (RegionList::reverse_iterator c = here.rbegin(); c != here.rend(); ++c) {
1864
1865                                 unique.insert (*c);
1866
1867                                 if ((*c)->opaque()) {
1868
1869                                         /* the other regions at this position are hidden by this one */
1870                                         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("%1 is opaque, ignore all others\n",
1871                                                                                            (*c)->name()));
1872                                         break;
1873                                 }
1874                         }
1875                 }
1876
1877                 for (set<boost::shared_ptr<Region> >::iterator s = unique.begin(); s != unique.end(); ++s) {
1878                         rlist->push_back (*s);
1879                 }
1880
1881                 if (rlist->size() > 1) {
1882                         /* now sort by time order */
1883
1884                         RegionSortByPosition cmp;
1885                         rlist->sort (cmp);
1886                 }
1887         }
1888
1889         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("<<<<< REGIONS TO READ returns %1\n", rlist->size()));
1890
1891         return rlist;
1892 }
1893
1894 Playlist::RegionList *
1895 Playlist::find_regions_at (framepos_t frame)
1896 {
1897         /* Caller must hold lock */
1898
1899         RegionList *rlist = new RegionList;
1900
1901         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1902                 if ((*i)->covers (frame)) {
1903                         rlist->push_back (*i);
1904                 }
1905         }
1906
1907         return rlist;
1908 }
1909
1910 Playlist::RegionList *
1911 Playlist::regions_touched (framepos_t start, framepos_t end)
1912 {
1913         RegionLock rlock (this);
1914         RegionList *rlist = new RegionList;
1915
1916         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1917                 if ((*i)->coverage (start, end) != OverlapNone) {
1918                         rlist->push_back (*i);
1919                 }
1920         }
1921
1922         return rlist;
1923 }
1924
1925 framepos_t
1926 Playlist::find_next_transient (framepos_t from, int dir)
1927 {
1928         RegionLock rlock (this);
1929         AnalysisFeatureList points;
1930         AnalysisFeatureList these_points;
1931
1932         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1933                 if (dir > 0) {
1934                         if ((*i)->last_frame() < from) {
1935                                 continue;
1936                         }
1937                 } else {
1938                         if ((*i)->first_frame() > from) {
1939                                 continue;
1940                         }
1941                 }
1942
1943                 (*i)->get_transients (these_points);
1944
1945                 /* add first frame, just, err, because */
1946
1947                 these_points.push_back ((*i)->first_frame());
1948
1949                 points.insert (points.end(), these_points.begin(), these_points.end());
1950                 these_points.clear ();
1951         }
1952
1953         if (points.empty()) {
1954                 return -1;
1955         }
1956
1957         TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0);
1958         bool reached = false;
1959
1960         if (dir > 0) {
1961                 for (AnalysisFeatureList::iterator x = points.begin(); x != points.end(); ++x) {
1962                         if ((*x) >= from) {
1963                                 reached = true;
1964                         }
1965
1966                         if (reached && (*x) > from) {
1967                                 return *x;
1968                         }
1969                 }
1970         } else {
1971                 for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) {
1972                         if ((*x) <= from) {
1973                                 reached = true;
1974                         }
1975
1976                         if (reached && (*x) < from) {
1977                                 return *x;
1978                         }
1979                 }
1980         }
1981
1982         return -1;
1983 }
1984
1985 boost::shared_ptr<Region>
1986 Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
1987 {
1988         RegionLock rlock (this);
1989         boost::shared_ptr<Region> ret;
1990         framepos_t closest = max_framepos;
1991
1992         bool end_iter = false;
1993
1994         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
1995
1996                 if(end_iter) break;
1997
1998                 frameoffset_t distance;
1999                 boost::shared_ptr<Region> r = (*i);
2000                 framepos_t pos = 0;
2001
2002                 switch (point) {
2003                 case Start:
2004                         pos = r->first_frame ();
2005                         break;
2006                 case End:
2007                         pos = r->last_frame ();
2008                         break;
2009                 case SyncPoint:
2010                         pos = r->sync_position ();
2011                         break;
2012                 }
2013
2014                 switch (dir) {
2015                 case 1: /* forwards */
2016
2017                         if (pos > frame) {
2018                                 if ((distance = pos - frame) < closest) {
2019                                         closest = distance;
2020                                         ret = r;
2021                                         end_iter = true;
2022                                 }
2023                         }
2024
2025                         break;
2026
2027                 default: /* backwards */
2028
2029                         if (pos < frame) {
2030                                 if ((distance = frame - pos) < closest) {
2031                                         closest = distance;
2032                                         ret = r;
2033                                 }
2034                         }
2035                         else {
2036                                 end_iter = true;
2037                         }
2038
2039                         break;
2040                 }
2041         }
2042
2043         return ret;
2044 }
2045
2046 framepos_t
2047 Playlist::find_next_region_boundary (framepos_t frame, int dir)
2048 {
2049         RegionLock rlock (this);
2050
2051         framepos_t closest = max_framepos;
2052         framepos_t ret = -1;
2053
2054         if (dir > 0) {
2055
2056                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
2057
2058                         boost::shared_ptr<Region> r = (*i);
2059                         frameoffset_t distance;
2060
2061                         if (r->first_frame() > frame) {
2062
2063                                 distance = r->first_frame() - frame;
2064
2065                                 if (distance < closest) {
2066                                         ret = r->first_frame();
2067                                         closest = distance;
2068                                 }
2069                         }
2070
2071                         if (r->last_frame () > frame) {
2072
2073                                 distance = r->last_frame () - frame;
2074
2075                                 if (distance < closest) {
2076                                         ret = r->last_frame ();
2077                                         closest = distance;
2078                                 }
2079                         }
2080                 }
2081
2082         } else {
2083
2084                 for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) {
2085
2086                         boost::shared_ptr<Region> r = (*i);
2087                         frameoffset_t distance;
2088
2089                         if (r->last_frame() < frame) {
2090
2091                                 distance = frame - r->last_frame();
2092
2093                                 if (distance < closest) {
2094                                         ret = r->last_frame();
2095                                         closest = distance;
2096                                 }
2097                         }
2098
2099                         if (r->first_frame() < frame) {
2100
2101                                 distance = frame - r->first_frame();
2102
2103                                 if (distance < closest) {
2104                                         ret = r->first_frame();
2105                                         closest = distance;
2106                                 }
2107                         }
2108                 }
2109         }
2110
2111         return ret;
2112 }
2113
2114
2115 /***********************************************************************/
2116
2117
2118
2119
2120 void
2121 Playlist::mark_session_dirty ()
2122 {
2123         if (!in_set_state && !holding_state ()) {
2124                 _session.set_dirty();
2125         }
2126 }
2127
2128 void
2129 Playlist::rdiff (vector<Command*>& cmds) const
2130 {
2131         RegionLock rlock (const_cast<Playlist *> (this));
2132         Stateful::rdiff (cmds);
2133 }
2134
2135 void
2136 Playlist::clear_owned_changes ()
2137 {
2138         RegionLock rlock (this);
2139         Stateful::clear_owned_changes ();
2140 }
2141
2142 void
2143 Playlist::update (const RegionListProperty::ChangeRecord& change)
2144 {
2145         DEBUG_TRACE (DEBUG::Properties, string_compose ("Playlist %1 updates from a change record with %2 adds %3 removes\n",
2146                                                         name(), change.added.size(), change.removed.size()));
2147
2148         freeze ();
2149         /* add the added regions */
2150         for (RegionListProperty::ChangeContainer::iterator i = change.added.begin(); i != change.added.end(); ++i) {
2151                 add_region ((*i), (*i)->position());
2152         }
2153         /* remove the removed regions */
2154         for (RegionListProperty::ChangeContainer::iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
2155                 remove_region (*i);
2156         }
2157
2158         thaw ();
2159 }
2160
2161 int
2162 Playlist::set_state (const XMLNode& node, int version)
2163 {
2164         XMLNode *child;
2165         XMLNodeList nlist;
2166         XMLNodeConstIterator niter;
2167         XMLPropertyList plist;
2168         XMLPropertyConstIterator piter;
2169         XMLProperty *prop;
2170         boost::shared_ptr<Region> region;
2171         string region_name;
2172
2173         in_set_state++;
2174
2175         if (node.name() != "Playlist") {
2176                 in_set_state--;
2177                 return -1;
2178         }
2179
2180         freeze ();
2181
2182         plist = node.properties();
2183
2184         for (piter = plist.begin(); piter != plist.end(); ++piter) {
2185
2186                 prop = *piter;
2187
2188                 if (prop->name() == X_("name")) {
2189                         _name = prop->value();
2190                         _set_sort_id ();
2191                 } else if (prop->name() == X_("id")) {
2192                         _id = prop->value();
2193                 } else if (prop->name() == X_("orig_diskstream_id")) {
2194                         _orig_diskstream_id = prop->value ();
2195                 } else if (prop->name() == X_("frozen")) {
2196                         _frozen = string_is_affirmative (prop->value());
2197                 }
2198         }
2199
2200         clear (true);
2201
2202         nlist = node.children();
2203
2204         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2205
2206                 child = *niter;
2207
2208                 if (child->name() == "Region") {
2209
2210                         if ((prop = child->property ("id")) == 0) {
2211                                 error << _("region state node has no ID, ignored") << endmsg;
2212                                 continue;
2213                         }
2214
2215                         ID id = prop->value ();
2216
2217                         if ((region = region_by_id (id))) {
2218
2219                                 region->suspend_property_changes ();
2220
2221                                 if (region->set_state (*child, version)) {
2222                                         region->resume_property_changes ();
2223                                         continue;
2224                                 }
2225
2226                         } else if ((region = RegionFactory::create (_session, *child, true)) != 0) {
2227                                 region->suspend_property_changes ();
2228                         } else {
2229                                 error << _("Playlist: cannot create region from XML") << endmsg;
2230                                 continue;
2231                         }
2232
2233
2234                         add_region (region, region->position(), 1.0);
2235
2236                         // So that layer_op ordering doesn't get screwed up
2237                         region->set_last_layer_op( region->layer());
2238                         region->resume_property_changes ();
2239                 }
2240         }
2241
2242         /* update dependents, which was not done during add_region_internal
2243            due to in_set_state being true
2244         */
2245
2246         for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) {
2247                 check_dependents (*r, false);
2248         }
2249
2250         thaw ();
2251         notify_contents_changed ();
2252
2253         in_set_state--;
2254         first_set_state = false;
2255         return 0;
2256 }
2257
2258 XMLNode&
2259 Playlist::get_state()
2260 {
2261         return state (true);
2262 }
2263
2264 XMLNode&
2265 Playlist::get_template()
2266 {
2267         return state (false);
2268 }
2269
2270 /** @param full_state true to include regions in the returned state, otherwise false.
2271  */
2272 XMLNode&
2273 Playlist::state (bool full_state)
2274 {
2275         XMLNode *node = new XMLNode (X_("Playlist"));
2276         char buf[64] = "";
2277
2278         node->add_property (X_("id"), id().to_s());
2279         node->add_property (X_("name"), _name);
2280         node->add_property (X_("type"), _type.to_string());
2281
2282         _orig_diskstream_id.print (buf, sizeof (buf));
2283         node->add_property (X_("orig_diskstream_id"), buf);
2284         node->add_property (X_("frozen"), _frozen ? "yes" : "no");
2285
2286         if (full_state) {
2287                 RegionLock rlock (this, false);
2288
2289                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
2290                         node->add_child_nocopy ((*i)->get_state());
2291                 }
2292         }
2293
2294         if (_extra_xml) {
2295                 node->add_child_copy (*_extra_xml);
2296         }
2297
2298         return *node;
2299 }
2300
2301 bool
2302 Playlist::empty() const
2303 {
2304         RegionLock rlock (const_cast<Playlist *>(this), false);
2305         return regions.empty();
2306 }
2307
2308 uint32_t
2309 Playlist::n_regions() const
2310 {
2311         RegionLock rlock (const_cast<Playlist *>(this), false);
2312         return regions.size();
2313 }
2314
2315 pair<framepos_t, framepos_t>
2316 Playlist::get_extent () const
2317 {
2318         RegionLock rlock (const_cast<Playlist *>(this), false);
2319         return _get_extent ();
2320 }
2321
2322 pair<framepos_t, framepos_t>
2323 Playlist::_get_extent () const
2324 {
2325         pair<framepos_t, framepos_t> ext (max_framepos, 0);
2326
2327         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2328                 pair<framepos_t, framepos_t> const e ((*i)->position(), (*i)->position() + (*i)->length());
2329                 if (e.first < ext.first) {
2330                         ext.first = e.first;
2331                 }
2332                 if (e.second > ext.second) {
2333                         ext.second = e.second;
2334                 }
2335         }
2336
2337         return ext;
2338 }
2339
2340 string
2341 Playlist::bump_name (string name, Session &session)
2342 {
2343         string newname = name;
2344
2345         do {
2346                 newname = bump_name_once (newname, '.');
2347         } while (session.playlists->by_name (newname)!=NULL);
2348
2349         return newname;
2350 }
2351
2352
2353 layer_t
2354 Playlist::top_layer() const
2355 {
2356         RegionLock rlock (const_cast<Playlist *> (this));
2357         layer_t top = 0;
2358
2359         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2360                 top = max (top, (*i)->layer());
2361         }
2362         return top;
2363 }
2364
2365 void
2366 Playlist::set_edit_mode (EditMode mode)
2367 {
2368         _edit_mode = mode;
2369 }
2370
2371 /********************
2372  * Region Layering
2373  ********************/
2374
2375 void
2376 Playlist::relayer ()
2377 {
2378         /* never compute layers when changing state for undo/redo or setting from XML */
2379
2380         if (in_update || in_set_state) {
2381                 return;
2382         }
2383
2384         bool changed = false;
2385
2386         /* Build up a new list of regions on each layer, stored in a set of lists
2387            each of which represent some period of time on some layer.  The idea
2388            is to avoid having to search the entire region list to establish whether
2389            each region overlaps another */
2390
2391         /* how many pieces to divide this playlist's time up into */
2392         int const divisions = 512;
2393
2394         /* find the start and end positions of the regions on this playlist */
2395         framepos_t start = INT64_MAX;
2396         framepos_t end = 0;
2397         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2398                 start = min (start, (*i)->position());
2399                 end = max (end, (*i)->position() + (*i)->length());
2400         }
2401
2402         /* hence the size of each time division */
2403         double const division_size = (end - start) / double (divisions);
2404
2405         vector<vector<RegionList> > layers;
2406         layers.push_back (vector<RegionList> (divisions));
2407
2408         /* we want to go through regions from desired lowest to desired highest layer,
2409            which depends on the layer model
2410         */
2411
2412         RegionList copy = regions.rlist();
2413
2414         /* sort according to the model and the layering mode that we're in */
2415
2416         if (_explicit_relayering) {
2417
2418                 copy.sort (RegionSortByLayerWithPending ());
2419
2420         } else if (_session.config.get_layer_model() == MoveAddHigher || _session.config.get_layer_model() == AddHigher) {
2421
2422                 copy.sort (RegionSortByLastLayerOp ());
2423
2424         }
2425
2426
2427         for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
2428
2429                 /* reset the pending explicit relayer flag for every region, now that we're relayering */
2430                 (*i)->set_pending_explicit_relayer (false);
2431
2432                 /* find the time divisions that this region covers; if there are no regions on the list,
2433                    division_size will equal 0 and in this case we'll just say that
2434                    start_division = end_division = 0.
2435                 */
2436                 int start_division = 0;
2437                 int end_division = 0;
2438
2439                 if (division_size > 0) {
2440                         start_division = floor ( ((*i)->position() - start) / division_size);
2441                         end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size );
2442                         if (end_division == divisions) {
2443                                 end_division--;
2444                         }
2445                 }
2446
2447                 assert (divisions == 0 || end_division < divisions);
2448
2449                 /* find the lowest layer that this region can go on */
2450                 size_t j = layers.size();
2451                 while (j > 0) {
2452                         /* try layer j - 1; it can go on if it overlaps no other region
2453                            that is already on that layer
2454                         */
2455
2456                         bool overlap = false;
2457                         for (int k = start_division; k <= end_division; ++k) {
2458                                 RegionList::iterator l = layers[j-1][k].begin ();
2459                                 while (l != layers[j-1][k].end()) {
2460                                         if ((*l)->overlap_equivalent (*i)) {
2461                                                 overlap = true;
2462                                                 break;
2463                                         }
2464                                         l++;
2465                                 }
2466
2467                                 if (overlap) {
2468                                         break;
2469                                 }
2470                         }
2471
2472                         if (overlap) {
2473                                 /* overlap, so we must use layer j */
2474                                 break;
2475                         }
2476
2477                         --j;
2478                 }
2479
2480                 if (j == layers.size()) {
2481                         /* we need a new layer for this region */
2482                         layers.push_back (vector<RegionList> (divisions));
2483                 }
2484
2485                 /* put a reference to this region in each of the divisions that it exists in */
2486                 for (int k = start_division; k <= end_division; ++k) {
2487                         layers[j][k].push_back (*i);
2488                 }
2489
2490                 if ((*i)->layer() != j) {
2491                         changed = true;
2492                 }
2493
2494                 (*i)->set_layer (j);
2495         }
2496
2497         if (changed) {
2498                 notify_layering_changed ();
2499         }
2500 }
2501
2502 /* XXX these layer functions are all deprecated */
2503
2504 void
2505 Playlist::raise_region (boost::shared_ptr<Region> region)
2506 {
2507         uint32_t top = regions.size() - 1;
2508         layer_t target = region->layer() + 1U;
2509
2510         if (target >= top) {
2511                 /* its already at the effective top */
2512                 return;
2513         }
2514
2515         move_region_to_layer (target, region, 1);
2516 }
2517
2518 void
2519 Playlist::lower_region (boost::shared_ptr<Region> region)
2520 {
2521         if (region->layer() == 0) {
2522                 /* its already at the bottom */
2523                 return;
2524         }
2525
2526         layer_t target = region->layer() - 1U;
2527
2528         move_region_to_layer (target, region, -1);
2529 }
2530
2531 void
2532 Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
2533 {
2534         /* does nothing useful if layering mode is later=higher */
2535         switch (_session.config.get_layer_model()) {
2536         case LaterHigher:
2537                 return;
2538         default:
2539                 break;
2540         }
2541
2542         layer_t top = regions.size() - 1;
2543
2544         if (region->layer() >= top) {
2545                 /* already on the top */
2546                 return;
2547         }
2548
2549         move_region_to_layer (top, region, 1);
2550         /* mark the region's last_layer_op as now, so that it remains on top when
2551            doing future relayers (until something else takes over)
2552          */
2553         timestamp_layer_op (region);
2554 }
2555
2556 void
2557 Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
2558 {
2559         /* does nothing useful if layering mode is later=higher */
2560         switch (_session.config.get_layer_model()) {
2561         case LaterHigher:
2562                 return;
2563         default:
2564                 break;
2565         }
2566
2567         if (region->layer() == 0) {
2568                 /* already on the bottom */
2569                 return;
2570         }
2571
2572         move_region_to_layer (0, region, -1);
2573         /* force region's last layer op to zero so that it stays at the bottom
2574            when doing future relayers
2575         */
2576         region->set_last_layer_op (0);
2577 }
2578
2579 int
2580 Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr<Region> region, int dir)
2581 {
2582         RegionList::iterator i;
2583         typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
2584         list<LayerInfo> layerinfo;
2585
2586         {
2587                 RegionLock rlock (const_cast<Playlist *> (this));
2588
2589                 for (i = regions.begin(); i != regions.end(); ++i) {
2590
2591                         if (region == *i) {
2592                                 continue;
2593                         }
2594
2595                         layer_t dest;
2596
2597                         if (dir > 0) {
2598
2599                                 /* region is moving up, move all regions on intermediate layers
2600                                    down 1
2601                                 */
2602
2603                                 if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) {
2604                                         dest = (*i)->layer() - 1;
2605                                 } else {
2606                                         /* not affected */
2607                                         continue;
2608                                 }
2609                         } else {
2610
2611                                 /* region is moving down, move all regions on intermediate layers
2612                                    up 1
2613                                 */
2614
2615                                 if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) {
2616                                         dest = (*i)->layer() + 1;
2617                                 } else {
2618                                         /* not affected */
2619                                         continue;
2620                                 }
2621                         }
2622
2623                         LayerInfo newpair;
2624
2625                         newpair.first = *i;
2626                         newpair.second = dest;
2627
2628                         layerinfo.push_back (newpair);
2629                 }
2630         }
2631
2632         freeze ();
2633
2634         /* now reset the layers without holding the region lock */
2635
2636         for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
2637                 x->first->set_layer (x->second);
2638         }
2639
2640         region->set_layer (target_layer);
2641
2642         /* now check all dependents, since we changed the layering */
2643
2644         for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
2645                 check_dependents (x->first, false);
2646         }
2647
2648         check_dependents (region, false);
2649         notify_layering_changed ();
2650
2651         thaw ();
2652
2653         return 0;
2654 }
2655
2656 void
2657 Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards)
2658 {
2659         RegionList::iterator i;
2660         bool moved = false;
2661
2662         _nudging = true;
2663
2664         {
2665                 RegionLock rlock (const_cast<Playlist *> (this));
2666
2667                 for (i = regions.begin(); i != regions.end(); ++i) {
2668
2669                         if ((*i)->position() >= start) {
2670
2671                                 framepos_t new_pos;
2672
2673                                 if (forwards) {
2674
2675                                         if ((*i)->last_frame() > max_framepos - distance) {
2676                                                 new_pos = max_framepos - (*i)->length();
2677                                         } else {
2678                                                 new_pos = (*i)->position() + distance;
2679                                         }
2680
2681                                 } else {
2682
2683                                         if ((*i)->position() > distance) {
2684                                                 new_pos = (*i)->position() - distance;
2685                                         } else {
2686                                                 new_pos = 0;
2687                                         }
2688                                 }
2689
2690                                 (*i)->set_position (new_pos, this);
2691                                 moved = true;
2692                         }
2693                 }
2694         }
2695
2696         if (moved) {
2697                 _nudging = false;
2698                 notify_length_changed ();
2699         }
2700
2701 }
2702
2703 boost::shared_ptr<Region>
2704 Playlist::find_region (const ID& id) const
2705 {
2706         RegionLock rlock (const_cast<Playlist*> (this));
2707
2708         /* searches all regions currently in use by the playlist */
2709
2710         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2711                 if ((*i)->id() == id) {
2712                         return *i;
2713                 }
2714         }
2715
2716         return boost::shared_ptr<Region> ();
2717 }
2718
2719 uint32_t
2720 Playlist::region_use_count (boost::shared_ptr<Region> r) const
2721 {
2722         RegionLock rlock (const_cast<Playlist*> (this));
2723         uint32_t cnt = 0;
2724
2725         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2726                 if ((*i) == r) {
2727                         cnt++;
2728                 }
2729         }
2730
2731         return cnt;
2732 }
2733
2734 boost::shared_ptr<Region>
2735 Playlist::region_by_id (const ID& id) const
2736 {
2737         /* searches all regions ever added to this playlist */
2738
2739         for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
2740                 if ((*i)->id() == id) {
2741                         return *i;
2742                 }
2743         }
2744         return boost::shared_ptr<Region> ();
2745 }
2746
2747 void
2748 Playlist::dump () const
2749 {
2750         boost::shared_ptr<Region> r;
2751
2752         cerr << "Playlist \"" << _name << "\" " << endl
2753              << regions.size() << " regions "
2754              << endl;
2755
2756         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2757                 r = *i;
2758                 cerr << "  " << r->name() << " ["
2759                      << r->start() << "+" << r->length()
2760                      << "] at "
2761                      << r->position()
2762                      << " on layer "
2763                      << r->layer ()
2764                      << endl;
2765         }
2766 }
2767
2768 void
2769 Playlist::set_frozen (bool yn)
2770 {
2771         _frozen = yn;
2772 }
2773
2774 void
2775 Playlist::timestamp_layer_op (boost::shared_ptr<Region> region)
2776 {
2777         region->set_last_layer_op (++layer_op_counter);
2778 }
2779
2780
2781 void
2782 Playlist::shuffle (boost::shared_ptr<Region> region, int dir)
2783 {
2784         bool moved = false;
2785
2786         if (region->locked()) {
2787                 return;
2788         }
2789
2790         _shuffling = true;
2791
2792         {
2793                 RegionLock rlock (const_cast<Playlist*> (this));
2794
2795
2796                 if (dir > 0) {
2797
2798                         RegionList::iterator next;
2799
2800                         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
2801                                 if ((*i) == region) {
2802                                         next = i;
2803                                         ++next;
2804
2805                                         if (next != regions.end()) {
2806
2807                                                 if ((*next)->locked()) {
2808                                                         break;
2809                                                 }
2810
2811                                                 framepos_t new_pos;
2812
2813                                                 if ((*next)->position() != region->last_frame() + 1) {
2814                                                         /* they didn't used to touch, so after shuffle,
2815                                                            just have them swap positions.
2816                                                         */
2817                                                         new_pos = (*next)->position();
2818                                                 } else {
2819                                                         /* they used to touch, so after shuffle,
2820                                                            make sure they still do. put the earlier
2821                                                            region where the later one will end after
2822                                                            it is moved.
2823                                                         */
2824                                                         new_pos = region->position() + (*next)->length();
2825                                                 }
2826
2827                                                 (*next)->set_position (region->position(), this);
2828                                                 region->set_position (new_pos, this);
2829
2830                                                 /* avoid a full sort */
2831
2832                                                 regions.erase (i); // removes the region from the list */
2833                                                 next++;
2834                                                 regions.insert (next, region); // adds it back after next
2835
2836                                                 moved = true;
2837                                         }
2838                                         break;
2839                                 }
2840                         }
2841                 } else {
2842
2843                         RegionList::iterator prev = regions.end();
2844
2845                         for (RegionList::iterator i = regions.begin(); i != regions.end(); prev = i, ++i) {
2846                                 if ((*i) == region) {
2847
2848                                         if (prev != regions.end()) {
2849
2850                                                 if ((*prev)->locked()) {
2851                                                         break;
2852                                                 }
2853
2854                                                 framepos_t new_pos;
2855                                                 if (region->position() != (*prev)->last_frame() + 1) {
2856                                                         /* they didn't used to touch, so after shuffle,
2857                                                            just have them swap positions.
2858                                                         */
2859                                                         new_pos = region->position();
2860                                                 } else {
2861                                                         /* they used to touch, so after shuffle,
2862                                                            make sure they still do. put the earlier
2863                                                            one where the later one will end after
2864                                                         */
2865                                                         new_pos = (*prev)->position() + region->length();
2866                                                 }
2867
2868                                                 region->set_position ((*prev)->position(), this);
2869                                                 (*prev)->set_position (new_pos, this);
2870
2871                                                 /* avoid a full sort */
2872
2873                                                 regions.erase (i); // remove region
2874                                                 regions.insert (prev, region); // insert region before prev
2875
2876                                                 moved = true;
2877                                         }
2878
2879                                         break;
2880                                 }
2881                         }
2882                 }
2883         }
2884
2885         _shuffling = false;
2886
2887         if (moved) {
2888
2889                 relayer ();
2890                 check_dependents (region, false);
2891
2892                 notify_contents_changed();
2893         }
2894
2895 }
2896
2897 bool
2898 Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
2899 {
2900         RegionLock rlock (const_cast<Playlist*> (this));
2901
2902         if (regions.size() > 1) {
2903                 return true;
2904         }
2905
2906         return false;
2907 }
2908
2909 void
2910 Playlist::update_after_tempo_map_change ()
2911 {
2912         RegionLock rlock (const_cast<Playlist*> (this));
2913         RegionList copy (regions.rlist());
2914
2915         freeze ();
2916
2917         for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
2918                 (*i)->update_position_after_tempo_map_change ();
2919         }
2920
2921         thaw ();
2922 }
2923
2924 void
2925 Playlist::foreach_region (boost::function<void(boost::shared_ptr<Region>)> s)
2926 {
2927         RegionLock rl (this, false);
2928         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
2929                 s (*i);
2930         }
2931 }
2932
2933 void
2934 Playlist::set_explicit_relayering (bool e)
2935 {
2936         if (e == false && _explicit_relayering == true) {
2937
2938                 /* We are changing from explicit to implicit relayering; layering may have been changed whilst
2939                    we were in explicit mode, and we don't want that to be undone next time an implicit relayer
2940                    occurs.  Hence now we'll set up region last_layer_op values so that an implicit relayer
2941                    at this point would keep regions on the same layers.
2942
2943                    From then on in, it's just you and your towel.
2944                 */
2945
2946                 RegionLock rl (this);
2947                 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
2948                         (*i)->set_last_layer_op ((*i)->layer ());
2949                 }
2950         }
2951
2952         _explicit_relayering = e;
2953 }
2954
2955
2956 bool
2957 Playlist::has_region_at (framepos_t const p) const
2958 {
2959         RegionLock (const_cast<Playlist *> (this));
2960
2961         RegionList::const_iterator i = regions.begin ();
2962         while (i != regions.end() && !(*i)->covers (p)) {
2963                 ++i;
2964         }
2965
2966         return (i != regions.end());
2967 }
2968
2969 /** Remove any region that uses a given source */
2970 void
2971 Playlist::remove_region_by_source (boost::shared_ptr<Source> s)
2972 {
2973         RegionLock rl (this);
2974
2975         RegionList::iterator i = regions.begin();
2976         while (i != regions.end()) {
2977                 RegionList::iterator j = i;
2978                 ++j;
2979
2980                 if ((*i)->uses_source (s)) {
2981                         remove_region_internal (*i);
2982                 }
2983
2984                 i = j;
2985         }
2986 }
2987
2988 /** Look from a session frame time and find the start time of the next region
2989  *  which is on the top layer of this playlist.
2990  *  @param t Time to look from.
2991  *  @return Position of next top-layered region, or max_framepos if there isn't one.
2992  */
2993 framepos_t
2994 Playlist::find_next_top_layer_position (framepos_t t) const
2995 {
2996         RegionLock rlock (const_cast<Playlist *> (this));
2997
2998         layer_t const top = top_layer ();
2999
3000         RegionList copy = regions.rlist ();
3001         copy.sort (RegionSortByPosition ());
3002
3003         for (RegionList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
3004                 if ((*i)->position() >= t && (*i)->layer() == top) {
3005                         return (*i)->position();
3006                 }
3007         }
3008
3009         return max_framepos;
3010 }