libs/ardour/audio_diskstream.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
  19 #include <fstream>
  20 #include <cstdio>
  21 #include <unistd.h>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <cassert>
  25 #include <string>
  26 #include <climits>
  27 #include <fcntl.h>
  28 #include <cstdlib>
  29 #include <ctime>
  30 #include <sys/stat.h>
  31 #include <sys/mman.h>
  32
  33 #include "pbd/error.h"
  34 #include <glibmm/thread.h>
  35 #include "pbd/xml++.h"
  36 #include "pbd/memento_command.h"
  37 #include "pbd/enumwriter.h"
  38 #include "pbd/stacktrace.h"
  39
  40 #include "ardour/analyser.h"
  41 #include "ardour/ardour.h"
  42 #include "ardour/audio_buffer.h"
  43 #include "ardour/audio_diskstream.h"
  44 #include "ardour/audio_port.h"
  45 #include "ardour/audioengine.h"
  46 #include "ardour/audiofilesource.h"
  47
  48 #include "ardour/audioplaylist.h"
  49 #include "ardour/audioregion.h"
  50 #include "ardour/butler.h"
  51 #include "ardour/configuration.h"
  52 #include "ardour/cycle_timer.h"
  53 #include "ardour/debug.h"
  54 #include "ardour/io.h"
  55 #include "ardour/playlist_factory.h"
  56 #include "ardour/region_factory.h"
  57 #include "ardour/send.h"
  58 #include "ardour/session.h"
  59 #include "ardour/source_factory.h"
  60 #include "ardour/utils.h"
  61 #include "ardour/session_playlists.h"
  62
  63 #include "i18n.h"
  64 #include <locale.h>
  65
  66 using namespace std;
  67 using namespace ARDOUR;
  68 using namespace PBD;
  69
  70 size_t  AudioDiskstream::_working_buffers_size = 0;
  71 Sample* AudioDiskstream::_mixdown_buffer       = 0;
  72 gain_t* AudioDiskstream::_gain_buffer          = 0;
  73
  74 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
  75         : Diskstream(sess, name, flag)
  76         , deprecated_io_node(NULL)
  77         , channels (new ChannelList)
  78 {
  79         /* prevent any write sources from being created */
  80
  81         in_set_state = true;
  82
  83         init(flag);
  84         use_new_playlist ();
  85
  86         in_set_state = false;
  87 }
  88
  89 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
  90         : Diskstream(sess, node)
  91         , deprecated_io_node(NULL)
  92         , channels (new ChannelList)
  93 {
  94         in_set_state = true;
  95         init (Recordable);
  96
  97         if (set_state (node, Stateful::loading_state_version)) {
  98                 in_set_state = false;
  99                 throw failed_constructor();
 100         }
 101
 102         in_set_state = false;
 103
 104         if (destructive()) {
 105                 use_destructive_playlist ();
 106         }
 107 }
 108
 109 void
 110 AudioDiskstream::init (Diskstream::Flag f)
 111 {
 112         Diskstream::init(f);
 113
 114         /* there are no channels at this point, so these
 115            two calls just get speed_buffer_size and wrap_buffer
 116            size setup without duplicating their code.
 117         */
 118
 119         set_block_size (_session.get_block_size());
 120         allocate_temporary_buffers ();
 121
 122         add_channel (1);
 123         assert(_n_channels == ChanCount(DataType::AUDIO, 1));
 124 }
 125
 126 AudioDiskstream::~AudioDiskstream ()
 127 {
 128         DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
 129
 130         {
 131                 RCUWriter<ChannelList> writer (channels);
 132                 boost::shared_ptr<ChannelList> c = writer.get_copy();
 133
 134                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 135                         delete *chan;
 136                 }
 137
 138                 c->clear();
 139         }
 140
 141         channels.flush ();
 142
 143         delete deprecated_io_node;
 144 }
 145
 146 void
 147 AudioDiskstream::allocate_working_buffers()
 148 {
 149         assert(disk_io_frames() > 0);
 150
 151         _working_buffers_size = disk_io_frames();
 152         _mixdown_buffer       = new Sample[_working_buffers_size];
 153         _gain_buffer          = new gain_t[_working_buffers_size];
 154 }
 155
 156 void
 157 AudioDiskstream::free_working_buffers()
 158 {
 159         delete [] _mixdown_buffer;
 160         delete [] _gain_buffer;
 161         _working_buffers_size = 0;
 162         _mixdown_buffer       = 0;
 163         _gain_buffer          = 0;
 164 }
 165
 166 void
 167 AudioDiskstream::non_realtime_input_change ()
 168 {
 169         {
 170                 Glib::Mutex::Lock lm (state_lock);
 171
 172                 if (input_change_pending == NoChange) {
 173                         return;
 174                 }
 175
 176                 {
 177                         RCUWriter<ChannelList> writer (channels);
 178                         boost::shared_ptr<ChannelList> c = writer.get_copy();
 179
 180                         _n_channels.set(DataType::AUDIO, c->size());
 181
 182                         if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
 183                                 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
 184                         } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
 185                                 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
 186                         }
 187                 }
 188
 189                 get_input_sources ();
 190                 set_capture_offset ();
 191
 192                 if (first_input_change) {
 193                         set_align_style (_persistent_alignment_style);
 194                         first_input_change = false;
 195                 } else {
 196                         set_align_style_from_io ();
 197                 }
 198
 199                 input_change_pending = NoChange;
 200
 201                 /* implicit unlock */
 202         }
 203
 204         /* reset capture files */
 205
 206         reset_write_sources (false);
 207
 208         /* now refill channel buffers */
 209
 210         if (speed() != 1.0f || speed() != -1.0f) {
 211                 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
 212         } else {
 213                 seek (_session.transport_frame());
 214         }
 215 }
 216
 217 void
 218 AudioDiskstream::non_realtime_locate (nframes_t location)
 219 {
 220         /* now refill channel buffers */
 221
 222         if (speed() != 1.0f || speed() != -1.0f) {
 223                 seek ((nframes_t) (location * (double) speed()));
 224         } else {
 225                 seek (location);
 226         }
 227 }
 228
 229 void
 230 AudioDiskstream::get_input_sources ()
 231 {
 232         boost::shared_ptr<ChannelList> c = channels.reader();
 233
 234         uint32_t n;
 235         ChannelList::iterator chan;
 236         uint32_t ni = _io->n_ports().n_audio();
 237         vector<string> connections;
 238
 239         for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
 240
 241                 connections.clear ();
 242
 243                 if (_io->nth (n)->get_connections (connections) == 0) {
 244
 245                         if ((*chan)->source) {
 246                                 // _source->disable_metering ();
 247                         }
 248
 249                         (*chan)->source = 0;
 250
 251                 } else {
 252                         (*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
 253                 }
 254         }
 255 }
 256
 257 int
 258 AudioDiskstream::find_and_use_playlist (const string& name)
 259 {
 260         boost::shared_ptr<AudioPlaylist> playlist;
 261
 262         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
 263                 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
 264         }
 265
 266         if (!playlist) {
 267                 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
 268                 return -1;
 269         }
 270
 271         return use_playlist (playlist);
 272 }
 273
 274 int
 275 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 276 {
 277         assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
 278
 279         Diskstream::use_playlist(playlist);
 280
 281         return 0;
 282 }
 283
 284 int
 285 AudioDiskstream::use_new_playlist ()
 286 {
 287         string newname;
 288         boost::shared_ptr<AudioPlaylist> playlist;
 289
 290         if (!in_set_state && destructive()) {
 291                 return 0;
 292         }
 293
 294         if (_playlist) {
 295                 newname = Playlist::bump_name (_playlist->name(), _session);
 296         } else {
 297                 newname = Playlist::bump_name (_name, _session);
 298         }
 299
 300         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 301
 302                 playlist->set_orig_diskstream_id (id());
 303                 return use_playlist (playlist);
 304
 305         } else {
 306                 return -1;
 307         }
 308 }
 309
 310 int
 311 AudioDiskstream::use_copy_playlist ()
 312 {
 313         assert(audio_playlist());
 314
 315         if (destructive()) {
 316                 return 0;
 317         }
 318
 319         if (_playlist == 0) {
 320                 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 321                 return -1;
 322         }
 323
 324         string newname;
 325         boost::shared_ptr<AudioPlaylist> playlist;
 326
 327         newname = Playlist::bump_name (_playlist->name(), _session);
 328
 329         if ((playlist  = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
 330                 playlist->set_orig_diskstream_id (id());
 331                 return use_playlist (playlist);
 332         } else {
 333                 return -1;
 334         }
 335 }
 336
 337 void
 338 AudioDiskstream::setup_destructive_playlist ()
 339 {
 340         SourceList srcs;
 341         boost::shared_ptr<ChannelList> c = channels.reader();
 342
 343         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 344                 srcs.push_back ((*chan)->write_source);
 345         }
 346
 347         /* a single full-sized region */
 348
 349         PropertyList plist;
 350         plist.add (Properties::name, _name.val());
 351         plist.add (Properties::start, 0);
 352         plist.add (Properties::length, max_frames - max_frames - srcs.front()->natural_position());
 353
 354         boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
 355         _playlist->add_region (region, srcs.front()->natural_position());
 356 }
 357
 358 void
 359 AudioDiskstream::use_destructive_playlist ()
 360 {
 361         /* this is called from the XML-based constructor or ::set_destructive. when called,
 362            we already have a playlist and a region, but we need to
 363            set up our sources for write. we use the sources associated
 364            with the (presumed single, full-extent) region.
 365         */
 366
 367         boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
 368
 369         if (!rp) {
 370                 reset_write_sources (false, true);
 371                 return;
 372         }
 373
 374         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
 375
 376         if (region == 0) {
 377                 throw failed_constructor();
 378         }
 379
 380         /* be sure to stretch the region out to the maximum length */
 381
 382         region->set_length (max_frames - region->position(), this);
 383
 384         uint32_t n;
 385         ChannelList::iterator chan;
 386         boost::shared_ptr<ChannelList> c = channels.reader();
 387
 388         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 389                 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
 390                 assert((*chan)->write_source);
 391                 (*chan)->write_source->set_allow_remove_if_empty (false);
 392
 393                 /* this might be false if we switched modes, so force it */
 394
 395                 (*chan)->write_source->set_destructive (true);
 396         }
 397
 398         /* the source list will never be reset for a destructive track */
 399 }
 400
 401 void
 402 AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
 403 {
 404         if (recordable() && destructive()) {
 405                 boost::shared_ptr<ChannelList> c = channels.reader();
 406                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 407
 408                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
 409                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
 410
 411                         if (transvec.len[0] > 0) {
 412                                 transvec.buf[0]->type = CaptureStart;
 413                                 transvec.buf[0]->capture_val = capture_start_frame;
 414                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
 415                         }
 416                         else {
 417                                 // bad!
 418                                 fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 419                                         << endmsg;
 420                         }
 421                 }
 422         }
 423 }
 424
 425 int
 426 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
 427 {
 428         uint32_t n;
 429         boost::shared_ptr<ChannelList> c = channels.reader();
 430         ChannelList::iterator chan;
 431         int ret = -1;
 432         nframes_t rec_offset = 0;
 433         nframes_t rec_nframes = 0;
 434         bool nominally_recording;
 435         bool re = record_enabled ();
 436         bool collect_playback = false;
 437
 438         /* if we've already processed the frames corresponding to this call,
 439            just return. this allows multiple routes that are taking input
 440            from this diskstream to call our ::process() method, but have
 441            this stuff only happen once. more commonly, it allows both
 442            the AudioTrack that is using this AudioDiskstream *and* the Session
 443            to call process() without problems.
 444         */
 445
 446         if (_processed) {
 447                 return 0;
 448         }
 449
 450         commit_should_unlock = false;
 451
 452         if (!_io || !_io->active()) {
 453                 _processed = true;
 454                 return 0;
 455         }
 456
 457         check_record_status (transport_frame, nframes, can_record);
 458
 459         nominally_recording = (can_record && re);
 460
 461         if (nframes == 0) {
 462                 _processed = true;
 463                 return 0;
 464         }
 465
 466         /* This lock is held until the end of AudioDiskstream::commit, so these two functions
 467            must always be called as a pair. The only exception is if this function
 468            returns a non-zero value, in which case, ::commit should not be called.
 469         */
 470
 471         // If we can't take the state lock return.
 472         if (!state_lock.trylock()) {
 473                 return 1;
 474         }
 475         commit_should_unlock = true;
 476         adjust_capture_position = 0;
 477
 478         for (chan = c->begin(); chan != c->end(); ++chan) {
 479                 (*chan)->current_capture_buffer = 0;
 480                 (*chan)->current_playback_buffer = 0;
 481         }
 482
 483         if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
 484                 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
 485                 if (last_recordable_frame < first_recordable_frame) {
 486                         last_recordable_frame = max_frames;
 487                 }
 488
 489                 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 490
 491                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 492
 493                 if (rec_nframes && !was_recording) {
 494                         capture_captured = 0;
 495                         was_recording = true;
 496                 }
 497         }
 498
 499
 500         if (can_record && !_last_capture_regions.empty()) {
 501                 _last_capture_regions.clear ();
 502         }
 503
 504         if (nominally_recording || rec_nframes) {
 505
 506                 uint32_t limit = _io->n_ports ().n_audio();
 507
 508                 /* one or more ports could already have been removed from _io, but our
 509                    channel setup hasn't yet been updated. prevent us from trying to
 510                    use channels that correspond to missing ports. note that the
 511                    process callback (from which this is called) is always atomic
 512                    with respect to port removal/addition.
 513                 */
 514
 515                 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
 516
 517                         ChannelInfo* chaninfo (*chan);
 518
 519                         chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
 520
 521                         if (rec_nframes <= chaninfo->capture_vector.len[0]) {
 522
 523                                 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
 524
 525                                 /* note: grab the entire port buffer, but only copy what we were supposed to
 526                                    for recording, and use rec_offset
 527                                 */
 528
 529                                 AudioPort* const ap = _io->audio (n);
 530                                 assert(ap);
 531                                 assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
 532                                 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (rec_nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
 533
 534
 535                         } else {
 536
 537                                 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
 538
 539                                 if (rec_nframes > total) {
 540                                         DiskOverrun ();
 541                                         goto out;
 542                                 }
 543
 544                                 AudioPort* const ap = _io->audio (n);
 545                                 assert(ap);
 546
 547                                 Sample* buf = ap->get_audio_buffer(nframes).data();
 548                                 nframes_t first = chaninfo->capture_vector.len[0];
 549
 550                                 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
 551                                 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
 552                                 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
 553                                 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
 554
 555                                 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
 556                         }
 557                 }
 558
 559         } else {
 560
 561                 if (was_recording) {
 562                         finish_capture (rec_monitors_input, c);
 563                 }
 564
 565         }
 566
 567         if (rec_nframes) {
 568
 569                 /* data will be written to disk */
 570
 571                 if (rec_nframes == nframes && rec_offset == 0) {
 572
 573                         for (chan = c->begin(); chan != c->end(); ++chan) {
 574                                 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 575                         }
 576
 577                         playback_distance = nframes;
 578
 579                 } else {
 580
 581
 582                         /* we can't use the capture buffer as the playback buffer, because
 583                            we recorded only a part of the current process' cycle data
 584                            for capture.
 585                         */
 586
 587                         collect_playback = true;
 588                 }
 589
 590                 adjust_capture_position = rec_nframes;
 591
 592         } else if (nominally_recording) {
 593
 594                 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
 595
 596                 for (chan = c->begin(); chan != c->end(); ++chan) {
 597                         (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 598                 }
 599
 600                 playback_distance = nframes;
 601
 602         } else {
 603
 604                 collect_playback = true;
 605         }
 606
 607         if (collect_playback) {
 608
 609                 /* we're doing playback */
 610
 611                 nframes_t necessary_samples;
 612
 613                 /* no varispeed playback if we're recording, because the output .... TBD */
 614
 615                 if (rec_nframes == 0 && _actual_speed != 1.0f) {
 616                         necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
 617                 } else {
 618                         necessary_samples = nframes;
 619                 }
 620
 621                 for (chan = c->begin(); chan != c->end(); ++chan) {
 622                         (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
 623                 }
 624
 625                 n = 0;
 626
 627                 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 628
 629                         ChannelInfo* chaninfo (*chan);
 630
 631                         if (necessary_samples <= chaninfo->playback_vector.len[0]) {
 632
 633                                 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 634
 635                         } else {
 636                                 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
 637
 638                                 if (necessary_samples > total) {
 639                                         cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
 640                                         cerr << "underrun for " << _name << endl;
 641                                         DiskUnderrun ();
 642                                         goto out;
 643
 644                                 } else {
 645
 646                                         memcpy ((char *) chaninfo->playback_wrap_buffer,
 647                                                         chaninfo->playback_vector.buf[0],
 648                                                         chaninfo->playback_vector.len[0] * sizeof (Sample));
 649                                         memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
 650                                                         chaninfo->playback_vector.buf[1],
 651                                                         (necessary_samples - chaninfo->playback_vector.len[0])
 652                                                                         * sizeof (Sample));
 653
 654                                         chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
 655                                 }
 656                         }
 657                 }
 658
 659                 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 660                         process_varispeed_playback(nframes, c);
 661                 } else {
 662                         playback_distance = nframes;
 663                 }
 664
 665                 _speed = _target_speed;
 666
 667         }
 668
 669         ret = 0;
 670
 671   out:
 672         _processed = true;
 673
 674         if (ret) {
 675
 676                 /* we're exiting with failure, so ::commit will not
 677                    be called. unlock the state lock.
 678                 */
 679
 680                 commit_should_unlock = false;
 681                 state_lock.unlock();
 682         }
 683
 684         return ret;
 685 }
 686
 687 void
 688 AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
 689 {
 690         ChannelList::iterator chan;
 691
 692         interpolation.set_speed (_target_speed);
 693
 694         int channel = 0;
 695         for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
 696                 ChannelInfo* chaninfo (*chan);
 697
 698                 playback_distance = interpolation.interpolate (
 699                                 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
 700
 701                 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
 702         }
 703 }
 704
 705 bool
 706 AudioDiskstream::commit (nframes_t /*nframes*/)
 707 {
 708         bool need_butler = false;
 709
 710         if (!_io || !_io->active()) {
 711                 return false;
 712         }
 713
 714         if (_actual_speed < 0.0) {
 715                 playback_sample -= playback_distance;
 716         } else {
 717                 playback_sample += playback_distance;
 718         }
 719
 720         boost::shared_ptr<ChannelList> c = channels.reader();
 721         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 722
 723                 (*chan)->playback_buf->increment_read_ptr (playback_distance);
 724
 725                 if (adjust_capture_position) {
 726                         (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
 727                 }
 728         }
 729
 730         if (adjust_capture_position != 0) {
 731                 capture_captured += adjust_capture_position;
 732                 adjust_capture_position = 0;
 733         }
 734
 735         if (_slaved) {
 736                 if (_io && _io->active()) {
 737                         need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
 738                 } else {
 739                         need_butler = false;
 740                 }
 741         } else {
 742                 if (_io && _io->active()) {
 743                         need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
 744                                 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
 745                 } else {
 746                         need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
 747                 }
 748         }
 749
 750         if (commit_should_unlock) {
 751                 state_lock.unlock();
 752         }
 753
 754         _processed = false;
 755
 756         return need_butler;
 757 }
 758
 759 void
 760 AudioDiskstream::set_pending_overwrite (bool yn)
 761 {
 762         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 763
 764         pending_overwrite = yn;
 765
 766         overwrite_frame = playback_sample;
 767         overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
 768 }
 769
 770 int
 771 AudioDiskstream::overwrite_existing_buffers ()
 772 {
 773         boost::shared_ptr<ChannelList> c = channels.reader();
 774         Sample* mixdown_buffer;
 775         float* gain_buffer;
 776         int ret = -1;
 777         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
 778
 779         overwrite_queued = false;
 780
 781         /* assume all are the same size */
 782         nframes_t size = c->front()->playback_buf->bufsize();
 783
 784         mixdown_buffer = new Sample[size];
 785         gain_buffer = new float[size];
 786
 787         /* reduce size so that we can fill the buffer correctly. */
 788         size--;
 789
 790         uint32_t n=0;
 791         nframes_t start;
 792
 793         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 794
 795                 start = overwrite_frame;
 796                 nframes_t cnt = size;
 797
 798                 /* to fill the buffer without resetting the playback sample, we need to
 799                    do it one or two chunks (normally two).
 800
 801                    |----------------------------------------------------------------------|
 802
 803                                        ^
 804                                        overwrite_offset
 805                     |<- second chunk->||<----------------- first chunk ------------------>|
 806
 807                 */
 808
 809                 nframes_t to_read = size - overwrite_offset;
 810
 811                 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
 812                         error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 813                                          _id, size, playback_sample) << endmsg;
 814                         goto out;
 815                 }
 816
 817                 if (cnt > to_read) {
 818
 819                         cnt -= to_read;
 820
 821                         if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
 822                                   start, cnt, *chan, n, reversed)) {
 823                                 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 824                                                  _id, size, playback_sample) << endmsg;
 825                                 goto out;
 826                         }
 827                 }
 828         }
 829
 830         ret = 0;
 831
 832   out:
 833         pending_overwrite = false;
 834         delete [] gain_buffer;
 835         delete [] mixdown_buffer;
 836         return ret;
 837 }
 838
 839 int
 840 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 841 {
 842         uint32_t n;
 843         int ret = -1;
 844         ChannelList::iterator chan;
 845         boost::shared_ptr<ChannelList> c = channels.reader();
 846
 847         Glib::Mutex::Lock lm (state_lock);
 848
 849         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 850                 (*chan)->playback_buf->reset ();
 851                 (*chan)->capture_buf->reset ();
 852         }
 853
 854         /* can't rec-enable in destructive mode if transport is before start */
 855
 856         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 857                 disengage_record_enable ();
 858         }
 859
 860         playback_sample = frame;
 861         file_frame = frame;
 862
 863         if (complete_refill) {
 864                 while ((ret = do_refill_with_alloc ()) > 0) ;
 865         } else {
 866                 ret = do_refill_with_alloc ();
 867         }
 868
 869         return ret;
 870 }
 871
 872 int
 873 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
 874 {
 875         ChannelList::iterator chan;
 876         boost::shared_ptr<ChannelList> c = channels.reader();
 877
 878         for (chan = c->begin(); chan != c->end(); ++chan) {
 879                 if ((*chan)->playback_buf->read_space() < distance) {
 880                         return false;
 881                 }
 882         }
 883         return true;
 884 }
 885
 886 int
 887 AudioDiskstream::internal_playback_seek (nframes_t distance)
 888 {
 889         ChannelList::iterator chan;
 890         boost::shared_ptr<ChannelList> c = channels.reader();
 891
 892         for (chan = c->begin(); chan != c->end(); ++chan) {
 893                 (*chan)->playback_buf->increment_read_ptr (distance);
 894         }
 895
 896         first_recordable_frame += distance;
 897         playback_sample += distance;
 898
 899         return 0;
 900 }
 901
 902 int
 903 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
 904                        ChannelInfo* /*channel_info*/, int channel, bool reversed)
 905 {
 906         nframes_t this_read = 0;
 907         bool reloop = false;
 908         nframes_t loop_end = 0;
 909         nframes_t loop_start = 0;
 910         nframes_t offset = 0;
 911         Location *loc = 0;
 912
 913         /* XXX we don't currently play loops in reverse. not sure why */
 914
 915         if (!reversed) {
 916
 917                 nframes_t loop_length = 0;
 918
 919                 /* Make the use of a Location atomic for this read operation.
 920
 921                    Note: Locations don't get deleted, so all we care about
 922                    when I say "atomic" is that we are always pointing to
 923                    the same one and using a start/length values obtained
 924                    just once.
 925                 */
 926
 927                 if ((loc = loop_location) != 0) {
 928                         loop_start = loc->start();
 929                         loop_end = loc->end();
 930                         loop_length = loop_end - loop_start;
 931                 }
 932
 933                 /* if we are looping, ensure that the first frame we read is at the correct
 934                    position within the loop.
 935                 */
 936
 937                 if (loc && start >= loop_end) {
 938                         //cerr << "start adjusted from " << start;
 939                         start = loop_start + ((start - loop_start) % loop_length);
 940                         //cerr << "to " << start << endl;
 941                 }
 942
 943                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 944         }
 945
 946         while (cnt) {
 947
 948                 if (reversed) {
 949                         start -= cnt;
 950                 }
 951
 952                 /* take any loop into account. we can't read past the end of the loop. */
 953
 954                 if (loc && (loop_end - start < cnt)) {
 955                         this_read = loop_end - start;
 956                         //cerr << "reloop true: thisread: " << this_read << "  cnt: " << cnt << endl;
 957                         reloop = true;
 958                 } else {
 959                         reloop = false;
 960                         this_read = cnt;
 961                 }
 962
 963                 if (this_read == 0) {
 964                         break;
 965                 }
 966
 967                 this_read = min(cnt,this_read);
 968
 969                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 970                         error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
 971                                          start) << endmsg;
 972                         return -1;
 973                 }
 974
 975                 _read_data_count = _playlist->read_data_count();
 976
 977                 if (reversed) {
 978
 979                         swap_by_ptr (buf, buf + this_read - 1);
 980
 981                 } else {
 982
 983                         /* if we read to the end of the loop, go back to the beginning */
 984
 985                         if (reloop) {
 986                                 start = loop_start;
 987                         } else {
 988                                 start += this_read;
 989                         }
 990                 }
 991
 992                 cnt -= this_read;
 993                 offset += this_read;
 994         }
 995
 996         return 0;
 997 }
 998
 999 int
1000 AudioDiskstream::do_refill_with_alloc ()
1001 {
1002         Sample* mix_buf  = new Sample[disk_io_chunk_frames];
1003         float*  gain_buf = new float[disk_io_chunk_frames];
1004
1005         int ret = _do_refill(mix_buf, gain_buf);
1006
1007         delete [] mix_buf;
1008         delete [] gain_buf;
1009
1010         return ret;
1011 }
1012
1013 int
1014 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1015 {
1016         int32_t ret = 0;
1017         nframes_t to_read;
1018         RingBufferNPT<Sample>::rw_vector vector;
1019         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1020         nframes_t total_space;
1021         nframes_t zero_fill;
1022         uint32_t chan_n;
1023         ChannelList::iterator i;
1024         boost::shared_ptr<ChannelList> c = channels.reader();
1025         nframes_t ts;
1026
1027         if (c->empty()) {
1028                 return 0;
1029         }
1030
1031         assert(mixdown_buffer);
1032         assert(gain_buffer);
1033
1034         vector.buf[0] = 0;
1035         vector.len[0] = 0;
1036         vector.buf[1] = 0;
1037         vector.len[1] = 0;
1038
1039         c->front()->playback_buf->get_write_vector (&vector);
1040
1041         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1042                 return 0;
1043         }
1044
1045         /* if there are 2+ chunks of disk i/o possible for
1046            this track, let the caller know so that it can arrange
1047            for us to be called again, ASAP.
1048         */
1049
1050         if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1051                 ret = 1;
1052         }
1053
1054         /* if we're running close to normal speed and there isn't enough
1055            space to do disk_io_chunk_frames of I/O, then don't bother.
1056
1057            at higher speeds, just do it because the sync between butler
1058            and audio thread may not be good enough.
1059         */
1060
1061         if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1062                 return 0;
1063         }
1064
1065         /* when slaved, don't try to get too close to the read pointer. this
1066            leaves space for the buffer reversal to have something useful to
1067            work with.
1068         */
1069
1070         if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1071                 return 0;
1072         }
1073
1074         /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1075
1076         total_space = min (disk_io_chunk_frames, total_space);
1077
1078         if (reversed) {
1079
1080                 if (file_frame == 0) {
1081
1082                         /* at start: nothing to do but fill with silence */
1083
1084                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1085
1086                                 ChannelInfo* chan (*i);
1087                                 chan->playback_buf->get_write_vector (&vector);
1088                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1089                                 if (vector.len[1]) {
1090                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1091                                 }
1092                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1093                         }
1094                         return 0;
1095                 }
1096
1097                 if (file_frame < total_space) {
1098
1099                         /* too close to the start: read what we can,
1100                            and then zero fill the rest
1101                         */
1102
1103                         zero_fill = total_space - file_frame;
1104                         total_space = file_frame;
1105                         file_frame = 0;
1106
1107                 } else {
1108
1109                         zero_fill = 0;
1110                 }
1111
1112         } else {
1113
1114                 if (file_frame == max_frames) {
1115
1116                         /* at end: nothing to do but fill with silence */
1117
1118                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1119
1120                                 ChannelInfo* chan (*i);
1121                                 chan->playback_buf->get_write_vector (&vector);
1122                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1123                                 if (vector.len[1]) {
1124                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1125                                 }
1126                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1127                         }
1128                         return 0;
1129                 }
1130
1131                 if (file_frame > max_frames - total_space) {
1132
1133                         /* to close to the end: read what we can, and zero fill the rest */
1134
1135                         zero_fill = total_space - (max_frames - file_frame);
1136                         total_space = max_frames - file_frame;
1137
1138                 } else {
1139                         zero_fill = 0;
1140                 }
1141         }
1142
1143         nframes_t file_frame_tmp = 0;
1144
1145         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1146
1147                 ChannelInfo* chan (*i);
1148                 Sample* buf1;
1149                 Sample* buf2;
1150                 nframes_t len1, len2;
1151
1152                 chan->playback_buf->get_write_vector (&vector);
1153
1154                 if (vector.len[0] > disk_io_chunk_frames) {
1155
1156                         /* we're not going to fill the first chunk, so certainly do not bother with the
1157                            other part. it won't be connected with the part we do fill, as in:
1158
1159                            .... => writable space
1160                            ++++ => readable space
1161                            ^^^^ => 1 x disk_io_chunk_frames that would be filled
1162
1163                            |......|+++++++++++++|...............................|
1164                            buf1                buf0
1165                                                 ^^^^^^^^^^^^^^^
1166
1167
1168                            So, just pretend that the buf1 part isn't there.
1169
1170                         */
1171
1172                         vector.buf[1] = 0;
1173                         vector.len[1] = 0;
1174
1175                 }
1176
1177                 ts = total_space;
1178                 file_frame_tmp = file_frame;
1179
1180                 buf1 = vector.buf[0];
1181                 len1 = vector.len[0];
1182                 buf2 = vector.buf[1];
1183                 len2 = vector.len[1];
1184
1185                 to_read = min (ts, len1);
1186                 to_read = min (to_read, disk_io_chunk_frames);
1187
1188                 if (to_read) {
1189
1190                         if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1191                                 ret = -1;
1192                                 goto out;
1193                         }
1194
1195                         chan->playback_buf->increment_write_ptr (to_read);
1196                         ts -= to_read;
1197                 }
1198
1199                 to_read = min (ts, len2);
1200
1201                 if (to_read) {
1202
1203                         /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1204                            so read some or all of vector.len[1] as well.
1205                         */
1206
1207                         if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1208                                 ret = -1;
1209                                 goto out;
1210                         }
1211
1212                         chan->playback_buf->increment_write_ptr (to_read);
1213                 }
1214
1215                 if (zero_fill) {
1216                         /* do something */
1217                 }
1218
1219         }
1220
1221         file_frame = file_frame_tmp;
1222
1223   out:
1224
1225         return ret;
1226 }
1227
1228 /** Flush pending data to disk.
1229  *
1230  * Important note: this function will write *AT MOST* disk_io_chunk_frames
1231  * of data to disk. it will never write more than that.  If it writes that
1232  * much and there is more than that waiting to be written, it will return 1,
1233  * otherwise 0 on success or -1 on failure.
1234  *
1235  * If there is less than disk_io_chunk_frames to be written, no data will be
1236  * written at all unless @a force_flush is true.
1237  */
1238 int
1239 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1240 {
1241         uint32_t to_write;
1242         int32_t ret = 0;
1243         RingBufferNPT<Sample>::rw_vector vector;
1244         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1245         nframes_t total;
1246
1247         _write_data_count = 0;
1248
1249         transvec.buf[0] = 0;
1250         transvec.buf[1] = 0;
1251         vector.buf[0] = 0;
1252         vector.buf[1] = 0;
1253
1254         boost::shared_ptr<ChannelList> c = channels.reader();
1255         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1256
1257                 (*chan)->capture_buf->get_read_vector (&vector);
1258
1259                 total = vector.len[0] + vector.len[1];
1260
1261                 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1262                         goto out;
1263                 }
1264
1265                 /* if there are 2+ chunks of disk i/o possible for
1266                    this track, let the caller know so that it can arrange
1267                    for us to be called again, ASAP.
1268
1269                    if we are forcing a flush, then if there is* any* extra
1270                    work, let the caller know.
1271
1272                    if we are no longer recording and there is any extra work,
1273                    let the caller know too.
1274                 */
1275
1276                 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1277                         ret = 1;
1278                 }
1279
1280                 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1281
1282                 // check the transition buffer when recording destructive
1283                 // important that we get this after the capture buf
1284
1285                 if (destructive()) {
1286                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
1287                         size_t transcount = transvec.len[0] + transvec.len[1];
1288                         bool have_start = false;
1289                         size_t ti;
1290
1291                         for (ti=0; ti < transcount; ++ti) {
1292                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1293
1294                                 if (captrans.type == CaptureStart) {
1295                                         // by definition, the first data we got above represents the given capture pos
1296
1297                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
1298                                         (*chan)->curr_capture_cnt = 0;
1299
1300                                         have_start = true;
1301                                 }
1302                                 else if (captrans.type == CaptureEnd) {
1303
1304                                         // capture end, the capture_val represents total frames in capture
1305
1306                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1307
1308                                                 // shorten to make the write a perfect fit
1309                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1310
1311                                                 if (nto_write < to_write) {
1312                                                         ret = 1; // should we?
1313                                                 }
1314                                                 to_write = nto_write;
1315
1316                                                 (*chan)->write_source->mark_capture_end ();
1317
1318                                                 // increment past this transition, but go no further
1319                                                 ++ti;
1320                                                 break;
1321                                         }
1322                                         else {
1323                                                 // actually ends just beyond this chunk, so force more work
1324                                                 ret = 1;
1325                                                 break;
1326                                         }
1327                                 }
1328                         }
1329
1330                         if (ti > 0) {
1331                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1332                         }
1333                 }
1334
1335                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1336                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1337                         return -1;
1338                 }
1339
1340                 (*chan)->capture_buf->increment_read_ptr (to_write);
1341                 (*chan)->curr_capture_cnt += to_write;
1342
1343                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1344
1345                         /* we wrote all of vector.len[0] but it wasn't an entire
1346                            disk_io_chunk_frames of data, so arrange for some part
1347                            of vector.len[1] to be flushed to disk as well.
1348                         */
1349
1350                         to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1351
1352                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1353                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1354                                 return -1;
1355                         }
1356
1357                         _write_data_count += (*chan)->write_source->write_data_count();
1358
1359                         (*chan)->capture_buf->increment_read_ptr (to_write);
1360                         (*chan)->curr_capture_cnt += to_write;
1361                 }
1362         }
1363
1364   out:
1365         return ret;
1366 }
1367
1368 void
1369 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1370 {
1371         uint32_t buffer_position;
1372         bool more_work = true;
1373         int err = 0;
1374         boost::shared_ptr<AudioRegion> region;
1375         nframes_t total_capture;
1376         SourceList srcs;
1377         SourceList::iterator src;
1378         ChannelList::iterator chan;
1379         vector<CaptureInfo*>::iterator ci;
1380         boost::shared_ptr<ChannelList> c = channels.reader();
1381         uint32_t n = 0;
1382         bool mark_write_completed = false;
1383
1384         finish_capture (true, c);
1385
1386         /* butler is already stopped, but there may be work to do
1387            to flush remaining data to disk.
1388         */
1389
1390         while (more_work && !err) {
1391                 switch (do_flush (TransportContext, true)) {
1392                 case 0:
1393                         more_work = false;
1394                         break;
1395                 case 1:
1396                         break;
1397                 case -1:
1398                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1399                         err++;
1400                 }
1401         }
1402
1403         /* XXX is there anything we can do if err != 0 ? */
1404         Glib::Mutex::Lock lm (capture_info_lock);
1405
1406         if (capture_info.empty()) {
1407                 return;
1408         }
1409
1410         if (abort_capture) {
1411
1412                 if (destructive()) {
1413                         goto outout;
1414                 }
1415
1416                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1417
1418                         if ((*chan)->write_source) {
1419
1420                                 (*chan)->write_source->mark_for_remove ();
1421                                 (*chan)->write_source->drop_references ();
1422                                 (*chan)->write_source.reset ();
1423                         }
1424
1425                         /* new source set up in "out" below */
1426                 }
1427
1428                 goto out;
1429         }
1430
1431         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1432                 total_capture += (*ci)->frames;
1433         }
1434
1435         /* figure out the name for this take */
1436
1437         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1438
1439                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1440
1441                 if (s) {
1442                         srcs.push_back (s);
1443                         s->update_header (capture_info.front()->start, when, twhen);
1444                         s->set_captured_for (_name.val());
1445                         s->mark_immutable ();
1446                         if (Config->get_auto_analyse_audio()) {
1447                                 Analyser::queue_source_for_analysis (s, true);
1448                         }
1449                 }
1450         }
1451
1452         /* destructive tracks have a single, never changing region */
1453
1454         if (destructive()) {
1455
1456                 /* send a signal that any UI can pick up to do the right thing. there is
1457                    a small problem here in that a UI may need the peak data to be ready
1458                    for the data that was recorded and this isn't interlocked with that
1459                    process. this problem is deferred to the UI.
1460                  */
1461
1462                 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1463
1464         } else {
1465
1466                 string whole_file_region_name;
1467                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1468
1469                 /* Register a new region with the Session that
1470                    describes the entire source. Do this first
1471                    so that any sub-regions will obviously be
1472                    children of this one (later!)
1473                 */
1474
1475                 try {
1476                         PropertyList plist;
1477
1478                         plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1479                         plist.add (Properties::length, total_capture);
1480                         plist.add (Properties::name, whole_file_region_name);
1481
1482                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1483                         rx->set_automatic (true);
1484                         rx->set_whole_file (true);
1485
1486                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1487                         region->special_set_position (capture_info.front()->start);
1488                 }
1489
1490
1491                 catch (failed_constructor& err) {
1492                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1493                         /* XXX what now? */
1494                 }
1495
1496                 _last_capture_regions.push_back (region);
1497
1498                 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1499
1500                 XMLNode &before = _playlist->get_state();
1501                 _playlist->freeze ();
1502
1503                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1504
1505                         string region_name;
1506
1507                         _session.region_name (region_name, whole_file_region_name, false);
1508
1509                         // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1510
1511                         try {
1512
1513                                 PropertyList plist;
1514
1515                                 plist.add (Properties::start, buffer_position);
1516                                 plist.add (Properties::length, (*ci)->frames);
1517                                 plist.add (Properties::name, region_name);
1518
1519                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1520                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1521                         }
1522
1523                         catch (failed_constructor& err) {
1524                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1525                                 continue; /* XXX is this OK? */
1526                         }
1527
1528                         region->DropReferences.connect_same_thread (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
1529
1530                         _last_capture_regions.push_back (region);
1531
1532                         i_am_the_modifier++;
1533                         _playlist->add_region (region, (*ci)->start, 1, non_layered());
1534                         i_am_the_modifier--;
1535
1536                         buffer_position += (*ci)->frames;
1537                 }
1538
1539                 _playlist->thaw ();
1540                 XMLNode &after = _playlist->get_state();
1541                 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1542         }
1543
1544         mark_write_completed = true;
1545
1546   out:
1547         reset_write_sources (mark_write_completed);
1548
1549   outout:
1550
1551         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1552                 delete *ci;
1553         }
1554
1555         capture_info.clear ();
1556         capture_start_frame = 0;
1557 }
1558
1559 void
1560 AudioDiskstream::transport_looped (nframes_t transport_frame)
1561 {
1562         if (was_recording) {
1563                 // all we need to do is finish this capture, with modified capture length
1564                 boost::shared_ptr<ChannelList> c = channels.reader();
1565
1566                 // adjust the capture length knowing that the data will be recorded to disk
1567                 // only necessary after the first loop where we're recording
1568                 if (capture_info.size() == 0) {
1569                         capture_captured += _capture_offset;
1570
1571                         if (_alignment_style == ExistingMaterial) {
1572                                 capture_captured += _session.worst_output_latency();
1573                         } else {
1574                                 capture_captured += _roll_delay;
1575                         }
1576                 }
1577
1578                 finish_capture (true, c);
1579
1580                 // the next region will start recording via the normal mechanism
1581                 // we'll set the start position to the current transport pos
1582                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1583                 capture_start_frame = transport_frame;
1584                 first_recordable_frame = transport_frame; // mild lie
1585                 last_recordable_frame = max_frames;
1586                 was_recording = true;
1587
1588                 if (recordable() && destructive()) {
1589                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1590
1591                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1592                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1593
1594                                 if (transvec.len[0] > 0) {
1595                                         transvec.buf[0]->type = CaptureStart;
1596                                         transvec.buf[0]->capture_val = capture_start_frame;
1597                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1598                                 }
1599                                 else {
1600                                         // bad!
1601                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1602                                               << endmsg;
1603                                 }
1604                         }
1605                 }
1606
1607         }
1608 }
1609
1610 void
1611 AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
1612 {
1613         was_recording = false;
1614
1615         if (capture_captured == 0) {
1616                 return;
1617         }
1618
1619         if (recordable() && destructive()) {
1620                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1621
1622                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1623                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1624
1625                         if (transvec.len[0] > 0) {
1626                                 transvec.buf[0]->type = CaptureEnd;
1627                                 transvec.buf[0]->capture_val = capture_captured;
1628                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1629                         }
1630                         else {
1631                                 // bad!
1632                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1633                         }
1634                 }
1635         }
1636
1637
1638         CaptureInfo* ci = new CaptureInfo;
1639
1640         ci->start =  capture_start_frame;
1641         ci->frames = capture_captured;
1642
1643         /* XXX theoretical race condition here. Need atomic exchange ?
1644            However, the circumstances when this is called right
1645            now (either on record-disable or transport_stopped)
1646            mean that no actual race exists. I think ...
1647            We now have a capture_info_lock, but it is only to be used
1648            to synchronize in the transport_stop and the capture info
1649            accessors, so that invalidation will not occur (both non-realtime).
1650         */
1651
1652         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1653
1654         capture_info.push_back (ci);
1655         capture_captured = 0;
1656
1657         /* now we've finished a capture, reset first_recordable_frame for next time */
1658         first_recordable_frame = max_frames;
1659 }
1660
1661 void
1662 AudioDiskstream::set_record_enabled (bool yn)
1663 {
1664         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1665                 return;
1666         }
1667
1668         /* can't rec-enable in destructive mode if transport is before start */
1669
1670         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1671                 return;
1672         }
1673
1674         /* yes, i know that this not proof against race conditions, but its
1675            good enough. i think.
1676         */
1677
1678         if (record_enabled() != yn) {
1679                 if (yn) {
1680                         engage_record_enable ();
1681                 } else {
1682                         disengage_record_enable ();
1683                 }
1684         }
1685 }
1686
1687 void
1688 AudioDiskstream::engage_record_enable ()
1689 {
1690         bool rolling = _session.transport_speed() != 0.0f;
1691         boost::shared_ptr<ChannelList> c = channels.reader();
1692
1693         g_atomic_int_set (&_record_enabled, 1);
1694         capturing_sources.clear ();
1695
1696         if (Config->get_monitoring_model() == HardwareMonitoring) {
1697
1698                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1699                         if ((*chan)->source) {
1700                                 (*chan)->source->ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
1701                         }
1702                         capturing_sources.push_back ((*chan)->write_source);
1703                         (*chan)->write_source->mark_streaming_write_started ();
1704                 }
1705
1706         } else {
1707                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1708                         capturing_sources.push_back ((*chan)->write_source);
1709                         (*chan)->write_source->mark_streaming_write_started ();
1710                 }
1711         }
1712
1713         RecordEnableChanged (); /* EMIT SIGNAL */
1714 }
1715
1716 void
1717 AudioDiskstream::disengage_record_enable ()
1718 {
1719         g_atomic_int_set (&_record_enabled, 0);
1720         boost::shared_ptr<ChannelList> c = channels.reader();
1721         if (Config->get_monitoring_model() == HardwareMonitoring) {
1722                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1723                         if ((*chan)->source) {
1724                                 (*chan)->source->ensure_monitor_input (false);
1725                         }
1726                 }
1727         }
1728         capturing_sources.clear ();
1729         RecordEnableChanged (); /* EMIT SIGNAL */
1730 }
1731
1732 XMLNode&
1733 AudioDiskstream::get_state ()
1734 {
1735         XMLNode* node = new XMLNode ("AudioDiskstream");
1736         char buf[64] = "";
1737         LocaleGuard lg (X_("POSIX"));
1738         boost::shared_ptr<ChannelList> c = channels.reader();
1739
1740         node->add_property ("flags", enum_2_string (_flags));
1741
1742         snprintf (buf, sizeof(buf), "%zd", c->size());
1743         node->add_property ("channels", buf);
1744
1745         node->add_property ("playlist", _playlist->name());
1746
1747         snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1748         node->add_property ("speed", buf);
1749
1750         node->add_property("name", _name);
1751         id().print (buf, sizeof (buf));
1752         node->add_property("id", buf);
1753
1754         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1755
1756                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1757                 XMLNode* cs_grandchild;
1758
1759                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1760                         cs_grandchild = new XMLNode (X_("file"));
1761                         cs_grandchild->add_property (X_("path"), (*i)->path());
1762                         cs_child->add_child_nocopy (*cs_grandchild);
1763                 }
1764
1765                 /* store the location where capture will start */
1766
1767                 Location* pi;
1768
1769                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1770                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1771                 } else {
1772                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1773                 }
1774
1775                 cs_child->add_property (X_("at"), buf);
1776                 node->add_child_nocopy (*cs_child);
1777         }
1778
1779         if (_extra_xml) {
1780                 node->add_child_copy (*_extra_xml);
1781         }
1782
1783         return* node;
1784 }
1785
1786 int
1787 AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
1788 {
1789         const XMLProperty* prop;
1790         XMLNodeList nlist = node.children();
1791         XMLNodeIterator niter;
1792         uint32_t nchans = 1;
1793         XMLNode* capture_pending_node = 0;
1794         LocaleGuard lg (X_("POSIX"));
1795
1796         in_set_state = true;
1797
1798         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1799                 if ((*niter)->name() == IO::state_node_name) {
1800                         deprecated_io_node = new XMLNode (**niter);
1801                 }
1802
1803                 if ((*niter)->name() == X_("CapturingSources")) {
1804                         capture_pending_node = *niter;
1805                 }
1806         }
1807
1808         /* prevent write sources from being created */
1809
1810         in_set_state = true;
1811
1812         if ((prop = node.property ("name")) != 0) {
1813                 _name = prop->value();
1814         }
1815
1816         if (deprecated_io_node) {
1817                 if ((prop = deprecated_io_node->property ("id")) != 0) {
1818                         _id = prop->value ();
1819                 }
1820         } else {
1821                 if ((prop = node.property ("id")) != 0) {
1822                         _id = prop->value ();
1823                 }
1824         }
1825
1826         if ((prop = node.property ("flags")) != 0) {
1827                 _flags = Flag (string_2_enum (prop->value(), _flags));
1828         }
1829
1830         if ((prop = node.property ("channels")) != 0) {
1831                 nchans = atoi (prop->value().c_str());
1832         }
1833
1834         // create necessary extra channels
1835         // we are always constructed with one and we always need one
1836
1837         _n_channels.set(DataType::AUDIO, channels.reader()->size());
1838
1839         if (nchans > _n_channels.n_audio()) {
1840
1841                 add_channel (nchans - _n_channels.n_audio());
1842                 IO::PortCountChanged(_n_channels);
1843
1844         } else if (nchans < _n_channels.n_audio()) {
1845
1846                 remove_channel (_n_channels.n_audio() - nchans);
1847         }
1848
1849         if ((prop = node.property ("playlist")) == 0) {
1850                 return -1;
1851         }
1852
1853         {
1854                 bool had_playlist = (_playlist != 0);
1855
1856                 if (find_and_use_playlist (prop->value())) {
1857                         return -1;
1858                 }
1859
1860                 if (!had_playlist) {
1861                         _playlist->set_orig_diskstream_id (_id);
1862                 }
1863
1864                 if (!destructive() && capture_pending_node) {
1865                         /* destructive streams have one and only one source per channel,
1866                            and so they never end up in pending capture in any useful
1867                            sense.
1868                         */
1869                         use_pending_capture_data (*capture_pending_node);
1870                 }
1871
1872         }
1873
1874         if ((prop = node.property ("speed")) != 0) {
1875                 double sp = atof (prop->value().c_str());
1876
1877                 if (realtime_set_speed (sp, false)) {
1878                         non_realtime_set_speed ();
1879                 }
1880         }
1881
1882         in_set_state = false;
1883
1884         /* make sure this is clear before we do anything else */
1885
1886         capturing_sources.clear ();
1887
1888         /* write sources are handled when we handle the input set
1889            up of the IO that owns this DS (::non_realtime_input_change())
1890         */
1891
1892         return 0;
1893 }
1894
1895 int
1896 AudioDiskstream::use_new_write_source (uint32_t n)
1897 {
1898         boost::shared_ptr<ChannelList> c = channels.reader();
1899
1900         if (!recordable()) {
1901                 return 1;
1902         }
1903
1904         if (n >= c->size()) {
1905                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1906                 return -1;
1907         }
1908
1909         ChannelInfo* chan = (*c)[n];
1910
1911         if (chan->write_source) {
1912                 chan->write_source->done_with_peakfile_writes ();
1913                 chan->write_source->set_allow_remove_if_empty (true);
1914                 chan->write_source.reset ();
1915         }
1916
1917         try {
1918                 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
1919                         throw failed_constructor();
1920                 }
1921         }
1922
1923         catch (failed_constructor &err) {
1924                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1925                 chan->write_source.reset ();
1926                 return -1;
1927         }
1928
1929         /* do not remove destructive files even if they are empty */
1930
1931         chan->write_source->set_allow_remove_if_empty (!destructive());
1932
1933         /* until we write, this file is considered removable */
1934
1935         chan->write_source->mark_for_remove ();
1936
1937         return 0;
1938 }
1939
1940 void
1941 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1942 {
1943         ChannelList::iterator chan;
1944         boost::shared_ptr<ChannelList> c = channels.reader();
1945         uint32_t n;
1946
1947         if (!_session.writable() || !recordable()) {
1948                 return;
1949         }
1950
1951         capturing_sources.clear ();
1952
1953         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1954                 if (!destructive()) {
1955
1956                         if ((*chan)->write_source && mark_write_complete) {
1957                                 (*chan)->write_source->mark_streaming_write_completed ();
1958                         }
1959                         use_new_write_source (n);
1960
1961                         if (record_enabled()) {
1962                                 capturing_sources.push_back ((*chan)->write_source);
1963                         }
1964
1965                 } else {
1966                         if ((*chan)->write_source == 0) {
1967                                 use_new_write_source (n);
1968                         }
1969                 }
1970         }
1971
1972         if (destructive()) {
1973
1974                 /* we now have all our write sources set up, so create the
1975                    playlist's single region.
1976                 */
1977
1978                 if (_playlist->empty()) {
1979                         setup_destructive_playlist ();
1980                 }
1981         }
1982 }
1983
1984 int
1985 AudioDiskstream::rename_write_sources ()
1986 {
1987         ChannelList::iterator chan;
1988         boost::shared_ptr<ChannelList> c = channels.reader();
1989         uint32_t n;
1990
1991         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1992                 if ((*chan)->write_source != 0) {
1993                         (*chan)->write_source->set_source_name (_name.val(), destructive());
1994                         /* XXX what to do if one of them fails ? */
1995                 }
1996         }
1997
1998         return 0;
1999 }
2000
2001 void
2002 AudioDiskstream::set_block_size (nframes_t /*nframes*/)
2003 {
2004         if (_session.get_block_size() > speed_buffer_size) {
2005                 speed_buffer_size = _session.get_block_size();
2006                 boost::shared_ptr<ChannelList> c = channels.reader();
2007
2008                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2009                         if ((*chan)->speed_buffer)
2010                                 delete [] (*chan)->speed_buffer;
2011                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
2012                 }
2013         }
2014         allocate_temporary_buffers ();
2015 }
2016
2017 void
2018 AudioDiskstream::allocate_temporary_buffers ()
2019 {
2020         /* make sure the wrap buffer is at least large enough to deal
2021            with the speeds up to 1.2, to allow for micro-variation
2022            when slaving to MTC, Timecode etc.
2023         */
2024
2025         double sp = max (fabsf (_actual_speed), 1.2f);
2026         nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2027
2028         if (required_wrap_size > wrap_buffer_size) {
2029
2030                 boost::shared_ptr<ChannelList> c = channels.reader();
2031
2032                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2033                         if ((*chan)->playback_wrap_buffer)
2034                                 delete [] (*chan)->playback_wrap_buffer;
2035                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2036                         if ((*chan)->capture_wrap_buffer)
2037                                 delete [] (*chan)->capture_wrap_buffer;
2038                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2039                 }
2040
2041                 wrap_buffer_size = required_wrap_size;
2042         }
2043 }
2044
2045 void
2046 AudioDiskstream::monitor_input (bool yn)
2047 {
2048         boost::shared_ptr<ChannelList> c = channels.reader();
2049
2050         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2051
2052                 if ((*chan)->source) {
2053                         (*chan)->source->ensure_monitor_input (yn);
2054                 }
2055         }
2056 }
2057
2058 void
2059 AudioDiskstream::set_align_style_from_io ()
2060 {
2061         bool have_physical = false;
2062
2063         if (_io == 0) {
2064                 return;
2065         }
2066
2067         get_input_sources ();
2068
2069         boost::shared_ptr<ChannelList> c = channels.reader();
2070
2071         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2072                 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2073                         have_physical = true;
2074                         break;
2075                 }
2076         }
2077
2078         if (have_physical) {
2079                 set_align_style (ExistingMaterial);
2080         } else {
2081                 set_align_style (CaptureTime);
2082         }
2083 }
2084
2085 int
2086 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2087 {
2088         while (how_many--) {
2089                 c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2090                 interpolation.add_channel_to (_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size);
2091         }
2092
2093         _n_channels.set(DataType::AUDIO, c->size());
2094
2095         return 0;
2096 }
2097
2098 int
2099 AudioDiskstream::add_channel (uint32_t how_many)
2100 {
2101         RCUWriter<ChannelList> writer (channels);
2102         boost::shared_ptr<ChannelList> c = writer.get_copy();
2103
2104         return add_channel_to (c, how_many);
2105 }
2106
2107 int
2108 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2109 {
2110         while (how_many-- && !c->empty()) {
2111                 // FIXME: crash (thread safe with RCU?)
2112                 // memory leak, when disabled.... :(
2113                 //delete c->back();
2114                 c->pop_back();
2115                 interpolation.remove_channel_from ();
2116         }
2117
2118         _n_channels.set(DataType::AUDIO, c->size());
2119
2120         return 0;
2121 }
2122
2123 int
2124 AudioDiskstream::remove_channel (uint32_t how_many)
2125 {
2126         RCUWriter<ChannelList> writer (channels);
2127         boost::shared_ptr<ChannelList> c = writer.get_copy();
2128
2129         return remove_channel_from (c, how_many);
2130 }
2131
2132 float
2133 AudioDiskstream::playback_buffer_load () const
2134 {
2135         boost::shared_ptr<ChannelList> c = channels.reader();
2136
2137         return (float) ((double) c->front()->playback_buf->read_space()/
2138                         (double) c->front()->playback_buf->bufsize());
2139 }
2140
2141 float
2142 AudioDiskstream::capture_buffer_load () const
2143 {
2144         boost::shared_ptr<ChannelList> c = channels.reader();
2145
2146         return (float) ((double) c->front()->capture_buf->write_space()/
2147                         (double) c->front()->capture_buf->bufsize());
2148 }
2149
2150 int
2151 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2152 {
2153         const XMLProperty* prop;
2154         XMLNodeList nlist = node.children();
2155         XMLNodeIterator niter;
2156         boost::shared_ptr<AudioFileSource> fs;
2157         boost::shared_ptr<AudioFileSource> first_fs;
2158         SourceList pending_sources;
2159         nframes_t position;
2160
2161         if ((prop = node.property (X_("at"))) == 0) {
2162                 return -1;
2163         }
2164
2165         if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2166                 return -1;
2167         }
2168
2169         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2170                 if ((*niter)->name() == X_("file")) {
2171
2172                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2173                                 continue;
2174                         }
2175
2176                         // This protects sessions from errant CapturingSources in stored sessions
2177                         struct stat sbuf;
2178                         if (stat (prop->value().c_str(), &sbuf)) {
2179                                 continue;
2180                         }
2181
2182                         try {
2183                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2184                                                 SourceFactory::createWritable (DataType::AUDIO, _session,
2185                                                                 prop->value(), false, _session.frame_rate()));
2186                         }
2187
2188                         catch (failed_constructor& err) {
2189                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2190                                                   _name, prop->value())
2191                                       << endmsg;
2192                                 return -1;
2193                         }
2194
2195                         pending_sources.push_back (fs);
2196
2197                         if (first_fs == 0) {
2198                                 first_fs = fs;
2199                         }
2200
2201                         fs->set_captured_for (_name.val());
2202                 }
2203         }
2204
2205         if (pending_sources.size() == 0) {
2206                 /* nothing can be done */
2207                 return 1;
2208         }
2209
2210         if (pending_sources.size() != _n_channels.n_audio()) {
2211                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2212                       << endmsg;
2213                 return -1;
2214         }
2215
2216         boost::shared_ptr<AudioRegion> region;
2217
2218         try {
2219
2220                 PropertyList plist;
2221
2222                 plist.add (Properties::start, 0);
2223                 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2224                 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2225
2226                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2227
2228                 region->set_automatic (true);
2229                 region->set_whole_file (true);
2230                 region->special_set_position (0);
2231         }
2232
2233         catch (failed_constructor& err) {
2234                 error << string_compose (
2235                                 _("%1: cannot create whole-file region from pending capture sources"),
2236                                 _name) << endmsg;
2237
2238                 return -1;
2239         }
2240
2241         _playlist->add_region (region, position);
2242
2243         return 0;
2244 }
2245
2246 int
2247 AudioDiskstream::set_non_layered (bool yn)
2248 {
2249         if (yn != non_layered()) {
2250
2251                 if (yn) {
2252                         _flags = Flag (_flags | NonLayered);
2253                 } else {
2254                         _flags = Flag (_flags & ~NonLayered);
2255                 }
2256         }
2257
2258         return 0;
2259 }
2260
2261 int
2262 AudioDiskstream::set_destructive (bool yn)
2263 {
2264         if (yn != destructive()) {
2265
2266                 if (yn) {
2267                         bool bounce_ignored;
2268                         /* requestor should already have checked this and
2269                            bounced if necessary and desired
2270                         */
2271                         if (!can_become_destructive (bounce_ignored)) {
2272                                 return -1;
2273                         }
2274                         _flags = Flag (_flags | Destructive);
2275                         use_destructive_playlist ();
2276                 } else {
2277                         _flags = Flag (_flags & ~Destructive);
2278                         reset_write_sources (true, true);
2279                 }
2280         }
2281
2282         return 0;
2283 }
2284
2285 bool
2286 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2287 {
2288         if (!_playlist) {
2289                 requires_bounce = false;
2290                 return false;
2291         }
2292
2293         /* is there only one region ? */
2294
2295         if (_playlist->n_regions() != 1) {
2296                 requires_bounce = true;
2297                 return false;
2298         }
2299
2300         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2301         assert (first);
2302
2303         /* do the source(s) for the region cover the session start position ? */
2304
2305         if (first->position() != _session.current_start_frame()) {
2306                 if (first->start() > _session.current_start_frame()) {
2307                         requires_bounce = true;
2308                         return false;
2309                 }
2310         }
2311
2312         /* is the source used by only 1 playlist ? */
2313
2314         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2315
2316         assert (afirst);
2317
2318         if (_session.playlists->source_use_count (afirst->source()) > 1) {
2319                 requires_bounce = true;
2320                 return false;
2321         }
2322
2323         requires_bounce = false;
2324         return true;
2325 }
2326
2327 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2328 {
2329         peak_power = 0.0f;
2330         source = 0;
2331         current_capture_buffer = 0;
2332         current_playback_buffer = 0;
2333         curr_capture_cnt = 0;
2334
2335         speed_buffer = new Sample[speed_size];
2336         playback_wrap_buffer = new Sample[wrap_size];
2337         capture_wrap_buffer = new Sample[wrap_size];
2338
2339         playback_buf = new RingBufferNPT<Sample> (bufsize);
2340         capture_buf = new RingBufferNPT<Sample> (bufsize);
2341         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2342
2343         /* touch the ringbuffer buffers, which will cause
2344            them to be mapped into locked physical RAM if
2345            we're running with mlockall(). this doesn't do
2346            much if we're not.
2347         */
2348
2349         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2350         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2351         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2352 }
2353
2354 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2355 {
2356         if (write_source) {
2357                 write_source.reset ();
2358         }
2359
2360         delete [] speed_buffer;
2361         speed_buffer = 0;
2362
2363         delete [] playback_wrap_buffer;
2364         playback_wrap_buffer = 0;
2365
2366         delete [] capture_wrap_buffer;
2367         capture_wrap_buffer = 0;
2368
2369         delete playback_buf;
2370         playback_buf = 0;
2371
2372         delete capture_buf;
2373         capture_buf = 0;
2374
2375         delete capture_transition_buf;
2376         capture_transition_buf = 0;
2377 }