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