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