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