libs/ardour/region.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 <iostream>
  21 #include <cmath>
  22 #include <climits>
  23 #include <algorithm>
  24 #include <sstream>
  25
  26 #include <glibmm/threads.h>
  27 #include "pbd/xml++.h"
  28
  29 #include "ardour/debug.h"
  30 #include "ardour/filter.h"
  31 #include "ardour/playlist.h"
  32 #include "ardour/playlist_source.h"
  33 #include "ardour/profile.h"
  34 #include "ardour/region.h"
  35 #include "ardour/region_factory.h"
  36 #include "ardour/session.h"
  37 #include "ardour/source.h"
  38 #include "ardour/tempo.h"
  39 #include "ardour/transient_detector.h"
  40
  41 #include "pbd/i18n.h"
  42
  43 using namespace std;
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46
  47 namespace ARDOUR {
  48         class Progress;
  49         namespace Properties {
  50                 PBD::PropertyDescriptor<bool> muted;
  51                 PBD::PropertyDescriptor<bool> opaque;
  52                 PBD::PropertyDescriptor<bool> locked;
  53                 PBD::PropertyDescriptor<bool> video_locked;
  54                 PBD::PropertyDescriptor<bool> automatic;
  55                 PBD::PropertyDescriptor<bool> whole_file;
  56                 PBD::PropertyDescriptor<bool> import;
  57                 PBD::PropertyDescriptor<bool> external;
  58                 PBD::PropertyDescriptor<bool> sync_marked;
  59                 PBD::PropertyDescriptor<bool> left_of_split;
  60                 PBD::PropertyDescriptor<bool> right_of_split;
  61                 PBD::PropertyDescriptor<bool> hidden;
  62                 PBD::PropertyDescriptor<bool> position_locked;
  63                 PBD::PropertyDescriptor<bool> valid_transients;
  64                 PBD::PropertyDescriptor<framepos_t> start;
  65                 PBD::PropertyDescriptor<framecnt_t> length;
  66                 PBD::PropertyDescriptor<framepos_t> position;
  67                 PBD::PropertyDescriptor<double> beat;
  68                 PBD::PropertyDescriptor<framecnt_t> sync_position;
  69                 PBD::PropertyDescriptor<layer_t> layer;
  70                 PBD::PropertyDescriptor<framepos_t> ancestral_start;
  71                 PBD::PropertyDescriptor<framecnt_t> ancestral_length;
  72                 PBD::PropertyDescriptor<float> stretch;
  73                 PBD::PropertyDescriptor<float> shift;
  74                 PBD::PropertyDescriptor<PositionLockStyle> position_lock_style;
  75                 PBD::PropertyDescriptor<uint64_t> layering_index;
  76         }
  77 }
  78
  79 PBD::Signal2<void,boost::shared_ptr<ARDOUR::Region>,const PropertyChange&> Region::RegionPropertyChanged;
  80
  81 void
  82 Region::make_property_quarks ()
  83 {
  84         Properties::muted.property_id = g_quark_from_static_string (X_("muted"));
  85         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for muted = %1\n",       Properties::muted.property_id));
  86         Properties::opaque.property_id = g_quark_from_static_string (X_("opaque"));
  87         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for opaque = %1\n",      Properties::opaque.property_id));
  88         Properties::locked.property_id = g_quark_from_static_string (X_("locked"));
  89         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for locked = %1\n",      Properties::locked.property_id));
  90         Properties::video_locked.property_id = g_quark_from_static_string (X_("video-locked"));
  91         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for video-locked = %1\n",        Properties::video_locked.property_id));
  92         Properties::automatic.property_id = g_quark_from_static_string (X_("automatic"));
  93         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for automatic = %1\n",   Properties::automatic.property_id));
  94         Properties::whole_file.property_id = g_quark_from_static_string (X_("whole-file"));
  95         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for whole-file = %1\n",  Properties::whole_file.property_id));
  96         Properties::import.property_id = g_quark_from_static_string (X_("import"));
  97         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for import = %1\n",      Properties::import.property_id));
  98         Properties::external.property_id = g_quark_from_static_string (X_("external"));
  99         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for external = %1\n",    Properties::external.property_id));
 100         Properties::sync_marked.property_id = g_quark_from_static_string (X_("sync-marked"));
 101         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for sync-marked = %1\n",         Properties::sync_marked.property_id));
 102         Properties::left_of_split.property_id = g_quark_from_static_string (X_("left-of-split"));
 103         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for left-of-split = %1\n",       Properties::left_of_split.property_id));
 104         Properties::right_of_split.property_id = g_quark_from_static_string (X_("right-of-split"));
 105         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for right-of-split = %1\n",      Properties::right_of_split.property_id));
 106         Properties::hidden.property_id = g_quark_from_static_string (X_("hidden"));
 107         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for hidden = %1\n",      Properties::hidden.property_id));
 108         Properties::position_locked.property_id = g_quark_from_static_string (X_("position-locked"));
 109         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for position-locked = %1\n",     Properties::position_locked.property_id));
 110         Properties::valid_transients.property_id = g_quark_from_static_string (X_("valid-transients"));
 111         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for valid-transients = %1\n",    Properties::valid_transients.property_id));
 112         Properties::start.property_id = g_quark_from_static_string (X_("start"));
 113         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for start = %1\n",       Properties::start.property_id));
 114         Properties::length.property_id = g_quark_from_static_string (X_("length"));
 115         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for length = %1\n",      Properties::length.property_id));
 116         Properties::position.property_id = g_quark_from_static_string (X_("position"));
 117         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for position = %1\n",    Properties::position.property_id));
 118         Properties::beat.property_id = g_quark_from_static_string (X_("beat"));
 119         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for beat = %1\n",        Properties::beat.property_id));
 120         Properties::sync_position.property_id = g_quark_from_static_string (X_("sync-position"));
 121         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for sync-position = %1\n",       Properties::sync_position.property_id));
 122         Properties::layer.property_id = g_quark_from_static_string (X_("layer"));
 123         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for layer = %1\n",       Properties::layer.property_id));
 124         Properties::ancestral_start.property_id = g_quark_from_static_string (X_("ancestral-start"));
 125         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for ancestral-start = %1\n",     Properties::ancestral_start.property_id));
 126         Properties::ancestral_length.property_id = g_quark_from_static_string (X_("ancestral-length"));
 127         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for ancestral-length = %1\n",    Properties::ancestral_length.property_id));
 128         Properties::stretch.property_id = g_quark_from_static_string (X_("stretch"));
 129         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for stretch = %1\n",     Properties::stretch.property_id));
 130         Properties::shift.property_id = g_quark_from_static_string (X_("shift"));
 131         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for shift = %1\n",       Properties::shift.property_id));
 132         Properties::position_lock_style.property_id = g_quark_from_static_string (X_("positional-lock-style"));
 133         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for position_lock_style = %1\n",         Properties::position_lock_style.property_id));
 134         Properties::layering_index.property_id = g_quark_from_static_string (X_("layering-index"));
 135         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for layering_index = %1\n",      Properties::layering_index.property_id));
 136 }
 137
 138 void
 139 Region::register_properties ()
 140 {
 141         _xml_node_name = X_("Region");
 142
 143         add_property (_muted);
 144         add_property (_opaque);
 145         add_property (_locked);
 146         add_property (_video_locked);
 147         add_property (_automatic);
 148         add_property (_whole_file);
 149         add_property (_import);
 150         add_property (_external);
 151         add_property (_sync_marked);
 152         add_property (_left_of_split);
 153         add_property (_right_of_split);
 154         add_property (_hidden);
 155         add_property (_position_locked);
 156         add_property (_valid_transients);
 157         add_property (_start);
 158         add_property (_length);
 159         add_property (_position);
 160         add_property (_beat);
 161         add_property (_sync_position);
 162         add_property (_ancestral_start);
 163         add_property (_ancestral_length);
 164         add_property (_stretch);
 165         add_property (_shift);
 166         add_property (_position_lock_style);
 167         add_property (_layering_index);
 168 }
 169
 170 #define REGION_DEFAULT_STATE(s,l) \
 171         _sync_marked (Properties::sync_marked, false) \
 172         , _left_of_split (Properties::left_of_split, false) \
 173         , _right_of_split (Properties::right_of_split, false) \
 174         , _valid_transients (Properties::valid_transients, false) \
 175         , _start (Properties::start, (s))       \
 176         , _length (Properties::length, (l))     \
 177         , _position (Properties::position, 0) \
 178         , _beat (Properties::beat, 0.0) \
 179         , _sync_position (Properties::sync_position, (s)) \
 180         , _quarter_note (0.0) \
 181         , _transient_user_start (0) \
 182         , _transient_analysis_start (0) \
 183         , _transient_analysis_end (0) \
 184         , _muted (Properties::muted, false) \
 185         , _opaque (Properties::opaque, true) \
 186         , _locked (Properties::locked, false) \
 187   , _video_locked (Properties::video_locked, false) \
 188         , _automatic (Properties::automatic, false) \
 189         , _whole_file (Properties::whole_file, false) \
 190         , _import (Properties::import, false) \
 191         , _external (Properties::external, false) \
 192         , _hidden (Properties::hidden, false) \
 193         , _position_locked (Properties::position_locked, false) \
 194         , _ancestral_start (Properties::ancestral_start, (s)) \
 195         , _ancestral_length (Properties::ancestral_length, (l)) \
 196         , _stretch (Properties::stretch, 1.0) \
 197         , _shift (Properties::shift, 1.0) \
 198         , _position_lock_style (Properties::position_lock_style, _type == DataType::AUDIO ? AudioTime : MusicTime) \
 199         , _layering_index (Properties::layering_index, 0)
 200
 201 #define REGION_COPY_STATE(other) \
 202           _sync_marked (Properties::sync_marked, other->_sync_marked) \
 203         , _left_of_split (Properties::left_of_split, other->_left_of_split) \
 204         , _right_of_split (Properties::right_of_split, other->_right_of_split) \
 205         , _valid_transients (Properties::valid_transients, other->_valid_transients) \
 206         , _start(Properties::start, other->_start)              \
 207         , _length(Properties::length, other->_length)           \
 208         , _position(Properties::position, other->_position)     \
 209         , _beat (Properties::beat, other->_beat)                \
 210         , _sync_position(Properties::sync_position, other->_sync_position) \
 211         , _quarter_note (other->_quarter_note)                                \
 212         , _user_transients (other->_user_transients) \
 213         , _transient_user_start (other->_transient_user_start) \
 214         , _transients (other->_transients) \
 215         , _transient_analysis_start (other->_transient_analysis_start) \
 216         , _transient_analysis_end (other->_transient_analysis_end) \
 217         , _muted (Properties::muted, other->_muted)             \
 218         , _opaque (Properties::opaque, other->_opaque)          \
 219         , _locked (Properties::locked, other->_locked)          \
 220   , _video_locked (Properties::video_locked, other->_video_locked) \
 221         , _automatic (Properties::automatic, other->_automatic) \
 222         , _whole_file (Properties::whole_file, other->_whole_file) \
 223         , _import (Properties::import, other->_import)          \
 224         , _external (Properties::external, other->_external)    \
 225         , _hidden (Properties::hidden, other->_hidden)          \
 226         , _position_locked (Properties::position_locked, other->_position_locked) \
 227         , _ancestral_start (Properties::ancestral_start, other->_ancestral_start) \
 228         , _ancestral_length (Properties::ancestral_length, other->_ancestral_length) \
 229         , _stretch (Properties::stretch, other->_stretch)       \
 230         , _shift (Properties::shift, other->_shift)             \
 231         , _position_lock_style (Properties::position_lock_style, other->_position_lock_style) \
 232         , _layering_index (Properties::layering_index, other->_layering_index)
 233
 234 /* derived-from-derived constructor (no sources in constructor) */
 235 Region::Region (Session& s, framepos_t start, framecnt_t length, const string& name, DataType type)
 236         : SessionObject(s, name)
 237         , _type(type)
 238         , REGION_DEFAULT_STATE(start,length)
 239         , _last_length (length)
 240         , _last_position (0)
 241         , _first_edit (EditChangesNothing)
 242         , _layer (0)
 243 {
 244         register_properties ();
 245
 246         /* no sources at this point */
 247 }
 248
 249 /** Basic Region constructor (many sources) */
 250 Region::Region (const SourceList& srcs)
 251         : SessionObject(srcs.front()->session(), "toBeRenamed")
 252         , _type (srcs.front()->type())
 253         , REGION_DEFAULT_STATE(0,0)
 254         , _last_length (0)
 255         , _last_position (0)
 256         , _first_edit (EditChangesNothing)
 257         , _layer (0)
 258 {
 259         register_properties ();
 260
 261         _type = srcs.front()->type();
 262
 263         use_sources (srcs);
 264
 265         assert(_sources.size() > 0);
 266         assert (_type == srcs.front()->type());
 267 }
 268
 269 /** Create a new Region from an existing one */
 270 Region::Region (boost::shared_ptr<const Region> other)
 271         : SessionObject(other->session(), other->name())
 272         , _type (other->data_type())
 273         , REGION_COPY_STATE (other)
 274         , _last_length (other->_last_length)
 275         , _last_position(other->_last_position) \
 276         , _first_edit (EditChangesNothing)
 277         , _layer (other->_layer)
 278 {
 279         register_properties ();
 280
 281         /* override state that may have been incorrectly inherited from the other region
 282          */
 283
 284         _position = other->_position;
 285         _locked = false;
 286         _whole_file = false;
 287         _hidden = false;
 288
 289         use_sources (other->_sources);
 290         set_master_sources (other->_master_sources);
 291
 292         _position_lock_style = other->_position_lock_style;
 293         _first_edit = other->_first_edit;
 294
 295         _start = other->_start;
 296         _beat = other->_beat;
 297         _quarter_note = other->_quarter_note;
 298
 299         /* sync pos is relative to start of file. our start-in-file is now zero,
 300            so set our sync position to whatever the the difference between
 301            _start and _sync_pos was in the other region.
 302
 303            result is that our new sync pos points to the same point in our source(s)
 304            as the sync in the other region did in its source(s).
 305
 306            since we start at zero in our source(s), it is not possible to use a sync point that
 307            is before the start. reset it to _start if that was true in the other region.
 308         */
 309
 310         if (other->sync_marked()) {
 311                 if (other->_start < other->_sync_position) {
 312                         /* sync pos was after the start point of the other region */
 313                         _sync_position = other->_sync_position - other->_start;
 314                 } else {
 315                         /* sync pos was before the start point of the other region. not possible here. */
 316                         _sync_marked = false;
 317                         _sync_position = _start;
 318                 }
 319         } else {
 320                 _sync_marked = false;
 321                 _sync_position = _start;
 322         }
 323
 324         assert (_type == other->data_type());
 325 }
 326
 327 /** Create a new Region from part of an existing one.
 328
 329     the start within \a other is given by \a offset
 330     (i.e. relative to the start of \a other's sources, the start is \a offset + \a other.start()
 331 */
 332 Region::Region (boost::shared_ptr<const Region> other, frameoffset_t offset, const int32_t sub_num)
 333         : SessionObject(other->session(), other->name())
 334         , _type (other->data_type())
 335         , REGION_COPY_STATE (other)
 336         , _last_length (other->_last_length)
 337         , _last_position(other->_last_position) \
 338         , _first_edit (EditChangesNothing)
 339         , _layer (other->_layer)
 340 {
 341         register_properties ();
 342
 343         /* override state that may have been incorrectly inherited from the other region
 344          */
 345
 346         _position = other->_position + offset;
 347         _locked = false;
 348         _whole_file = false;
 349         _hidden = false;
 350
 351         use_sources (other->_sources);
 352         set_master_sources (other->_master_sources);
 353
 354         _start = other->_start + offset;
 355         _beat = _session.tempo_map().exact_beat_at_frame (_position, sub_num);
 356         _quarter_note = _session.tempo_map().exact_qn_at_frame (_position, sub_num);
 357
 358         /* if the other region had a distinct sync point
 359            set, then continue to use it as best we can.
 360            otherwise, reset sync point back to start.
 361         */
 362
 363         if (other->sync_marked()) {
 364                 if (other->_sync_position < _start) {
 365                         _sync_marked = false;
 366                         _sync_position = _start;
 367                 } else {
 368                         _sync_position = other->_sync_position;
 369                 }
 370         } else {
 371                 _sync_marked = false;
 372                 _sync_position = _start;
 373         }
 374
 375         assert (_type == other->data_type());
 376 }
 377
 378 /** Create a copy of @param other but with different sources. Used by filters */
 379 Region::Region (boost::shared_ptr<const Region> other, const SourceList& srcs)
 380         : SessionObject (other->session(), other->name())
 381         , _type (srcs.front()->type())
 382         , REGION_COPY_STATE (other)
 383         , _last_length (other->_last_length)
 384         , _last_position (other->_last_position)
 385         , _first_edit (EditChangesID)
 386         , _layer (other->_layer)
 387 {
 388         register_properties ();
 389
 390         _locked = false;
 391         _position_locked = false;
 392
 393         other->_first_edit = EditChangesName;
 394
 395         if (other->_extra_xml) {
 396                 _extra_xml = new XMLNode (*other->_extra_xml);
 397         } else {
 398                 _extra_xml = 0;
 399         }
 400
 401         use_sources (srcs);
 402         assert(_sources.size() > 0);
 403 }
 404
 405 Region::~Region ()
 406 {
 407         DEBUG_TRACE (DEBUG::Destruction, string_compose ("Region %1 destructor @ %2\n", _name, this));
 408         drop_sources ();
 409 }
 410
 411 void
 412 Region::set_playlist (boost::weak_ptr<Playlist> wpl)
 413 {
 414         _playlist = wpl.lock();
 415 }
 416
 417 bool
 418 Region::set_name (const std::string& str)
 419 {
 420         if (_name != str) {
 421                 SessionObject::set_name(str); // EMIT SIGNAL NameChanged()
 422                 assert(_name == str);
 423
 424                 send_change (Properties::name);
 425         }
 426
 427         return true;
 428 }
 429
 430 void
 431 Region::set_length (framecnt_t len, const int32_t sub_num)
 432 {
 433         //cerr << "Region::set_length() len = " << len << endl;
 434         if (locked()) {
 435                 return;
 436         }
 437
 438         if (_length != len && len != 0) {
 439
 440                 /* check that the current _position wouldn't make the new
 441                    length impossible.
 442                 */
 443
 444                 if (max_framepos - len < _position) {
 445                         return;
 446                 }
 447
 448                 if (!verify_length (len)) {
 449                         return;
 450                 }
 451
 452
 453                 set_length_internal (len, sub_num);
 454                 _whole_file = false;
 455                 first_edit ();
 456                 maybe_uncopy ();
 457                 maybe_invalidate_transients ();
 458
 459                 if (!property_changes_suspended()) {
 460                         recompute_at_end ();
 461                 }
 462
 463                 send_change (Properties::length);
 464         }
 465 }
 466
 467 void
 468 Region::set_length_internal (framecnt_t len, const int32_t sub_num)
 469 {
 470         _last_length = _length;
 471         _length = len;
 472 }
 473
 474 void
 475 Region::maybe_uncopy ()
 476 {
 477         /* this does nothing but marked a semantic moment once upon a time */
 478 }
 479
 480 void
 481 Region::first_edit ()
 482 {
 483         boost::shared_ptr<Playlist> pl (playlist());
 484
 485         if (_first_edit != EditChangesNothing && pl) {
 486
 487                 _name = RegionFactory::new_region_name (_name);
 488                 _first_edit = EditChangesNothing;
 489
 490                 send_change (Properties::name);
 491
 492                 RegionFactory::CheckNewRegion (shared_from_this());
 493         }
 494 }
 495
 496 bool
 497 Region::at_natural_position () const
 498 {
 499         boost::shared_ptr<Playlist> pl (playlist());
 500
 501         if (!pl) {
 502                 return false;
 503         }
 504
 505         boost::shared_ptr<Region> whole_file_region = get_parent();
 506
 507         if (whole_file_region) {
 508                 if (_position == whole_file_region->position() + _start) {
 509                         return true;
 510                 }
 511         }
 512
 513         return false;
 514 }
 515
 516 void
 517 Region::move_to_natural_position ()
 518 {
 519         boost::shared_ptr<Playlist> pl (playlist());
 520
 521         if (!pl) {
 522                 return;
 523         }
 524
 525         boost::shared_ptr<Region> whole_file_region = get_parent();
 526
 527         if (whole_file_region) {
 528                 set_position (whole_file_region->position() + _start);
 529         }
 530 }
 531
 532 void
 533 Region::special_set_position (framepos_t pos)
 534 {
 535         /* this is used when creating a whole file region as
 536            a way to store its "natural" or "captured" position.
 537         */
 538
 539         _position = _position;
 540         _position = pos;
 541 }
 542
 543 void
 544 Region::set_position_lock_style (PositionLockStyle ps)
 545 {
 546         if (_position_lock_style != ps) {
 547
 548                 boost::shared_ptr<Playlist> pl (playlist());
 549
 550                 _position_lock_style = ps;
 551
 552                 send_change (Properties::position_lock_style);
 553         }
 554 }
 555
 556 void
 557 Region::update_after_tempo_map_change (bool send)
 558 {
 559         boost::shared_ptr<Playlist> pl (playlist());
 560
 561         if (!pl) {
 562                 return;
 563         }
 564
 565         if (_position_lock_style == AudioTime) {
 566                 /* don't signal as the actual position has not chnged */
 567                 recompute_position_from_lock_style (0);
 568                 return;
 569         }
 570
 571         /* prevent movement before 0 */
 572         const framepos_t pos = max ((framepos_t) 0, _session.tempo_map().frame_at_beat (_beat));
 573         /* we have _beat. update frame position non-musically */
 574         set_position_internal (pos, false, 0);
 575
 576         /* do this even if the position is the same. this helps out
 577            a GUI that has moved its representation already.
 578         */
 579
 580         if (send) {
 581                 send_change (Properties::position);
 582         }
 583 }
 584
 585 void
 586 Region::set_position (framepos_t pos, int32_t sub_num)
 587 {
 588         if (!can_move()) {
 589                 return;
 590         }
 591
 592         if (position_lock_style() == AudioTime) {
 593                 set_position_internal (pos, true, sub_num);
 594         } else {
 595                 if (!_session.loading()) {
 596                         _beat = _session.tempo_map().exact_beat_at_frame (pos, sub_num);
 597                 }
 598
 599                 /* will set pulse accordingly */
 600                 set_position_internal (pos, false, sub_num);
 601         }
 602
 603         /* do this even if the position is the same. this helps out
 604            a GUI that has moved its representation already.
 605         */
 606         PropertyChange p_and_l;
 607
 608         p_and_l.add (Properties::position);
 609         /* Currently length change due to position change is only implemented
 610            for MidiRegion (Region has no length in beats).
 611            Notify a length change regardless (its more efficient for MidiRegions),
 612            and when Region has a _length_beats we will need it here anyway).
 613         */
 614         p_and_l.add (Properties::length);
 615
 616         send_change (p_and_l);
 617
 618 }
 619
 620 /** A gui may need to create a region, then place it in an initial
 621  *  position determined by the user.
 622  *  When this takes place within one gui operation, we have to reset
 623  *  _last_position to prevent an implied move.
 624  */
 625 void
 626 Region::set_initial_position (framepos_t pos)
 627 {
 628         if (!can_move()) {
 629                 return;
 630         }
 631
 632         if (_position != pos) {
 633                 _position = pos;
 634
 635                 /* check that the new _position wouldn't make the current
 636                    length impossible - if so, change the length.
 637
 638                    XXX is this the right thing to do?
 639                 */
 640
 641                 if (max_framepos - _length < _position) {
 642                         _last_length = _length;
 643                         _length = max_framepos - _position;
 644                 }
 645
 646                 recompute_position_from_lock_style (0);
 647                 /* ensure that this move doesn't cause a range move */
 648                 _last_position = _position;
 649         }
 650
 651
 652         /* do this even if the position is the same. this helps out
 653            a GUI that has moved its representation already.
 654         */
 655         send_change (Properties::position);
 656 }
 657
 658 void
 659 Region::set_position_internal (framepos_t pos, bool allow_bbt_recompute, const int32_t sub_num)
 660 {
 661         /* We emit a change of Properties::position even if the position hasn't changed
 662            (see Region::set_position), so we must always set this up so that
 663            e.g. Playlist::notify_region_moved doesn't use an out-of-date last_position.
 664         */
 665         _last_position = _position;
 666
 667         if (_position != pos) {
 668                 _position = pos;
 669
 670                 if (allow_bbt_recompute) {
 671                         recompute_position_from_lock_style (sub_num);
 672                 } else {
 673                         /* MusicTime dictates that we glue to ardour beats. the pulse may have changed.*/
 674                         _quarter_note = _session.tempo_map().quarter_note_at_beat (_beat);
 675                 }
 676
 677                 /* check that the new _position wouldn't make the current
 678                    length impossible - if so, change the length.
 679
 680                    XXX is this the right thing to do?
 681                 */
 682                 if (max_framepos - _length < _position) {
 683                         _last_length = _length;
 684                         _length = max_framepos - _position;
 685                 }
 686         }
 687 }
 688
 689 void
 690 Region::recompute_position_from_lock_style (const int32_t sub_num)
 691 {
 692         _beat = _session.tempo_map().exact_beat_at_frame (_position, sub_num);
 693         _quarter_note = _session.tempo_map().exact_qn_at_frame (_position, sub_num);
 694 }
 695
 696 void
 697 Region::nudge_position (frameoffset_t n)
 698 {
 699         if (locked() || video_locked()) {
 700                 return;
 701         }
 702
 703         if (n == 0) {
 704                 return;
 705         }
 706
 707         framepos_t new_position = _position;
 708
 709         if (n > 0) {
 710                 if (_position > max_framepos - n) {
 711                         new_position = max_framepos;
 712                 } else {
 713                         new_position += n;
 714                 }
 715         } else {
 716                 if (_position < -n) {
 717                         new_position = 0;
 718                 } else {
 719                         new_position += n;
 720                 }
 721         }
 722         /* assumes non-musical nudge */
 723         set_position_internal (new_position, true, 0);
 724
 725         send_change (Properties::position);
 726 }
 727
 728 void
 729 Region::set_ancestral_data (framepos_t s, framecnt_t l, float st, float sh)
 730 {
 731         _ancestral_length = l;
 732         _ancestral_start = s;
 733         _stretch = st;
 734         _shift = sh;
 735 }
 736
 737 void
 738 Region::set_start (framepos_t pos)
 739 {
 740         if (locked() || position_locked() || video_locked()) {
 741                 return;
 742         }
 743         /* This just sets the start, nothing else. It effectively shifts
 744            the contents of the Region within the overall extent of the Source,
 745            without changing the Region's position or length
 746         */
 747
 748         if (_start != pos) {
 749
 750                 if (!verify_start (pos)) {
 751                         return;
 752                 }
 753
 754                 set_start_internal (pos);
 755                 _whole_file = false;
 756                 first_edit ();
 757                 maybe_invalidate_transients ();
 758
 759                 send_change (Properties::start);
 760         }
 761 }
 762
 763 void
 764 Region::move_start (frameoffset_t distance, const int32_t sub_num)
 765 {
 766         if (locked() || position_locked() || video_locked()) {
 767                 return;
 768         }
 769
 770         framepos_t new_start;
 771
 772         if (distance > 0) {
 773
 774                 if (_start > max_framepos - distance) {
 775                         new_start = max_framepos; // makes no sense
 776                 } else {
 777                         new_start = _start + distance;
 778                 }
 779
 780                 if (!verify_start (new_start)) {
 781                         return;
 782                 }
 783
 784         } else if (distance < 0) {
 785
 786                 if (_start < -distance) {
 787                         new_start = 0;
 788                 } else {
 789                         new_start = _start + distance;
 790                 }
 791
 792         } else {
 793                 return;
 794         }
 795
 796         if (new_start == _start) {
 797                 return;
 798         }
 799
 800         set_start_internal (new_start, sub_num);
 801
 802         _whole_file = false;
 803         first_edit ();
 804
 805         send_change (Properties::start);
 806 }
 807
 808 void
 809 Region::trim_front (framepos_t new_position, const int32_t sub_num)
 810 {
 811         modify_front (new_position, false, sub_num);
 812 }
 813
 814 void
 815 Region::cut_front (framepos_t new_position, const int32_t sub_num)
 816 {
 817         modify_front (new_position, true, sub_num);
 818 }
 819
 820 void
 821 Region::cut_end (framepos_t new_endpoint, const int32_t sub_num)
 822 {
 823         modify_end (new_endpoint, true, sub_num);
 824 }
 825
 826 void
 827 Region::modify_front (framepos_t new_position, bool reset_fade, const int32_t sub_num)
 828 {
 829         if (locked()) {
 830                 return;
 831         }
 832
 833         framepos_t end = last_frame();
 834         framepos_t source_zero;
 835
 836         if (_position > _start) {
 837                 source_zero = _position - _start;
 838         } else {
 839                 source_zero = 0; // its actually negative, but this will work for us
 840         }
 841
 842         if (new_position < end) { /* can't trim it zero or negative length */
 843
 844                 framecnt_t newlen = 0;
 845
 846                 if (!can_trim_start_before_source_start ()) {
 847                         /* can't trim it back past where source position zero is located */
 848                         new_position = max (new_position, source_zero);
 849                 }
 850
 851                 if (new_position > _position) {
 852                         newlen = _length - (new_position - _position);
 853                 } else {
 854                         newlen = _length + (_position - new_position);
 855                 }
 856
 857                 trim_to_internal (new_position, newlen, sub_num);
 858
 859                 if (reset_fade) {
 860                         _right_of_split = true;
 861                 }
 862
 863                 if (!property_changes_suspended()) {
 864                         recompute_at_start ();
 865                 }
 866
 867                 maybe_invalidate_transients ();
 868         }
 869 }
 870
 871 void
 872 Region::modify_end (framepos_t new_endpoint, bool reset_fade, const int32_t sub_num)
 873 {
 874         if (locked()) {
 875                 return;
 876         }
 877
 878         if (new_endpoint > _position) {
 879                 trim_to_internal (_position, new_endpoint - _position, sub_num);
 880                 if (reset_fade) {
 881                         _left_of_split = true;
 882                 }
 883                 if (!property_changes_suspended()) {
 884                         recompute_at_end ();
 885                 }
 886         }
 887 }
 888
 889 /** @param new_endpoint New region end point, such that, for example,
 890  *  a region at 0 of length 10 has an endpoint of 9.
 891  */
 892
 893 void
 894 Region::trim_end (framepos_t new_endpoint, const int32_t sub_num)
 895 {
 896         modify_end (new_endpoint, false, sub_num);
 897 }
 898
 899 void
 900 Region::trim_to (framepos_t position, framecnt_t length, const int32_t sub_num)
 901 {
 902         if (locked()) {
 903                 return;
 904         }
 905
 906         trim_to_internal (position, length, sub_num);
 907
 908         if (!property_changes_suspended()) {
 909                 recompute_at_start ();
 910                 recompute_at_end ();
 911         }
 912 }
 913
 914 void
 915 Region::trim_to_internal (framepos_t position, framecnt_t length, const int32_t sub_num)
 916 {
 917         framepos_t new_start;
 918
 919         if (locked()) {
 920                 return;
 921         }
 922
 923         frameoffset_t const start_shift = position - _position;
 924
 925         if (start_shift > 0) {
 926
 927                 if (_start > max_framepos - start_shift) {
 928                         new_start = max_framepos;
 929                 } else {
 930                         new_start = _start + start_shift;
 931                 }
 932
 933         } else if (start_shift < 0) {
 934
 935                 if (_start < -start_shift && !can_trim_start_before_source_start ()) {
 936                         new_start = 0;
 937                 } else {
 938                         new_start = _start + start_shift;
 939                 }
 940
 941         } else {
 942                 new_start = _start;
 943         }
 944
 945         if (!verify_start_and_length (new_start, length)) {
 946                 return;
 947         }
 948
 949         PropertyChange what_changed;
 950
 951         if (_start != new_start) {
 952                 set_start_internal (new_start, sub_num);
 953                 what_changed.add (Properties::start);
 954         }
 955
 956
 957         /* Set position before length, otherwise for MIDI regions this bad thing happens:
 958          * 1. we call set_length_internal; length in beats is computed using the region's current
 959          *    (soon-to-be old) position
 960          * 2. we call set_position_internal; position is set and length in frames re-computed using
 961          *    length in beats from (1) but at the new position, which is wrong if the region
 962          *    straddles a tempo/meter change.
 963          */
 964
 965         if (_position != position) {
 966                 if (!property_changes_suspended()) {
 967                         _last_position = _position;
 968                 }
 969                 set_position_internal (position, true, sub_num);
 970                 what_changed.add (Properties::position);
 971         }
 972
 973         if (_length != length) {
 974                 if (!property_changes_suspended()) {
 975                         _last_length = _length;
 976                 }
 977                 set_length_internal (length, sub_num);
 978                 what_changed.add (Properties::length);
 979         }
 980
 981         _whole_file = false;
 982
 983         PropertyChange start_and_length;
 984
 985         start_and_length.add (Properties::start);
 986         start_and_length.add (Properties::length);
 987
 988         if (what_changed.contains (start_and_length)) {
 989                 first_edit ();
 990         }
 991
 992         if (!what_changed.empty()) {
 993                 send_change (what_changed);
 994         }
 995 }
 996
 997 void
 998 Region::set_hidden (bool yn)
 999 {
1000         if (hidden() != yn) {
1001                 _hidden = yn;
1002                 send_change (Properties::hidden);
1003         }
1004 }
1005
1006 void
1007 Region::set_whole_file (bool yn)
1008 {
1009         _whole_file = yn;
1010         /* no change signal */
1011 }
1012
1013 void
1014 Region::set_automatic (bool yn)
1015 {
1016         _automatic = yn;
1017         /* no change signal */
1018 }
1019
1020 void
1021 Region::set_muted (bool yn)
1022 {
1023         if (muted() != yn) {
1024                 _muted = yn;
1025                 send_change (Properties::muted);
1026         }
1027 }
1028
1029 void
1030 Region::set_opaque (bool yn)
1031 {
1032         if (opaque() != yn) {
1033                 _opaque = yn;
1034                 send_change (Properties::opaque);
1035         }
1036 }
1037
1038 void
1039 Region::set_locked (bool yn)
1040 {
1041         if (locked() != yn) {
1042                 _locked = yn;
1043                 send_change (Properties::locked);
1044         }
1045 }
1046
1047 void
1048 Region::set_video_locked (bool yn)
1049 {
1050         if (video_locked() != yn) {
1051                 _video_locked = yn;
1052                 send_change (Properties::video_locked);
1053         }
1054 }
1055
1056 void
1057 Region::set_position_locked (bool yn)
1058 {
1059         if (position_locked() != yn) {
1060                 _position_locked = yn;
1061                 send_change (Properties::locked);
1062         }
1063 }
1064
1065 /** Set the region's sync point.
1066  *  @param absolute_pos Session time.
1067  */
1068 void
1069 Region::set_sync_position (framepos_t absolute_pos)
1070 {
1071         /* position within our file */
1072         framepos_t const file_pos = _start + (absolute_pos - _position);
1073
1074         if (file_pos != _sync_position) {
1075                 _sync_marked = true;
1076                 _sync_position = file_pos;
1077                 if (!property_changes_suspended()) {
1078                         maybe_uncopy ();
1079                 }
1080
1081                 send_change (Properties::sync_position);
1082         }
1083 }
1084
1085 void
1086 Region::clear_sync_position ()
1087 {
1088         if (sync_marked()) {
1089                 _sync_marked = false;
1090                 if (!property_changes_suspended()) {
1091                         maybe_uncopy ();
1092                 }
1093
1094                 send_change (Properties::sync_position);
1095         }
1096 }
1097
1098 /* @return the sync point relative the first frame of the region */
1099 frameoffset_t
1100 Region::sync_offset (int& dir) const
1101 {
1102         if (sync_marked()) {
1103                 if (_sync_position > _start) {
1104                         dir = 1;
1105                         return _sync_position - _start;
1106                 } else {
1107                         dir = -1;
1108                         return _start - _sync_position;
1109                 }
1110         } else {
1111                 dir = 0;
1112                 return 0;
1113         }
1114 }
1115
1116 framepos_t
1117 Region::adjust_to_sync (framepos_t pos) const
1118 {
1119         int sync_dir;
1120         frameoffset_t offset = sync_offset (sync_dir);
1121
1122         // cerr << "adjusting pos = " << pos << " to sync at " << _sync_position << " offset = " << offset << " with dir = " << sync_dir << endl;
1123
1124         if (sync_dir > 0) {
1125                 if (pos > offset) {
1126                         pos -= offset;
1127                 } else {
1128                         pos = 0;
1129                 }
1130         } else {
1131                 if (max_framepos - pos > offset) {
1132                         pos += offset;
1133                 }
1134         }
1135
1136         return pos;
1137 }
1138
1139 /** @return Sync position in session time */
1140 framepos_t
1141 Region::sync_position() const
1142 {
1143         if (sync_marked()) {
1144                 return _position - _start + _sync_position;
1145         } else {
1146                 /* if sync has not been marked, use the start of the region */
1147                 return _position;
1148         }
1149 }
1150
1151 void
1152 Region::raise ()
1153 {
1154         boost::shared_ptr<Playlist> pl (playlist());
1155         if (pl) {
1156                 pl->raise_region (shared_from_this ());
1157         }
1158 }
1159
1160 void
1161 Region::lower ()
1162 {
1163         boost::shared_ptr<Playlist> pl (playlist());
1164         if (pl) {
1165                 pl->lower_region (shared_from_this ());
1166         }
1167 }
1168
1169
1170 void
1171 Region::raise_to_top ()
1172 {
1173         boost::shared_ptr<Playlist> pl (playlist());
1174         if (pl) {
1175                 pl->raise_region_to_top (shared_from_this());
1176         }
1177 }
1178
1179 void
1180 Region::lower_to_bottom ()
1181 {
1182         boost::shared_ptr<Playlist> pl (playlist());
1183         if (pl) {
1184                 pl->lower_region_to_bottom (shared_from_this());
1185         }
1186 }
1187
1188 void
1189 Region::set_layer (layer_t l)
1190 {
1191         _layer = l;
1192 }
1193
1194 XMLNode&
1195 Region::state ()
1196 {
1197         XMLNode *node = new XMLNode ("Region");
1198         char buf[64];
1199         char buf2[64];
1200         LocaleGuard lg;
1201         const char* fe = NULL;
1202
1203         /* custom version of 'add_properties (*node);'
1204          * skip values that have have dedicated save functions
1205          * in AudioRegion::state()
1206          */
1207         for (OwnedPropertyList::iterator i = _properties->begin(); i != _properties->end(); ++i) {
1208                 if (!strcmp(i->second->property_name(), (const char*)"Envelope")) continue;
1209                 if (!strcmp(i->second->property_name(), (const char*)"FadeIn")) continue;
1210                 if (!strcmp(i->second->property_name(), (const char*)"FadeOut")) continue;
1211                 if (!strcmp(i->second->property_name(), (const char*)"InverseFadeIn")) continue;
1212                 if (!strcmp(i->second->property_name(), (const char*)"InverseFadeOut")) continue;
1213                 i->second->get_value (*node);
1214         }
1215
1216         id().print (buf, sizeof (buf));
1217         node->add_property ("id", buf);
1218         node->add_property ("type", _type.to_string());
1219
1220         switch (_first_edit) {
1221         case EditChangesNothing:
1222                 fe = X_("nothing");
1223                 break;
1224         case EditChangesName:
1225                 fe = X_("name");
1226                 break;
1227         case EditChangesID:
1228                 fe = X_("id");
1229                 break;
1230         default: /* should be unreachable but makes g++ happy */
1231                 fe = X_("nothing");
1232                 break;
1233         }
1234
1235         node->add_property ("first-edit", fe);
1236
1237         /* note: flags are stored by derived classes */
1238
1239         for (uint32_t n=0; n < _sources.size(); ++n) {
1240                 snprintf (buf2, sizeof(buf2), "source-%d", n);
1241                 _sources[n]->id().print (buf, sizeof(buf));
1242                 node->add_property (buf2, buf);
1243         }
1244
1245         for (uint32_t n=0; n < _master_sources.size(); ++n) {
1246                 snprintf (buf2, sizeof(buf2), "master-source-%d", n);
1247                 _master_sources[n]->id().print (buf, sizeof (buf));
1248                 node->add_property (buf2, buf);
1249         }
1250
1251         /* Only store nested sources for the whole-file region that acts
1252            as the parent/root of all regions using it.
1253         */
1254
1255         if (_whole_file && max_source_level() > 0) {
1256
1257                 XMLNode* nested_node = new XMLNode (X_("NestedSource"));
1258
1259                 /* region is compound - get its playlist and
1260                    store that before we list the region that
1261                    needs it ...
1262                 */
1263
1264                 for (SourceList::const_iterator s = _sources.begin(); s != _sources.end(); ++s) {
1265                         nested_node->add_child_nocopy ((*s)->get_state ());
1266                 }
1267
1268                 if (nested_node) {
1269                         node->add_child_nocopy (*nested_node);
1270                 }
1271         }
1272
1273         if (_extra_xml) {
1274                 node->add_child_copy (*_extra_xml);
1275         }
1276
1277         return *node;
1278 }
1279
1280 XMLNode&
1281 Region::get_state ()
1282 {
1283         return state ();
1284 }
1285
1286 int
1287 Region::set_state (const XMLNode& node, int version)
1288 {
1289         PropertyChange what_changed;
1290         return _set_state (node, version, what_changed, true);
1291 }
1292
1293 int
1294 Region::_set_state (const XMLNode& node, int /*version*/, PropertyChange& what_changed, bool send)
1295 {
1296         XMLProperty const * prop;
1297         Timecode::BBT_Time bbt_time;
1298
1299         Stateful::save_extra_xml (node);
1300
1301         what_changed = set_values (node);
1302
1303         set_id (node);
1304
1305         if (_position_lock_style == MusicTime) {
1306                 if ((prop = node.property ("bbt-position")) != 0) {
1307                         if (sscanf (prop->value().c_str(), "%d|%d|%d",
1308                                     &bbt_time.bars,
1309                                     &bbt_time.beats,
1310                                     &bbt_time.ticks) != 3) {
1311                                 _position_lock_style = AudioTime;
1312                                 _beat = _session.tempo_map().beat_at_frame (_position);
1313                         } else {
1314                                 _beat = _session.tempo_map().beat_at_bbt (bbt_time);
1315                         }
1316                         /* no position property change for legacy Property, so we do this here */
1317                         _quarter_note = _session.tempo_map().quarter_note_at_beat (_beat);
1318                 }
1319         }
1320
1321         /* fix problems with old sessions corrupted by impossible
1322            values for _stretch or _shift
1323         */
1324         if (_stretch == 0.0f) {
1325                 _stretch = 1.0f;
1326         }
1327
1328         if (_shift == 0.0f) {
1329                 _shift = 1.0f;
1330         }
1331
1332         if (send) {
1333                 send_change (what_changed);
1334         }
1335
1336         /* Quick fix for 2.x sessions when region is muted */
1337         if ((prop = node.property (X_("flags")))) {
1338                 if (string::npos != prop->value().find("Muted")){
1339                         set_muted (true);
1340                 }
1341         }
1342
1343         // saved property is invalid, region-transients are not saved
1344         if (_user_transients.size() == 0){
1345                 _valid_transients = false;
1346         }
1347
1348         return 0;
1349 }
1350
1351 void
1352 Region::suspend_property_changes ()
1353 {
1354         Stateful::suspend_property_changes ();
1355         _last_length = _length;
1356         _last_position = _position;
1357 }
1358
1359 void
1360 Region::mid_thaw (const PropertyChange& what_changed)
1361 {
1362         if (what_changed.contains (Properties::length)) {
1363                 if (what_changed.contains (Properties::position)) {
1364                         recompute_at_start ();
1365                 }
1366                 recompute_at_end ();
1367         }
1368 }
1369
1370 void
1371 Region::send_change (const PropertyChange& what_changed)
1372 {
1373         if (what_changed.empty()) {
1374                 return;
1375         }
1376
1377         Stateful::send_change (what_changed);
1378
1379         if (!Stateful::property_changes_suspended()) {
1380
1381                 /* Try and send a shared_pointer unless this is part of the constructor.
1382                    If so, do nothing.
1383                 */
1384
1385                 try {
1386                         boost::shared_ptr<Region> rptr = shared_from_this();
1387                         RegionPropertyChanged (rptr, what_changed);
1388                 } catch (...) {
1389                         /* no shared_ptr available, relax; */
1390                 }
1391         }
1392 }
1393
1394 bool
1395 Region::overlap_equivalent (boost::shared_ptr<const Region> other) const
1396 {
1397         return coverage (other->first_frame(), other->last_frame()) != Evoral::OverlapNone;
1398 }
1399
1400 bool
1401 Region::equivalent (boost::shared_ptr<const Region> other) const
1402 {
1403         return _start == other->_start &&
1404                 _position == other->_position &&
1405                 _length == other->_length;
1406 }
1407
1408 bool
1409 Region::size_equivalent (boost::shared_ptr<const Region> other) const
1410 {
1411         return _start == other->_start &&
1412                 _length == other->_length;
1413 }
1414
1415 bool
1416 Region::region_list_equivalent (boost::shared_ptr<const Region> other) const
1417 {
1418         return size_equivalent (other) && source_equivalent (other) && _name == other->_name;
1419 }
1420
1421 void
1422 Region::source_deleted (boost::weak_ptr<Source>)
1423 {
1424         drop_sources ();
1425
1426         if (!_session.deletion_in_progress()) {
1427                 /* this is a very special case: at least one of the region's
1428                    sources has bee deleted, so invalidate all references to
1429                    ourselves. Do NOT do this during session deletion, because
1430                    then we run the risk that this will actually result
1431                    in this object being deleted (as refcnt goes to zero)
1432                    while emitting DropReferences.
1433                 */
1434
1435                 drop_references ();
1436         }
1437 }
1438
1439 vector<string>
1440 Region::master_source_names ()
1441 {
1442         SourceList::iterator i;
1443
1444         vector<string> names;
1445         for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
1446                 names.push_back((*i)->name());
1447         }
1448
1449         return names;
1450 }
1451
1452 void
1453 Region::set_master_sources (const SourceList& srcs)
1454 {
1455         for (SourceList::const_iterator i = _master_sources.begin (); i != _master_sources.end(); ++i) {
1456                 (*i)->dec_use_count ();
1457         }
1458
1459         _master_sources = srcs;
1460         assert (_sources.size() == _master_sources.size());
1461
1462         for (SourceList::const_iterator i = _master_sources.begin (); i != _master_sources.end(); ++i) {
1463                 (*i)->inc_use_count ();
1464         }
1465 }
1466
1467 bool
1468 Region::source_equivalent (boost::shared_ptr<const Region> other) const
1469 {
1470         if (!other)
1471                 return false;
1472
1473         if ((_sources.size() != other->_sources.size()) ||
1474             (_master_sources.size() != other->_master_sources.size())) {
1475                 return false;
1476         }
1477
1478         SourceList::const_iterator i;
1479         SourceList::const_iterator io;
1480
1481         for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
1482                 if ((*i)->id() != (*io)->id()) {
1483                         return false;
1484                 }
1485         }
1486
1487         for (i = _master_sources.begin(), io = other->_master_sources.begin(); i != _master_sources.end() && io != other->_master_sources.end(); ++i, ++io) {
1488                 if ((*i)->id() != (*io)->id()) {
1489                         return false;
1490                 }
1491         }
1492
1493         return true;
1494 }
1495
1496 bool
1497 Region::any_source_equivalent (boost::shared_ptr<const Region> other) const
1498 {
1499         if (!other) {
1500                 return false;
1501         }
1502
1503         SourceList::const_iterator i;
1504         SourceList::const_iterator io;
1505
1506         for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
1507                 if ((*i)->id() == (*io)->id()) {
1508                         return true;
1509                 }
1510         }
1511
1512         return false;
1513 }
1514
1515 std::string
1516 Region::source_string () const
1517 {
1518         //string res = itos(_sources.size());
1519
1520         stringstream res;
1521         res << _sources.size() << ":";
1522
1523         SourceList::const_iterator i;
1524
1525         for (i = _sources.begin(); i != _sources.end(); ++i) {
1526                 res << (*i)->id() << ":";
1527         }
1528
1529         for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
1530                 res << (*i)->id() << ":";
1531         }
1532
1533         return res.str();
1534 }
1535
1536 void
1537 Region::deep_sources (std::set<boost::shared_ptr<Source> > & sources) const
1538 {
1539         for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
1540
1541                 boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
1542
1543                 if (ps) {
1544                         if (sources.find (ps) == sources.end()) {
1545                                 /* (Playlist)Source not currently in
1546                                    accumulating set, so recurse.
1547                                 */
1548                                 ps->playlist()->deep_sources (sources);
1549                         }
1550                 }
1551
1552                 /* add this source */
1553                 sources.insert (*i);
1554         }
1555
1556         for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
1557
1558                 boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
1559
1560                 if (ps) {
1561                         if (sources.find (ps) == sources.end()) {
1562                                 /* (Playlist)Source not currently in
1563                                    accumulating set, so recurse.
1564                                 */
1565                                 ps->playlist()->deep_sources (sources);
1566                         }
1567                 }
1568
1569                 /* add this source */
1570                 sources.insert (*i);
1571         }
1572 }
1573
1574 bool
1575 Region::uses_source (boost::shared_ptr<const Source> source, bool shallow) const
1576 {
1577         for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
1578                 if (*i == source) {
1579                         return true;
1580                 }
1581
1582                 if (!shallow) {
1583                         boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
1584
1585                         if (ps) {
1586                                 if (ps->playlist()->uses_source (source)) {
1587                                         return true;
1588                                 }
1589                         }
1590                 }
1591         }
1592
1593         for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
1594                 if (*i == source) {
1595                         return true;
1596                 }
1597
1598                 if (!shallow) {
1599                         boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
1600
1601                         if (ps) {
1602                                 if (ps->playlist()->uses_source (source)) {
1603                                         return true;
1604                                 }
1605                         }
1606                 }
1607         }
1608
1609         return false;
1610 }
1611
1612
1613 framecnt_t
1614 Region::source_length(uint32_t n) const
1615 {
1616         assert (n < _sources.size());
1617         return _sources[n]->length (_position - _start);
1618 }
1619
1620 bool
1621 Region::verify_length (framecnt_t& len)
1622 {
1623         if (source() && (source()->destructive() || source()->length_mutable())) {
1624                 return true;
1625         }
1626
1627         framecnt_t maxlen = 0;
1628
1629         for (uint32_t n = 0; n < _sources.size(); ++n) {
1630                 maxlen = max (maxlen, source_length(n) - _start);
1631         }
1632
1633         len = min (len, maxlen);
1634
1635         return true;
1636 }
1637
1638 bool
1639 Region::verify_start_and_length (framepos_t new_start, framecnt_t& new_length)
1640 {
1641         if (source() && (source()->destructive() || source()->length_mutable())) {
1642                 return true;
1643         }
1644
1645         framecnt_t maxlen = 0;
1646
1647         for (uint32_t n = 0; n < _sources.size(); ++n) {
1648                 maxlen = max (maxlen, source_length(n) - new_start);
1649         }
1650
1651         new_length = min (new_length, maxlen);
1652
1653         return true;
1654 }
1655
1656 bool
1657 Region::verify_start (framepos_t pos)
1658 {
1659         if (source() && (source()->destructive() || source()->length_mutable())) {
1660                 return true;
1661         }
1662
1663         for (uint32_t n = 0; n < _sources.size(); ++n) {
1664                 if (pos > source_length(n) - _length) {
1665                         return false;
1666                 }
1667         }
1668         return true;
1669 }
1670
1671 bool
1672 Region::verify_start_mutable (framepos_t& new_start)
1673 {
1674         if (source() && (source()->destructive() || source()->length_mutable())) {
1675                 return true;
1676         }
1677
1678         for (uint32_t n = 0; n < _sources.size(); ++n) {
1679                 if (new_start > source_length(n) - _length) {
1680                         new_start = source_length(n) - _length;
1681                 }
1682         }
1683         return true;
1684 }
1685
1686 boost::shared_ptr<Region>
1687 Region::get_parent() const
1688 {
1689         boost::shared_ptr<Playlist> pl (playlist());
1690
1691         if (pl) {
1692                 boost::shared_ptr<Region> r;
1693                 boost::shared_ptr<Region const> grrr2 = boost::dynamic_pointer_cast<Region const> (shared_from_this());
1694
1695                 if (grrr2 && (r = _session.find_whole_file_parent (grrr2))) {
1696                         return boost::static_pointer_cast<Region> (r);
1697                 }
1698         }
1699
1700         return boost::shared_ptr<Region>();
1701 }
1702
1703 int
1704 Region::apply (Filter& filter, Progress* progress)
1705 {
1706         return filter.run (shared_from_this(), progress);
1707 }
1708
1709
1710 void
1711 Region::maybe_invalidate_transients ()
1712 {
1713         bool changed = !_onsets.empty();
1714         _onsets.clear ();
1715
1716         if (_valid_transients || changed) {
1717                 send_change (PropertyChange (Properties::valid_transients));
1718                 return;
1719         }
1720 }
1721
1722 void
1723 Region::transients (AnalysisFeatureList& afl)
1724 {
1725         int cnt = afl.empty() ? 0 : 1;
1726
1727         Region::merge_features (afl, _onsets, _position);
1728         Region::merge_features (afl, _user_transients, _position + _transient_user_start - _start);
1729         if (!_onsets.empty ()) {
1730                 ++cnt;
1731         }
1732         if (!_user_transients.empty ()) {
1733                 ++cnt;
1734         }
1735         if (cnt > 1 ) {
1736                 afl.sort ();
1737                 // remove exact duplicates
1738                 TransientDetector::cleanup_transients (afl, _session.frame_rate(), 0);
1739         }
1740 }
1741
1742 bool
1743 Region::has_transients () const
1744 {
1745         if (!_user_transients.empty ()) {
1746                 assert (_valid_transients);
1747                 return true;
1748         }
1749         if (!_onsets.empty ()) {
1750                 return true;
1751         }
1752         return false;
1753 }
1754
1755 void
1756 Region::merge_features (AnalysisFeatureList& result, const AnalysisFeatureList& src, const frameoffset_t off) const
1757 {
1758         for (AnalysisFeatureList::const_iterator x = src.begin(); x != src.end(); ++x) {
1759                 const frameoffset_t p = (*x) + off;
1760                 if (p < first_frame() || p > last_frame()) {
1761                         continue;
1762                 }
1763                 result.push_back (p);
1764         }
1765 }
1766
1767 void
1768 Region::drop_sources ()
1769 {
1770         for (SourceList::const_iterator i = _sources.begin (); i != _sources.end(); ++i) {
1771                 (*i)->dec_use_count ();
1772         }
1773
1774         _sources.clear ();
1775
1776         for (SourceList::const_iterator i = _master_sources.begin (); i != _master_sources.end(); ++i) {
1777                 (*i)->dec_use_count ();
1778         }
1779
1780         _master_sources.clear ();
1781 }
1782
1783 void
1784 Region::use_sources (SourceList const & s)
1785 {
1786         set<boost::shared_ptr<Source> > unique_srcs;
1787
1788         for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
1789
1790                 _sources.push_back (*i);
1791                 (*i)->inc_use_count ();
1792                 _master_sources.push_back (*i);
1793                 (*i)->inc_use_count ();
1794
1795                 /* connect only once to DropReferences, even if sources are replicated
1796                  */
1797
1798                 if (unique_srcs.find (*i) == unique_srcs.end ()) {
1799                         unique_srcs.insert (*i);
1800                         (*i)->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
1801                 }
1802         }
1803 }
1804
1805 Trimmable::CanTrim
1806 Region::can_trim () const
1807 {
1808         CanTrim ct = CanTrim (0);
1809
1810         if (locked()) {
1811                 return ct;
1812         }
1813
1814         /* if not locked, we can always move the front later, and the end earlier
1815          */
1816
1817         ct = CanTrim (ct | FrontTrimLater | EndTrimEarlier);
1818
1819         if (start() != 0 || can_trim_start_before_source_start ()) {
1820                 ct = CanTrim (ct | FrontTrimEarlier);
1821         }
1822
1823         if (!_sources.empty()) {
1824                 if ((start() + length()) < _sources.front()->length (0)) {
1825                         ct = CanTrim (ct | EndTrimLater);
1826                 }
1827         }
1828
1829         return ct;
1830 }
1831
1832 uint32_t
1833 Region::max_source_level () const
1834 {
1835         uint32_t lvl = 0;
1836
1837         for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
1838                 lvl = max (lvl, (*i)->level());
1839         }
1840
1841         return lvl;
1842 }
1843
1844 bool
1845 Region::is_compound () const
1846 {
1847         return max_source_level() > 0;
1848 }
1849
1850 void
1851 Region::post_set (const PropertyChange& pc)
1852 {
1853         if (pc.contains (Properties::position)) {
1854                 _quarter_note = _session.tempo_map().quarter_note_at_beat (_beat);
1855         }
1856 }
1857
1858 void
1859 Region::set_start_internal (framecnt_t s, const int32_t sub_num)
1860 {
1861         _start = s;
1862 }
1863
1864 framepos_t
1865 Region::earliest_possible_position () const
1866 {
1867         if (_start > _position) {
1868                 return 0;
1869         } else {
1870                 return _position - _start;
1871         }
1872 }
1873
1874 framecnt_t
1875 Region::latest_possible_frame () const
1876 {
1877         framecnt_t minlen = max_framecnt;
1878
1879         for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
1880                 /* non-audio regions have a length that may vary based on their
1881                  * position, so we have to pass it in the call.
1882                  */
1883                 minlen = min (minlen, (*i)->length (_position));
1884         }
1885
1886         /* the latest possible last frame is determined by the current
1887          * position, plus the shortest source extent past _start.
1888          */
1889
1890         return _position + (minlen - _start) - 1;
1891 }