libs/ardour/audioregion.cc

   1 /*
   2     Copyright (C) 2000-2006 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     $Id$
  19 */
  20
  21 #include <cmath>
  22 #include <climits>
  23 #include <cfloat>
  24
  25 #include <set>
  26
  27 #include <sigc++/bind.h>
  28 #include <sigc++/class_slot.h>
  29
  30 #include <glibmm/thread.h>
  31
  32 #include <pbd/basename.h>
  33 #include <pbd/xml++.h>
  34
  35 #include <ardour/audioregion.h>
  36 #include <ardour/session.h>
  37 #include <ardour/gain.h>
  38 #include <ardour/dB.h>
  39 #include <ardour/playlist.h>
  40 #include <ardour/audiofilter.h>
  41 #include <ardour/audiosource.h>
  42
  43 #include "i18n.h"
  44 #include <locale.h>
  45
  46 using namespace std;
  47 using namespace ARDOUR;
  48
  49 /* a Session will reset these to its chosen defaults by calling AudioRegion::set_default_fade() */
  50
  51 Change AudioRegion::FadeInChanged         = ARDOUR::new_change();
  52 Change AudioRegion::FadeOutChanged        = ARDOUR::new_change();
  53 Change AudioRegion::FadeInActiveChanged   = ARDOUR::new_change();
  54 Change AudioRegion::FadeOutActiveChanged  = ARDOUR::new_change();
  55 Change AudioRegion::EnvelopeActiveChanged = ARDOUR::new_change();
  56 Change AudioRegion::ScaleAmplitudeChanged = ARDOUR::new_change();
  57 Change AudioRegion::EnvelopeChanged       = ARDOUR::new_change();
  58
  59 AudioRegionState::AudioRegionState (string why)
  60         : RegionState (why)
  61         , _fade_in (0.0, 2.0, 1.0, false)
  62         , _fade_out (0.0, 2.0, 1.0, false)
  63         , _envelope (0.0, 2.0, 1.0, false)
  64 {
  65 }
  66
  67 /** Basic AudioRegion constructor (one channel) */
  68 AudioRegion::AudioRegion (AudioSource& src, jack_nframes_t start, jack_nframes_t length, bool announce)
  69         : Region (src, start, length, PBD::basename_nosuffix(src.name()), DataType::AUDIO, 0,  Region::Flag(Region::DefaultFlags|Region::External))
  70         , _fade_in (0.0, 2.0, 1.0, false)
  71         , _fade_out (0.0, 2.0, 1.0, false)
  72         , _envelope (0.0, 2.0, 1.0, false)
  73 {
  74         _scale_amplitude = 1.0;
  75
  76         set_default_fades ();
  77         set_default_envelope ();
  78
  79         save_state ("initial state");
  80
  81         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
  82
  83         if (announce) {
  84                  CheckNewRegion (this); /* EMIT SIGNAL */
  85         }
  86 }
  87
  88 /* Basic AudioRegion constructor (one channel) */
  89 AudioRegion::AudioRegion (AudioSource& src, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags, bool announce)
  90         : Region (src, start, length, name, DataType::AUDIO, layer, flags)
  91         , _fade_in (0.0, 2.0, 1.0, false)
  92         , _fade_out (0.0, 2.0, 1.0, false)
  93         , _envelope (0.0, 2.0, 1.0, false)
  94 {
  95         _scale_amplitude = 1.0;
  96
  97         set_default_fades ();
  98         set_default_envelope ();
  99         save_state ("initial state");
 100
 101         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 102
 103         if (announce) {
 104                  CheckNewRegion (this); /* EMIT SIGNAL */
 105         }
 106 }
 107
 108 /* Basic AudioRegion constructor (many channels) */
 109 AudioRegion::AudioRegion (SourceList& srcs, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags, bool announce)
 110         : Region (srcs, start, length, name, DataType::AUDIO, layer, flags)
 111         , _fade_in (0.0, 2.0, 1.0, false)
 112         , _fade_out (0.0, 2.0, 1.0, false)
 113         , _envelope (0.0, 2.0, 1.0, false)
 114 {
 115         _scale_amplitude = 1.0;
 116
 117         set_default_fades ();
 118         set_default_envelope ();
 119         save_state ("initial state");
 120
 121         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 122
 123         if (announce) {
 124                  CheckNewRegion (this); /* EMIT SIGNAL */
 125         }
 126 }
 127
 128
 129 /** Create a new AudioRegion, that is part of an existing one */
 130 AudioRegion::AudioRegion (const AudioRegion& other, jack_nframes_t offset, jack_nframes_t length, const string& name, layer_t layer, Flag flags, bool announce)
 131         : Region (other, offset, length, name, layer, flags)
 132         , _fade_in (other._fade_in)
 133         , _fade_out (other._fade_out)
 134         , _envelope (other._envelope, (double) offset, (double) offset + length)
 135 {
 136         /* return to default fades if the existing ones are too long */
 137         _fade_in_disabled = 0;
 138         _fade_out_disabled = 0;
 139
 140
 141         if (_flags & LeftOfSplit) {
 142                 if (_fade_in.back()->when >= _length) {
 143                         set_default_fade_in ();
 144                 } else {
 145                         _fade_in_disabled = other._fade_in_disabled;
 146                 }
 147                 set_default_fade_out ();
 148                 _flags = Flag (_flags & ~Region::LeftOfSplit);
 149         }
 150
 151         if (_flags & RightOfSplit) {
 152                 if (_fade_out.back()->when >= _length) {
 153                         set_default_fade_out ();
 154                 } else {
 155                         _fade_out_disabled = other._fade_out_disabled;
 156                 }
 157                 set_default_fade_in ();
 158                 _flags = Flag (_flags & ~Region::RightOfSplit);
 159         }
 160
 161         _scale_amplitude = other._scale_amplitude;
 162
 163         save_state ("initial state");
 164
 165         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 166
 167         if (announce) {
 168                 CheckNewRegion (this); /* EMIT SIGNAL */
 169         }
 170 }
 171
 172 AudioRegion::AudioRegion (const AudioRegion &other)
 173         : Region (other)
 174         , _fade_in (other._fade_in)
 175         , _fade_out (other._fade_out)
 176         , _envelope (other._envelope)
 177 {
 178         _scale_amplitude = other._scale_amplitude;
 179         _envelope = other._envelope;
 180
 181         _fade_in_disabled = 0;
 182         _fade_out_disabled = 0;
 183
 184         save_state ("initial state");
 185
 186         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 187
 188         /* NOTE: no CheckNewRegion signal emitted here. This is the copy constructor */
 189 }
 190
 191 AudioRegion::AudioRegion (AudioSource& src, const XMLNode& node)
 192         : Region (src, node)
 193         , _fade_in (0.0, 2.0, 1.0, false)
 194         , _fade_out (0.0, 2.0, 1.0, false)
 195         , _envelope (0.0, 2.0, 1.0, false)
 196 {
 197         set_default_fades ();
 198
 199         if (set_state (node)) {
 200                 throw failed_constructor();
 201         }
 202
 203         save_state ("initial state");
 204
 205         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 206
 207         assert(_type == DataType::AUDIO);
 208
 209         CheckNewRegion (this); /* EMIT SIGNAL */
 210 }
 211
 212 AudioRegion::AudioRegion (SourceList& srcs, const XMLNode& node)
 213         : Region (srcs, node),
 214           _fade_in (0.0, 2.0, 1.0, false),
 215           _fade_out (0.0, 2.0, 1.0, false),
 216           _envelope (0.0, 2.0, 1.0, false)
 217 {
 218         set_default_fades ();
 219         _scale_amplitude = 1.0;
 220
 221         if (set_state (node)) {
 222                 throw failed_constructor();
 223         }
 224
 225         save_state ("initial state");
 226
 227         _envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
 228
 229         assert(_type == DataType::AUDIO);
 230
 231         CheckNewRegion (this); /* EMIT SIGNAL */
 232 }
 233
 234 AudioRegion::~AudioRegion ()
 235 {
 236         GoingAway (this);
 237 }
 238
 239 StateManager::State*
 240 AudioRegion::state_factory (std::string why) const
 241 {
 242         AudioRegionState* state = new AudioRegionState (why);
 243
 244         Region::store_state (*state);
 245
 246         state->_fade_in = _fade_in;
 247         state->_fade_out = _fade_out;
 248         state->_envelope = _envelope;
 249         state->_scale_amplitude = _scale_amplitude;
 250         state->_fade_in_disabled = _fade_in_disabled;
 251         state->_fade_out_disabled = _fade_out_disabled;
 252
 253         return state;
 254 }
 255
 256 Change
 257 AudioRegion::restore_state (StateManager::State& sstate)
 258 {
 259         AudioRegionState* state = dynamic_cast<AudioRegionState*> (&sstate);
 260
 261         Change what_changed = Region::restore_and_return_flags (*state);
 262
 263         if (_flags != Flag (state->_flags)) {
 264
 265                 uint32_t old_flags = _flags;
 266
 267                 _flags = Flag (state->_flags);
 268
 269                 if ((old_flags ^ state->_flags) & EnvelopeActive) {
 270                         what_changed = Change (what_changed|EnvelopeActiveChanged);
 271                 }
 272         }
 273
 274         if (!(_fade_in == state->_fade_in)) {
 275                 _fade_in = state->_fade_in;
 276                 what_changed = Change (what_changed|FadeInChanged);
 277         }
 278
 279         if (!(_fade_out == state->_fade_out)) {
 280                 _fade_out = state->_fade_out;
 281                 what_changed = Change (what_changed|FadeOutChanged);
 282         }
 283
 284         if (_scale_amplitude != state->_scale_amplitude) {
 285                 _scale_amplitude = state->_scale_amplitude;
 286                 what_changed = Change (what_changed|ScaleAmplitudeChanged);
 287         }
 288
 289         if (_fade_in_disabled != state->_fade_in_disabled) {
 290                 if (_fade_in_disabled == 0 && state->_fade_in_disabled) {
 291                         set_fade_in_active (false);
 292                 } if (_fade_in_disabled && state->_fade_in_disabled == 0) {
 293                         set_fade_in_active (true);
 294                 }
 295                 _fade_in_disabled = state->_fade_in_disabled;
 296         }
 297
 298         if (_fade_out_disabled != state->_fade_out_disabled) {
 299                 if (_fade_out_disabled == 0 && state->_fade_out_disabled) {
 300                         set_fade_out_active (false);
 301                 } if (_fade_out_disabled && state->_fade_out_disabled == 0) {
 302                         set_fade_out_active (true);
 303                 }
 304                 _fade_out_disabled = state->_fade_out_disabled;
 305         }
 306
 307         /* XXX need a way to test stored state versus current for envelopes */
 308
 309         _envelope = state->_envelope;
 310         what_changed = Change (what_changed);
 311
 312         return what_changed;
 313 }
 314
 315 UndoAction
 316 AudioRegion::get_memento() const
 317 {
 318         return sigc::bind (mem_fun (*(const_cast<AudioRegion *> (this)), &StateManager::use_state), _current_state_id);
 319 }
 320
 321 void
 322 AudioRegion::set_envelope_active (bool yn)
 323 {
 324         if (envelope_active() != yn) {
 325                 char buf[64];
 326                 if (yn) {
 327                         snprintf (buf, sizeof (buf), "envelope active");
 328                         _flags = Flag (_flags|EnvelopeActive);
 329                 } else {
 330                         snprintf (buf, sizeof (buf), "envelope off");
 331                         _flags = Flag (_flags & ~EnvelopeActive);
 332                 }
 333                 if (!_frozen) {
 334                         save_state (buf);
 335                 }
 336                 send_change (EnvelopeActiveChanged);
 337
 338         }
 339 }
 340
 341 jack_nframes_t
 342 AudioRegion::read_peaks (PeakData *buf, jack_nframes_t npeaks, jack_nframes_t offset, jack_nframes_t cnt, uint32_t chan_n, double samples_per_unit) const
 343 {
 344         if (chan_n >= _sources.size()) {
 345                 return 0;
 346         }
 347
 348         if (audio_source(chan_n).read_peaks (buf, npeaks, offset, cnt, samples_per_unit)) {
 349                 return 0;
 350         } else {
 351                 if (_scale_amplitude != 1.0) {
 352                         for (jack_nframes_t n = 0; n < npeaks; ++n) {
 353                                 buf[n].max *= _scale_amplitude;
 354                                 buf[n].min *= _scale_amplitude;
 355                         }
 356                 }
 357                 return cnt;
 358         }
 359 }
 360
 361 jack_nframes_t
 362 AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
 363                       jack_nframes_t cnt,
 364                       uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
 365 {
 366         return _read_at (_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames);
 367 }
 368
 369 jack_nframes_t
 370 AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
 371                              jack_nframes_t cnt, uint32_t chan_n) const
 372 {
 373         return _read_at (_master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
 374 }
 375
 376 jack_nframes_t
 377 AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
 378                        jack_nframes_t position, jack_nframes_t cnt,
 379                        uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
 380 {
 381         jack_nframes_t internal_offset;
 382         jack_nframes_t buf_offset;
 383         jack_nframes_t to_read;
 384
 385         /* precondition: caller has verified that we cover the desired section */
 386
 387         if (chan_n >= _sources.size()) {
 388                 return 0; /* read nothing */
 389         }
 390
 391         if (position < _position) {
 392                 internal_offset = 0;
 393                 buf_offset = _position - position;
 394                 cnt -= buf_offset;
 395         } else {
 396                 internal_offset = position - _position;
 397                 buf_offset = 0;
 398         }
 399
 400         if (internal_offset >= _length) {
 401                 return 0; /* read nothing */
 402         }
 403
 404
 405         if ((to_read = min (cnt, _length - internal_offset)) == 0) {
 406                 return 0; /* read nothing */
 407         }
 408
 409         if (opaque()) {
 410                 /* overwrite whatever is there */
 411                 mixdown_buffer = buf + buf_offset;
 412         } else {
 413                 mixdown_buffer += buf_offset;
 414         }
 415
 416         if (muted()) {
 417                 return 0; /* read nothing */
 418         }
 419
 420         _read_data_count = 0;
 421
 422         AudioSource& src = audio_source(chan_n);
 423         if (src.read (mixdown_buffer, _start + internal_offset, to_read) != to_read) {
 424                 return 0; /* "read nothing" */
 425         }
 426
 427         _read_data_count += src.read_data_count();
 428
 429         /* fade in */
 430
 431         if (_flags & FadeIn) {
 432
 433                 jack_nframes_t fade_in_length = (jack_nframes_t) _fade_in.back()->when;
 434
 435                 /* see if this read is within the fade in */
 436
 437                 if (internal_offset < fade_in_length) {
 438
 439                         jack_nframes_t limit;
 440
 441                         limit = min (to_read, fade_in_length - internal_offset);
 442
 443                         _fade_in.get_vector (internal_offset, internal_offset+limit, gain_buffer, limit);
 444
 445                         for (jack_nframes_t n = 0; n < limit; ++n) {
 446                                 mixdown_buffer[n] *= gain_buffer[n];
 447                         }
 448                 }
 449         }
 450
 451         /* fade out */
 452
 453         if (_flags & FadeOut) {
 454
 455
 456
 457
 458                 /* see if some part of this read is within the fade out */
 459
 460                 /* .................        >|            REGION
 461                                             _length
 462
 463                                  {           }            FADE
 464                                              fade_out_length
 465                                  ^
 466                                _length - fade_out_length
 467                         |--------------|
 468                         ^internal_offset
 469                                        ^internal_offset + to_read
 470
 471                   we need the intersection of [internal_offset,internal_offset+to_read] with
 472                   [_length - fade_out_length, _length]
 473
 474                 */
 475
 476
 477                 jack_nframes_t fade_out_length = (jack_nframes_t) _fade_out.back()->when;
 478                 jack_nframes_t fade_interval_start = max(internal_offset, _length-fade_out_length);
 479                 jack_nframes_t fade_interval_end   = min(internal_offset + to_read, _length);
 480
 481                 if (fade_interval_end > fade_interval_start) {
 482                         /* (part of the) the fade out is  in this buffer */
 483
 484                         jack_nframes_t limit = fade_interval_end - fade_interval_start;
 485                         jack_nframes_t curve_offset = fade_interval_start - (_length-fade_out_length);
 486                         jack_nframes_t fade_offset = fade_interval_start - internal_offset;
 487
 488                         _fade_out.get_vector (curve_offset,curve_offset+limit, gain_buffer, limit);
 489
 490                         for (jack_nframes_t n = 0, m = fade_offset; n < limit; ++n, ++m) {
 491                                 mixdown_buffer[m] *= gain_buffer[n];
 492                         }
 493                 }
 494
 495         }
 496
 497         /* Regular gain curves */
 498
 499         if (envelope_active())  {
 500                 _envelope.get_vector (internal_offset, internal_offset + to_read, gain_buffer, to_read);
 501
 502                 if (_scale_amplitude != 1.0f) {
 503                         for (jack_nframes_t n = 0; n < to_read; ++n) {
 504                                 mixdown_buffer[n] *= gain_buffer[n] * _scale_amplitude;
 505                         }
 506                 } else {
 507                         for (jack_nframes_t n = 0; n < to_read; ++n) {
 508                                 mixdown_buffer[n] *= gain_buffer[n];
 509                         }
 510                 }
 511         } else if (_scale_amplitude != 1.0f) {
 512                 Session::apply_gain_to_buffer (mixdown_buffer, to_read, _scale_amplitude);
 513         }
 514
 515         if (!opaque()) {
 516
 517                 /* gack. the things we do for users.
 518                  */
 519
 520                 buf += buf_offset;
 521
 522                 for (jack_nframes_t n = 0; n < to_read; ++n) {
 523                         buf[n] += mixdown_buffer[n];
 524                 }
 525         }
 526
 527         return to_read;
 528 }
 529
 530 XMLNode&
 531 AudioRegion::state (bool full)
 532 {
 533         XMLNode& node (Region::state (full));
 534         XMLNode *child;
 535         char buf[64];
 536         char buf2[64];
 537         LocaleGuard lg (X_("POSIX"));
 538
 539         snprintf (buf, sizeof (buf), "0x%x", (int) _flags);
 540         node.add_property ("flags", buf);
 541         snprintf (buf, sizeof(buf), "%.12g", _scale_amplitude);
 542         node.add_property ("scale-gain", buf);
 543
 544         for (uint32_t n=0; n < _sources.size(); ++n) {
 545                 snprintf (buf2, sizeof(buf2), "source-%d", n);
 546                 _sources[n]->id().print (buf);
 547                 node.add_property (buf2, buf);
 548         }
 549
 550         snprintf (buf, sizeof (buf), "%u", (uint32_t) _sources.size());
 551         node.add_property ("channels", buf);
 552
 553         if (full) {
 554
 555                 child = node.add_child (X_("FadeIn"));
 556
 557                 if ((_flags & DefaultFadeIn)) {
 558                         child->add_property (X_("default"), X_("yes"));
 559                 } else {
 560                         _fade_in.store_state (*child);
 561                 }
 562
 563                 child = node.add_child (X_("FadeOut"));
 564
 565                 if ((_flags & DefaultFadeOut)) {
 566                         child->add_property (X_("default"), X_("yes"));
 567                 } else {
 568                         _fade_out.store_state (*child);
 569                 }
 570         }
 571
 572         child = node.add_child ("Envelope");
 573
 574         if (full) {
 575                 bool default_env = false;
 576
 577                 // If there are only two points, the points are in the start of the region and the end of the region
 578                 // so, if they are both at 1.0f, that means the default region.
 579                 if (_envelope.size() == 2 &&
 580                     _envelope.front()->value == 1.0f &&
 581                     _envelope.back()->value==1.0f) {
 582                         if (_envelope.front()->when == 0 && _envelope.back()->when == _length) {
 583                                 default_env = true;
 584                         }
 585                 }
 586
 587                 if (default_env) {
 588                         child->add_property ("default", "yes");
 589                 } else {
 590                         _envelope.store_state (*child);
 591                 }
 592         } else {
 593                 child->add_property ("default", "yes");
 594         }
 595
 596         if (full && _extra_xml) {
 597                 node.add_child_copy (*_extra_xml);
 598         }
 599
 600         return node;
 601 }
 602
 603 int
 604 AudioRegion::set_state (const XMLNode& node)
 605 {
 606         const XMLNodeList& nlist = node.children();
 607         const XMLProperty *prop;
 608         LocaleGuard lg (X_("POSIX"));
 609
 610         Region::set_state (node);
 611
 612         if ((prop = node.property ("flags")) != 0) {
 613                 _flags = Flag (strtol (prop->value().c_str(), (char **) 0, 16));
 614
 615                 _flags = Flag (_flags & ~Region::LeftOfSplit);
 616                 _flags = Flag (_flags & ~Region::RightOfSplit);
 617         }
 618
 619         if ((prop = node.property ("scale-gain")) != 0) {
 620                 _scale_amplitude = atof (prop->value().c_str());
 621         } else {
 622                 _scale_amplitude = 1.0;
 623         }
 624
 625         /* Now find envelope description and other misc child items */
 626
 627         for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 628
 629                 XMLNode *child;
 630                 XMLProperty *prop;
 631
 632                 child = (*niter);
 633
 634                 if (child->name() == "Envelope") {
 635
 636                         _envelope.clear ();
 637
 638                         if ((prop = child->property ("default")) != 0) {
 639                                 set_default_envelope ();
 640                         } else {
 641                                 _envelope.load_state (*child);
 642                         }
 643
 644                         _envelope.set_max_xval (_length);
 645                         _envelope.truncate_end (_length);
 646
 647                 } else if (child->name() == "FadeIn") {
 648
 649                         _fade_in.clear ();
 650
 651                         if ((prop = child->property ("default")) != 0 || (prop = child->property ("steepness")) != 0) {
 652                                 set_default_fade_in ();
 653                         } else {
 654
 655                                 _fade_in.load_state (*child);
 656                         }
 657
 658                 } else if (child->name() == "FadeOut") {
 659
 660                         _fade_out.clear ();
 661
 662                         if ((prop = child->property ("default")) != 0 || (prop = child->property ("steepness")) != 0) {
 663                                 set_default_fade_out ();
 664                         } else {
 665                                 _fade_out.load_state (*child);
 666                         }
 667                 }
 668         }
 669
 670         return 0;
 671 }
 672
 673 void
 674 AudioRegion::set_fade_in_shape (FadeShape shape)
 675 {
 676         set_fade_in (shape, (jack_nframes_t) _fade_in.back()->when);
 677 }
 678
 679 void
 680 AudioRegion::set_fade_out_shape (FadeShape shape)
 681 {
 682         set_fade_out (shape, (jack_nframes_t) _fade_out.back()->when);
 683 }
 684
 685 void
 686 AudioRegion::set_fade_in (FadeShape shape, jack_nframes_t len)
 687 {
 688         _fade_in.freeze ();
 689         _fade_in.clear ();
 690
 691         switch (shape) {
 692         case Linear:
 693                 _fade_in.add (0.0, 0.0);
 694                 _fade_in.add (len, 1.0);
 695                 break;
 696
 697         case Fast:
 698                 _fade_in.add (0, 0);
 699                 _fade_in.add (len * 0.389401, 0.0333333);
 700                 _fade_in.add (len * 0.629032, 0.0861111);
 701                 _fade_in.add (len * 0.829493, 0.233333);
 702                 _fade_in.add (len * 0.9447, 0.483333);
 703                 _fade_in.add (len * 0.976959, 0.697222);
 704                 _fade_in.add (len, 1);
 705                 break;
 706
 707         case Slow:
 708                 _fade_in.add (0, 0);
 709                 _fade_in.add (len * 0.0207373, 0.197222);
 710                 _fade_in.add (len * 0.0645161, 0.525);
 711                 _fade_in.add (len * 0.152074, 0.802778);
 712                 _fade_in.add (len * 0.276498, 0.919444);
 713                 _fade_in.add (len * 0.481567, 0.980556);
 714                 _fade_in.add (len * 0.767281, 1);
 715                 _fade_in.add (len, 1);
 716                 break;
 717
 718         case LogA:
 719                 _fade_in.add (0, 0);
 720                 _fade_in.add (len * 0.0737327, 0.308333);
 721                 _fade_in.add (len * 0.246544, 0.658333);
 722                 _fade_in.add (len * 0.470046, 0.886111);
 723                 _fade_in.add (len * 0.652074, 0.972222);
 724                 _fade_in.add (len * 0.771889, 0.988889);
 725                 _fade_in.add (len, 1);
 726                 break;
 727
 728         case LogB:
 729                 _fade_in.add (0, 0);
 730                 _fade_in.add (len * 0.304147, 0.0694444);
 731                 _fade_in.add (len * 0.529954, 0.152778);
 732                 _fade_in.add (len * 0.725806, 0.333333);
 733                 _fade_in.add (len * 0.847926, 0.558333);
 734                 _fade_in.add (len * 0.919355, 0.730556);
 735                 _fade_in.add (len, 1);
 736                 break;
 737         }
 738
 739         _fade_in.thaw ();
 740         _fade_in_shape = shape;
 741
 742         if (!_frozen) {
 743                 save_state (_("fade in change"));
 744         }
 745
 746         send_change (FadeInChanged);
 747 }
 748
 749 void
 750 AudioRegion::set_fade_out (FadeShape shape, jack_nframes_t len)
 751 {
 752         _fade_out.freeze ();
 753         _fade_out.clear ();
 754
 755         switch (shape) {
 756         case Fast:
 757                 _fade_out.add (len * 0, 1);
 758                 _fade_out.add (len * 0.023041, 0.697222);
 759                 _fade_out.add (len * 0.0553,   0.483333);
 760                 _fade_out.add (len * 0.170507, 0.233333);
 761                 _fade_out.add (len * 0.370968, 0.0861111);
 762                 _fade_out.add (len * 0.610599, 0.0333333);
 763                 _fade_out.add (len * 1, 0);
 764                 break;
 765
 766         case LogA:
 767                 _fade_out.add (len * 0, 1);
 768                 _fade_out.add (len * 0.228111, 0.988889);
 769                 _fade_out.add (len * 0.347926, 0.972222);
 770                 _fade_out.add (len * 0.529954, 0.886111);
 771                 _fade_out.add (len * 0.753456, 0.658333);
 772                 _fade_out.add (len * 0.9262673, 0.308333);
 773                 _fade_out.add (len * 1, 0);
 774                 break;
 775
 776         case Slow:
 777                 _fade_out.add (len * 0, 1);
 778                 _fade_out.add (len * 0.305556, 1);
 779                 _fade_out.add (len * 0.548611, 0.991736);
 780                 _fade_out.add (len * 0.759259, 0.931129);
 781                 _fade_out.add (len * 0.918981, 0.68595);
 782                 _fade_out.add (len * 0.976852, 0.22865);
 783                 _fade_out.add (len * 1, 0);
 784                 break;
 785
 786         case LogB:
 787                 _fade_out.add (len * 0, 1);
 788                 _fade_out.add (len * 0.080645, 0.730556);
 789                 _fade_out.add (len * 0.277778, 0.289256);
 790                 _fade_out.add (len * 0.470046, 0.152778);
 791                 _fade_out.add (len * 0.695853, 0.0694444);
 792                 _fade_out.add (len * 1, 0);
 793                 break;
 794
 795         case Linear:
 796                 _fade_out.add (len * 0, 1);
 797                 _fade_out.add (len * 1, 0);
 798                 break;
 799         }
 800
 801         _fade_out.thaw ();
 802         _fade_out_shape = shape;
 803
 804         if (!_frozen) {
 805                 save_state (_("fade in change"));
 806         }
 807
 808         send_change (FadeOutChanged);
 809 }
 810
 811 void
 812 AudioRegion::set_fade_in_length (jack_nframes_t len)
 813 {
 814         bool changed = _fade_in.extend_to (len);
 815
 816         if (changed) {
 817                 _flags = Flag (_flags & ~DefaultFadeIn);
 818
 819                 if (!_frozen) {
 820                         char buf[64];
 821                         snprintf (buf, sizeof (buf), "fade in length changed to %u", len);
 822                         save_state (buf);
 823                 }
 824
 825                 send_change (FadeInChanged);
 826         }
 827 }
 828
 829 void
 830 AudioRegion::set_fade_out_length (jack_nframes_t len)
 831 {
 832         bool changed =  _fade_out.extend_to (len);
 833
 834         if (changed) {
 835                 _flags = Flag (_flags & ~DefaultFadeOut);
 836
 837                 if (!_frozen) {
 838                         char buf[64];
 839                         snprintf (buf, sizeof (buf), "fade out length changed to %u", len);
 840                         save_state (buf);
 841                 }
 842         }
 843
 844         send_change (FadeOutChanged);
 845 }
 846
 847 void
 848 AudioRegion::set_fade_in_active (bool yn)
 849 {
 850         if (yn == (_flags & FadeIn)) {
 851                 return;
 852         }
 853         if (yn) {
 854                 _flags = Flag (_flags|FadeIn);
 855         } else {
 856                 _flags = Flag (_flags & ~FadeIn);
 857         }
 858
 859         send_change (FadeInActiveChanged);
 860 }
 861
 862 void
 863 AudioRegion::set_fade_out_active (bool yn)
 864 {
 865         if (yn == (_flags & FadeOut)) {
 866                 return;
 867         }
 868         if (yn) {
 869                 _flags = Flag (_flags | FadeOut);
 870         } else {
 871                 _flags = Flag (_flags & ~FadeOut);
 872         }
 873
 874         send_change (FadeOutActiveChanged);
 875 }
 876
 877 void
 878 AudioRegion::set_default_fade_in ()
 879 {
 880         set_fade_in (Linear, 64);
 881 }
 882
 883 void
 884 AudioRegion::set_default_fade_out ()
 885 {
 886         set_fade_out (Linear, 64);
 887 }
 888
 889 void
 890 AudioRegion::set_default_fades ()
 891 {
 892         _fade_in_disabled = 0;
 893         _fade_out_disabled = 0;
 894         set_default_fade_in ();
 895         set_default_fade_out ();
 896 }
 897
 898 void
 899 AudioRegion::set_default_envelope ()
 900 {
 901         _envelope.freeze ();
 902         _envelope.clear ();
 903         _envelope.add (0, 1.0f);
 904         _envelope.add (_length, 1.0f);
 905         _envelope.thaw ();
 906 }
 907
 908 void
 909 AudioRegion::recompute_at_end ()
 910 {
 911         /* our length has changed. recompute a new final point by interpolating
 912            based on the the existing curve.
 913         */
 914
 915         _envelope.freeze ();
 916         _envelope.truncate_end (_length);
 917         _envelope.set_max_xval (_length);
 918         _envelope.thaw ();
 919
 920         if (_fade_in.back()->when > _length) {
 921                 _fade_in.extend_to (_length);
 922                 send_change (FadeInChanged);
 923         }
 924
 925         if (_fade_out.back()->when > _length) {
 926                 _fade_out.extend_to (_length);
 927                 send_change (FadeOutChanged);
 928         }
 929 }
 930
 931 void
 932 AudioRegion::recompute_at_start ()
 933 {
 934         /* as above, but the shift was from the front */
 935
 936         _envelope.truncate_start (_length);
 937
 938         if (_fade_in.back()->when > _length) {
 939                 _fade_in.extend_to (_length);
 940                 send_change (FadeInChanged);
 941         }
 942
 943         if (_fade_out.back()->when > _length) {
 944                 _fade_out.extend_to (_length);
 945                 send_change (FadeOutChanged);
 946         }
 947 }
 948
 949 int
 950 AudioRegion::separate_by_channel (Session& session, vector<AudioRegion*>& v) const
 951 {
 952         SourceList srcs;
 953         string new_name;
 954
 955         for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
 956
 957                 srcs.clear ();
 958                 srcs.push_back (*i);
 959
 960                 /* generate a new name */
 961
 962                 if (session.region_name (new_name, _name)) {
 963                         return -1;
 964                 }
 965
 966                 /* create a copy with just one source */
 967
 968                 v.push_back (new AudioRegion (srcs, _start, _length, new_name, _layer, _flags));
 969         }
 970
 971         return 0;
 972 }
 973
 974 int
 975 AudioRegion::apply (AudioFilter& filter)
 976 {
 977         return filter.run (*this);
 978 }
 979
 980 int
 981 AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
 982 {
 983         const jack_nframes_t blocksize = 4096;
 984         jack_nframes_t to_read;
 985         int status = -1;
 986
 987         spec.channels = _sources.size();
 988
 989         if (spec.prepare (blocksize, session.frame_rate())) {
 990                 goto out;
 991         }
 992
 993         spec.pos = 0;
 994         spec.total_frames = _length;
 995
 996         while (spec.pos < _length && !spec.stop) {
 997
 998
 999                 /* step 1: interleave */
1000
1001                 to_read = min (_length - spec.pos, blocksize);
1002
1003                 if (spec.channels == 1) {
1004
1005                         if (audio_source().read (spec.dataF, _start + spec.pos, to_read) != to_read) {
1006                                 goto out;
1007                         }
1008
1009                 } else {
1010
1011                         Sample buf[blocksize];
1012
1013                         for (uint32_t chan = 0; chan < spec.channels; ++chan) {
1014
1015                                 if (audio_source(chan).read (buf, _start + spec.pos, to_read) != to_read) {
1016                                         goto out;
1017                                 }
1018
1019                                 for (jack_nframes_t x = 0; x < to_read; ++x) {
1020                                         spec.dataF[chan+(x*spec.channels)] = buf[x];
1021                                 }
1022                         }
1023                 }
1024
1025                 if (spec.process (to_read)) {
1026                         goto out;
1027                 }
1028
1029                 spec.pos += to_read;
1030                 spec.progress = (double) spec.pos /_length;
1031
1032         }
1033
1034         status = 0;
1035
1036   out:
1037         spec.running = false;
1038         spec.status = status;
1039         spec.clear();
1040
1041         return status;
1042 }
1043
1044 void
1045 AudioRegion::set_scale_amplitude (gain_t g)
1046 {
1047         _scale_amplitude = g;
1048
1049         /* tell the diskstream we're in */
1050
1051         if (_playlist) {
1052                 _playlist->Modified();
1053         }
1054
1055         /* tell everybody else */
1056
1057         send_change (ScaleAmplitudeChanged);
1058 }
1059
1060 void
1061 AudioRegion::normalize_to (float target_dB)
1062 {
1063         const jack_nframes_t blocksize = 64 * 1024;
1064         Sample buf[blocksize];
1065         jack_nframes_t fpos;
1066         jack_nframes_t fend;
1067         jack_nframes_t to_read;
1068         double maxamp = 0;
1069         gain_t target = dB_to_coefficient (target_dB);
1070
1071         if (target == 1.0f) {
1072                 /* do not normalize to precisely 1.0 (0 dBFS), to avoid making it appear
1073                    that we may have clipped.
1074                 */
1075                 target -= FLT_EPSILON;
1076         }
1077
1078         fpos = _start;
1079         fend = _start + _length;
1080
1081         /* first pass: find max amplitude */
1082
1083         while (fpos < fend) {
1084
1085                 uint32_t n;
1086
1087                 to_read = min (fend - fpos, blocksize);
1088
1089                 for (n = 0; n < n_channels(); ++n) {
1090
1091                         /* read it in */
1092
1093                         if (audio_source (n).read (buf, fpos, to_read) != to_read) {
1094                                 return;
1095                         }
1096
1097                         maxamp = Session::compute_peak (buf, to_read, maxamp);
1098                 }
1099
1100                 fpos += to_read;
1101         };
1102
1103         if (maxamp == 0.0f) {
1104                 /* don't even try */
1105                 return;
1106         }
1107
1108         if (maxamp == target) {
1109                 /* we can't do anything useful */
1110                 return;
1111         }
1112
1113         /* compute scale factor */
1114
1115         _scale_amplitude = target/maxamp;
1116
1117         if (!_frozen) {
1118                 char buf[64];
1119                 snprintf (buf, sizeof (buf), _("normalized to %.2fdB"), target_dB);
1120                 save_state (buf);
1121         }
1122
1123         /* tell the diskstream we're in */
1124
1125         if (_playlist) {
1126                 _playlist->Modified();
1127         }
1128
1129         /* tell everybody else */
1130
1131         send_change (ScaleAmplitudeChanged);
1132 }
1133
1134 void
1135 AudioRegion::envelope_changed (Change ignored)
1136 {
1137         save_state (_("envelope change"));
1138         send_change (EnvelopeChanged);
1139 }
1140
1141 void
1142 AudioRegion::suspend_fade_in ()
1143 {
1144         if (++_fade_in_disabled == 1) {
1145                 set_fade_in_active (false);
1146         }
1147 }
1148
1149 void
1150 AudioRegion::resume_fade_in ()
1151 {
1152         if (_fade_in_disabled && --_fade_in_disabled == 0) {
1153                 set_fade_in_active (true);
1154         }
1155 }
1156
1157 void
1158 AudioRegion::suspend_fade_out ()
1159 {
1160         if (++_fade_out_disabled == 1) {
1161                 set_fade_out_active (false);
1162         }
1163 }
1164
1165 void
1166 AudioRegion::resume_fade_out ()
1167 {
1168         if (_fade_out_disabled && --_fade_out_disabled == 0) {
1169                 set_fade_out_active (true);
1170         }
1171 }
1172
1173 bool
1174 AudioRegion::speed_mismatch (float sr) const
1175 {
1176         if (_sources.empty()) {
1177                 /* impossible, but ... */
1178                 return false;
1179         }
1180
1181         float fsr = audio_source().sample_rate();
1182
1183         return fsr != sr;
1184 }
1185
1186 AudioSource&
1187 AudioRegion::audio_source (uint32_t n) const
1188 {
1189         // Guaranteed to succeed (use a static cast?)
1190         return dynamic_cast<AudioSource&>(source(n));
1191 }
1192
1193 extern "C" {
1194
1195         int region_read_peaks_from_c (void *arg, uint32_t npeaks, uint32_t start, uint32_t cnt, intptr_t data, uint32_t n_chan, double samples_per_unit)
1196 {
1197         return ((AudioRegion *) arg)->read_peaks ((PeakData *) data, (jack_nframes_t) npeaks, (jack_nframes_t) start, (jack_nframes_t) cnt, n_chan,samples_per_unit);
1198 }
1199
1200 uint32_t region_length_from_c (void *arg)
1201 {
1202
1203         return ((AudioRegion *) arg)->length();
1204 }
1205
1206 uint32_t sourcefile_length_from_c (void *arg, double zoom_factor)
1207 {
1208         return ( (AudioRegion *) arg)->audio_source().available_peaks (zoom_factor) ;
1209 }
1210
1211 } /* extern "C" */