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 (_flags & Recordable) {
 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                 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 559
 560                 switch (ot) {
 561                 case OverlapNone:
 562                         rec_nframes = 0;
 563                         break;
 564
 565                 case OverlapInternal:
 566                 /*     ----------    recrange
 567                          |---|       transrange
 568                 */
 569                         rec_nframes = nframes;
 570                         rec_offset = 0;
 571                         break;
 572
 573                 case OverlapStart:
 574                         /*    |--------|    recrange
 575                             -----|          transrange
 576                         */
 577                         rec_nframes = transport_frame + nframes - first_recordable_frame;
 578                         if (rec_nframes) {
 579                                 rec_offset = first_recordable_frame - transport_frame;
 580                         }
 581                         break;
 582
 583                 case OverlapEnd:
 584                         /*    |--------|    recrange
 585                                  |--------  transrange
 586                         */
 587                         rec_nframes = last_recordable_frame - transport_frame;
 588                         rec_offset = 0;
 589                         break;
 590
 591                 case OverlapExternal:
 592                         /*    |--------|    recrange
 593                             --------------  transrange
 594                         */
 595                         rec_nframes = last_recordable_frame - last_recordable_frame;
 596                         rec_offset = first_recordable_frame - transport_frame;
 597                         break;
 598                 }
 599
 600                 if (rec_nframes && !was_recording) {
 601                         capture_captured = 0;
 602                         was_recording = true;
 603                 }
 604         }
 605
 606
 607         if (can_record && !_last_capture_regions.empty()) {
 608                 _last_capture_regions.clear ();
 609         }
 610
 611         if (nominally_recording || rec_nframes) {
 612
 613                 uint32_t limit = _io->n_inputs ();
 614
 615                 /* one or more ports could already have been removed from _io, but our
 616                    channel setup hasn't yet been updated. prevent us from trying to
 617                    use channels that correspond to missing ports. note that the
 618                    process callback (from which this is called) is always atomic
 619                    with respect to port removal/addition.
 620                 */
 621
 622                 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
 623
 624                         ChannelInfo* chaninfo (*chan);
 625
 626                         chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
 627
 628                         if (rec_nframes <= chaninfo->capture_vector.len[0]) {
 629
 630                                 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
 631
 632                                 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
 633                                    rec_offset
 634                                 */
 635
 636                                 memcpy (chaninfo->current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
 637
 638                         } else {
 639
 640                                 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
 641
 642                                 if (rec_nframes > total) {
 643                                         DiskOverrun ();
 644                                         goto out;
 645                                 }
 646
 647                                 Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
 648                                 nframes_t first = chaninfo->capture_vector.len[0];
 649
 650                                 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
 651                                 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
 652                                 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
 653                                 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
 654
 655                                 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
 656                         }
 657                 }
 658
 659         } else {
 660
 661                 if (was_recording) {
 662                         finish_capture (rec_monitors_input, c);
 663                 }
 664
 665         }
 666
 667         if (rec_nframes) {
 668
 669                 /* data will be written to disk */
 670
 671                 if (rec_nframes == nframes && rec_offset == 0) {
 672
 673                         for (chan = c->begin(); chan != c->end(); ++chan) {
 674                                 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 675                         }
 676
 677                         playback_distance = nframes;
 678
 679                 } else {
 680
 681
 682                         /* we can't use the capture buffer as the playback buffer, because
 683                            we recorded only a part of the current process' cycle data
 684                            for capture.
 685                         */
 686
 687                         collect_playback = true;
 688                 }
 689
 690                 adjust_capture_position = rec_nframes;
 691
 692         } else if (nominally_recording) {
 693
 694                 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
 695
 696                 for (chan = c->begin(); chan != c->end(); ++chan) {
 697                         (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 698                 }
 699
 700                 playback_distance = nframes;
 701
 702         } else {
 703
 704                 collect_playback = true;
 705         }
 706
 707         if (collect_playback) {
 708
 709                 /* we're doing playback */
 710
 711                 nframes_t necessary_samples;
 712
 713                 /* no varispeed playback if we're recording, because the output .... TBD */
 714
 715                 if (rec_nframes == 0 && _actual_speed != 1.0f) {
 716                         necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
 717                 } else {
 718                         necessary_samples = nframes;
 719                 }
 720
 721                 for (chan = c->begin(); chan != c->end(); ++chan) {
 722                         (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
 723                 }
 724
 725                 n = 0;
 726
 727                 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 728
 729                         ChannelInfo* chaninfo (*chan);
 730
 731                         if (necessary_samples <= chaninfo->playback_vector.len[0]) {
 732
 733                                 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 734
 735                         } else {
 736                                 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
 737
 738                                 if (necessary_samples > total) {
 739                                         DiskUnderrun ();
 740                                         goto out;
 741
 742                                 } else {
 743
 744                                         memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
 745                                                 chaninfo->playback_vector.len[0] * sizeof (Sample));
 746                                         memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
 747                                                 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
 748
 749                                         chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
 750                                 }
 751                         }
 752                 }
 753
 754                 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 755
 756                         uint64_t phase = last_phase;
 757                         nframes_t i = 0;
 758
 759                         // Linearly interpolate into the alt buffer
 760                         // using 40.24 fixp maths (swh)
 761
 762                         for (chan = c->begin(); chan != c->end(); ++chan) {
 763
 764                                 float fr;
 765                                 ChannelInfo* chaninfo (*chan);
 766
 767                                 i = 0;
 768                                 phase = last_phase;
 769
 770                                 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
 771                                         i = phase >> 24;
 772                                         fr = (phase & 0xFFFFFF) / 16777216.0f;
 773                                         chaninfo->speed_buffer[outsample] =
 774                                                 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
 775                                                 chaninfo->current_playback_buffer[i+1] * fr;
 776                                         phase += phi;
 777                                 }
 778
 779                                 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
 780                         }
 781
 782                         playback_distance = i + 1;
 783                         last_phase = (phase & 0xFFFFFF);
 784
 785                 } else {
 786                         playback_distance = nframes;
 787                 }
 788
 789         }
 790
 791         ret = 0;
 792
 793   out:
 794         _processed = true;
 795
 796         if (ret) {
 797
 798                 /* we're exiting with failure, so ::commit will not
 799                    be called. unlock the state lock.
 800                 */
 801
 802                 commit_should_unlock = false;
 803                 state_lock.unlock();
 804         }
 805
 806         return ret;
 807 }
 808
 809 bool
 810 AudioDiskstream::commit (nframes_t nframes)
 811 {
 812         bool need_butler = false;
 813
 814         if (_actual_speed < 0.0) {
 815                 playback_sample -= playback_distance;
 816         } else {
 817                 playback_sample += playback_distance;
 818         }
 819
 820         boost::shared_ptr<ChannelList> c = channels.reader();
 821         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 822
 823                 (*chan)->playback_buf->increment_read_ptr (playback_distance);
 824
 825                 if (adjust_capture_position) {
 826                         (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
 827                 }
 828         }
 829
 830         if (adjust_capture_position != 0) {
 831                 capture_captured += adjust_capture_position;
 832                 adjust_capture_position = 0;
 833         }
 834
 835         if (_slaved) {
 836                 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
 837         } else {
 838                 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
 839                         || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
 840         }
 841
 842         if (commit_should_unlock) {
 843                 state_lock.unlock();
 844         }
 845
 846         _processed = false;
 847
 848         return need_butler;
 849 }
 850
 851 void
 852 AudioDiskstream::set_pending_overwrite (bool yn)
 853 {
 854         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 855
 856         pending_overwrite = yn;
 857
 858         overwrite_frame = playback_sample;
 859         overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
 860 }
 861
 862 int
 863 AudioDiskstream::overwrite_existing_buffers ()
 864 {
 865         boost::shared_ptr<ChannelList> c = channels.reader();
 866         Sample* mixdown_buffer;
 867         float* gain_buffer;
 868         int ret = -1;
 869         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
 870
 871         overwrite_queued = false;
 872
 873         /* assume all are the same size */
 874         nframes_t size = c->front()->playback_buf->bufsize();
 875
 876         mixdown_buffer = new Sample[size];
 877         gain_buffer = new float[size];
 878
 879         /* reduce size so that we can fill the buffer correctly. */
 880         size--;
 881
 882         uint32_t n=0;
 883         nframes_t start;
 884
 885         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 886
 887                 start = overwrite_frame;
 888                 nframes_t cnt = size;
 889
 890                 /* to fill the buffer without resetting the playback sample, we need to
 891                    do it one or two chunks (normally two).
 892
 893                    |----------------------------------------------------------------------|
 894
 895                                        ^
 896                                        overwrite_offset
 897                     |<- second chunk->||<----------------- first chunk ------------------>|
 898
 899                 */
 900
 901                 nframes_t to_read = size - overwrite_offset;
 902
 903                 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
 904                         error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 905                                          _id, size, playback_sample) << endmsg;
 906                         goto out;
 907                 }
 908
 909                 if (cnt > to_read) {
 910
 911                         cnt -= to_read;
 912
 913                         if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
 914                                   start, cnt, *chan, n, reversed)) {
 915                                 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 916                                                  _id, size, playback_sample) << endmsg;
 917                                 goto out;
 918                         }
 919                 }
 920         }
 921
 922         ret = 0;
 923
 924   out:
 925         pending_overwrite = false;
 926         delete [] gain_buffer;
 927         delete [] mixdown_buffer;
 928         return ret;
 929 }
 930
 931 int
 932 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 933 {
 934         uint32_t n;
 935         int ret;
 936         ChannelList::iterator chan;
 937         boost::shared_ptr<ChannelList> c = channels.reader();
 938
 939         Glib::Mutex::Lock lm (state_lock);
 940
 941         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 942                 (*chan)->playback_buf->reset ();
 943                 (*chan)->capture_buf->reset ();
 944         }
 945
 946         /* can't rec-enable in destructive mode if transport is before start */
 947
 948         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 949                 disengage_record_enable ();
 950         }
 951
 952         playback_sample = frame;
 953         file_frame = frame;
 954
 955         if (complete_refill) {
 956                 while ((ret = do_refill_with_alloc ()) > 0) ;
 957         } else {
 958                 ret = do_refill_with_alloc ();
 959         }
 960
 961         return ret;
 962 }
 963
 964 int
 965 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
 966 {
 967         ChannelList::iterator chan;
 968         boost::shared_ptr<ChannelList> c = channels.reader();
 969
 970         for (chan = c->begin(); chan != c->end(); ++chan) {
 971                 if ((*chan)->playback_buf->read_space() < distance) {
 972                         return false;
 973                 }
 974         }
 975         return true;
 976 }
 977
 978 int
 979 AudioDiskstream::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                 (*chan)->playback_buf->increment_read_ptr (distance);
 986         }
 987
 988         first_recordable_frame += distance;
 989         playback_sample += distance;
 990
 991         return 0;
 992 }
 993
 994 int
 995 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
 996                        ChannelInfo* channel_info, int channel, bool reversed)
 997 {
 998         nframes_t this_read = 0;
 999         bool reloop = false;
1000         nframes_t loop_end = 0;
1001         nframes_t loop_start = 0;
1002         nframes_t loop_length = 0;
1003         nframes_t offset = 0;
1004         Location *loc = 0;
1005
1006         /* XXX we don't currently play loops in reverse. not sure why */
1007
1008         if (!reversed) {
1009
1010                 /* Make the use of a Location atomic for this read operation.
1011
1012                    Note: Locations don't get deleted, so all we care about
1013                    when I say "atomic" is that we are always pointing to
1014                    the same one and using a start/length values obtained
1015                    just once.
1016                 */
1017
1018                 if ((loc = loop_location) != 0) {
1019                         loop_start = loc->start();
1020                         loop_end = loc->end();
1021                         loop_length = loop_end - loop_start;
1022                 }
1023
1024                 /* if we are looping, ensure that the first frame we read is at the correct
1025                    position within the loop.
1026                 */
1027
1028                 if (loc && start >= loop_end) {
1029                         //cerr << "start adjusted from " << start;
1030                         start = loop_start + ((start - loop_start) % loop_length);
1031                         //cerr << "to " << start << endl;
1032                 }
1033
1034                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
1035         }
1036
1037         while (cnt) {
1038
1039                 if (reversed) {
1040                         start -= cnt;
1041                 }
1042
1043                 /* take any loop into account. we can't read past the end of the loop. */
1044
1045                 if (loc && (loop_end - start < cnt)) {
1046                         this_read = loop_end - start;
1047                         //cerr << "reloop true: thisread: " << this_read << "  cnt: " << cnt << endl;
1048                         reloop = true;
1049                 } else {
1050                         reloop = false;
1051                         this_read = cnt;
1052                 }
1053
1054                 if (this_read == 0) {
1055                         break;
1056                 }
1057
1058                 this_read = min(cnt,this_read);
1059
1060                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1061                         error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1062                                          start) << endmsg;
1063                         return -1;
1064                 }
1065
1066                 _read_data_count = _playlist->read_data_count();
1067
1068                 if (reversed) {
1069
1070                         swap_by_ptr (buf, buf + this_read - 1);
1071
1072                 } else {
1073
1074                         /* if we read to the end of the loop, go back to the beginning */
1075
1076                         if (reloop) {
1077                                 start = loop_start;
1078                         } else {
1079                                 start += this_read;
1080                         }
1081                 }
1082
1083                 cnt -= this_read;
1084                 offset += this_read;
1085         }
1086
1087         return 0;
1088 }
1089
1090 int
1091 AudioDiskstream::do_refill_with_alloc ()
1092 {
1093         Sample* mix_buf  = new Sample[disk_io_chunk_frames];
1094         float*  gain_buf = new float[disk_io_chunk_frames];
1095
1096         int ret = _do_refill(mix_buf, gain_buf);
1097
1098         delete [] mix_buf;
1099         delete [] gain_buf;
1100
1101         return ret;
1102 }
1103
1104 int
1105 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1106 {
1107         int32_t ret = 0;
1108         nframes_t to_read;
1109         RingBufferNPT<Sample>::rw_vector vector;
1110         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1111         nframes_t total_space;
1112         nframes_t zero_fill;
1113         uint32_t chan_n;
1114         ChannelList::iterator i;
1115         boost::shared_ptr<ChannelList> c = channels.reader();
1116         nframes_t ts;
1117
1118         if (c->empty()) {
1119                 return 0;
1120         }
1121
1122         assert(mixdown_buffer);
1123         assert(gain_buffer);
1124
1125         vector.buf[0] = 0;
1126         vector.len[0] = 0;
1127         vector.buf[1] = 0;
1128         vector.len[1] = 0;
1129
1130         c->front()->playback_buf->get_write_vector (&vector);
1131
1132         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1133                 return 0;
1134         }
1135
1136         /* if there are 2+ chunks of disk i/o possible for
1137            this track, let the caller know so that it can arrange
1138            for us to be called again, ASAP.
1139         */
1140
1141         if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1142                 ret = 1;
1143         }
1144
1145         /* if we're running close to normal speed and there isn't enough
1146            space to do disk_io_chunk_frames of I/O, then don't bother.
1147
1148            at higher speeds, just do it because the sync between butler
1149            and audio thread may not be good enough.
1150         */
1151
1152         if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1153                 return 0;
1154         }
1155
1156         /* when slaved, don't try to get too close to the read pointer. this
1157            leaves space for the buffer reversal to have something useful to
1158            work with.
1159         */
1160
1161         if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1162                 return 0;
1163         }
1164
1165         /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1166
1167         total_space = min (disk_io_chunk_frames, total_space);
1168
1169         if (reversed) {
1170
1171                 if (file_frame == 0) {
1172
1173                         /* at start: nothing to do but fill with silence */
1174
1175                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1176
1177                                 ChannelInfo* chan (*i);
1178                                 chan->playback_buf->get_write_vector (&vector);
1179                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1180                                 if (vector.len[1]) {
1181                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1182                                 }
1183                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1184                         }
1185                         return 0;
1186                 }
1187
1188                 if (file_frame < total_space) {
1189
1190                         /* too close to the start: read what we can,
1191                            and then zero fill the rest
1192                         */
1193
1194                         zero_fill = total_space - file_frame;
1195                         total_space = file_frame;
1196                         file_frame = 0;
1197
1198                 } else {
1199
1200                         zero_fill = 0;
1201                 }
1202
1203         } else {
1204
1205                 if (file_frame == max_frames) {
1206
1207                         /* at end: nothing to do but fill with silence */
1208
1209                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1210
1211                                 ChannelInfo* chan (*i);
1212                                 chan->playback_buf->get_write_vector (&vector);
1213                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1214                                 if (vector.len[1]) {
1215                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1216                                 }
1217                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1218                         }
1219                         return 0;
1220                 }
1221
1222                 if (file_frame > max_frames - total_space) {
1223
1224                         /* to close to the end: read what we can, and zero fill the rest */
1225
1226                         zero_fill = total_space - (max_frames - file_frame);
1227                         total_space = max_frames - file_frame;
1228
1229                 } else {
1230                         zero_fill = 0;
1231                 }
1232         }
1233
1234         nframes_t file_frame_tmp = 0;
1235
1236         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1237
1238                 ChannelInfo* chan (*i);
1239                 Sample* buf1;
1240                 Sample* buf2;
1241                 nframes_t len1, len2;
1242
1243                 chan->playback_buf->get_write_vector (&vector);
1244
1245                 if (vector.len[0] > disk_io_chunk_frames) {
1246
1247                         /* we're not going to fill the first chunk, so certainly do not bother with the
1248                            other part. it won't be connected with the part we do fill, as in:
1249
1250                            .... => writable space
1251                            ++++ => readable space
1252                            ^^^^ => 1 x disk_io_chunk_frames that would be filled
1253
1254                            |......|+++++++++++++|...............................|
1255                            buf1                buf0
1256                                                 ^^^^^^^^^^^^^^^
1257
1258
1259                            So, just pretend that the buf1 part isn't there.
1260
1261                         */
1262
1263                         vector.buf[1] = 0;
1264                         vector.len[1] = 0;
1265
1266                 }
1267
1268                 ts = total_space;
1269                 file_frame_tmp = file_frame;
1270
1271                 buf1 = vector.buf[0];
1272                 len1 = vector.len[0];
1273                 buf2 = vector.buf[1];
1274                 len2 = vector.len[1];
1275
1276                 to_read = min (ts, len1);
1277                 to_read = min (to_read, disk_io_chunk_frames);
1278
1279                 if (to_read) {
1280
1281                         if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1282                                 ret = -1;
1283                                 goto out;
1284                         }
1285
1286                         chan->playback_buf->increment_write_ptr (to_read);
1287                         ts -= to_read;
1288                 }
1289
1290                 to_read = min (ts, len2);
1291
1292                 if (to_read) {
1293
1294                         /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1295                            so read some or all of vector.len[1] as well.
1296                         */
1297
1298                         if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1299                                 ret = -1;
1300                                 goto out;
1301                         }
1302
1303                         chan->playback_buf->increment_write_ptr (to_read);
1304                 }
1305
1306                 if (zero_fill) {
1307                         /* do something */
1308                 }
1309
1310         }
1311
1312         file_frame = file_frame_tmp;
1313
1314   out:
1315
1316         return ret;
1317 }
1318
1319 /** Flush pending data to disk.
1320  *
1321  * Important note: this function will write *AT MOST* disk_io_chunk_frames
1322  * of data to disk. it will never write more than that.  If it writes that
1323  * much and there is more than that waiting to be written, it will return 1,
1324  * otherwise 0 on success or -1 on failure.
1325  *
1326  * If there is less than disk_io_chunk_frames to be written, no data will be
1327  * written at all unless @a force_flush is true.
1328  */
1329 int
1330 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1331 {
1332         uint32_t to_write;
1333         int32_t ret = 0;
1334         RingBufferNPT<Sample>::rw_vector vector;
1335         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1336         nframes_t total;
1337
1338         _write_data_count = 0;
1339
1340         transvec.buf[0] = 0;
1341         transvec.buf[1] = 0;
1342         vector.buf[0] = 0;
1343         vector.buf[1] = 0;
1344
1345         boost::shared_ptr<ChannelList> c = channels.reader();
1346         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1347
1348                 (*chan)->capture_buf->get_read_vector (&vector);
1349
1350                 total = vector.len[0] + vector.len[1];
1351
1352                 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1353                         goto out;
1354                 }
1355
1356                 /* if there are 2+ chunks of disk i/o possible for
1357                    this track, let the caller know so that it can arrange
1358                    for us to be called again, ASAP.
1359
1360                    if we are forcing a flush, then if there is* any* extra
1361                    work, let the caller know.
1362
1363                    if we are no longer recording and there is any extra work,
1364                    let the caller know too.
1365                 */
1366
1367                 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1368                         ret = 1;
1369                 }
1370
1371                 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1372
1373                 // check the transition buffer when recording destructive
1374                 // important that we get this after the capture buf
1375
1376                 if (destructive()) {
1377                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
1378                         size_t transcount = transvec.len[0] + transvec.len[1];
1379                         bool have_start = false;
1380                         size_t ti;
1381
1382                         for (ti=0; ti < transcount; ++ti) {
1383                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1384
1385                                 if (captrans.type == CaptureStart) {
1386                                         // by definition, the first data we got above represents the given capture pos
1387
1388                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
1389                                         (*chan)->curr_capture_cnt = 0;
1390
1391                                         have_start = true;
1392                                 }
1393                                 else if (captrans.type == CaptureEnd) {
1394
1395                                         // capture end, the capture_val represents total frames in capture
1396
1397                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1398
1399                                                 // shorten to make the write a perfect fit
1400                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1401
1402                                                 if (nto_write < to_write) {
1403                                                         ret = 1; // should we?
1404                                                 }
1405                                                 to_write = nto_write;
1406
1407                                                 (*chan)->write_source->mark_capture_end ();
1408
1409                                                 // increment past this transition, but go no further
1410                                                 ++ti;
1411                                                 break;
1412                                         }
1413                                         else {
1414                                                 // actually ends just beyond this chunk, so force more work
1415                                                 ret = 1;
1416                                                 break;
1417                                         }
1418                                 }
1419                         }
1420
1421                         if (ti > 0) {
1422                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1423                         }
1424                 }
1425
1426                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1427                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1428                         return -1;
1429                 }
1430
1431                 (*chan)->capture_buf->increment_read_ptr (to_write);
1432                 (*chan)->curr_capture_cnt += to_write;
1433
1434                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1435
1436                         /* we wrote all of vector.len[0] but it wasn't an entire
1437                            disk_io_chunk_frames of data, so arrange for some part
1438                            of vector.len[1] to be flushed to disk as well.
1439                         */
1440
1441                         to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1442
1443                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1444                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1445                                 return -1;
1446                         }
1447
1448                         _write_data_count += (*chan)->write_source->write_data_count();
1449
1450                         (*chan)->capture_buf->increment_read_ptr (to_write);
1451                         (*chan)->curr_capture_cnt += to_write;
1452                 }
1453         }
1454
1455   out:
1456         return ret;
1457 }
1458
1459 void
1460 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1461 {
1462         uint32_t buffer_position;
1463         bool more_work = true;
1464         int err = 0;
1465         boost::shared_ptr<AudioRegion> region;
1466         nframes_t total_capture;
1467         SourceList srcs;
1468         SourceList::iterator src;
1469         ChannelList::iterator chan;
1470         vector<CaptureInfo*>::iterator ci;
1471         boost::shared_ptr<ChannelList> c = channels.reader();
1472         uint32_t n = 0;
1473         bool mark_write_completed = false;
1474
1475         finish_capture (true, c);
1476
1477         /* butler is already stopped, but there may be work to do
1478            to flush remaining data to disk.
1479         */
1480
1481         while (more_work && !err) {
1482                 switch (do_flush (Session::TransportContext, true)) {
1483                 case 0:
1484                         more_work = false;
1485                         break;
1486                 case 1:
1487                         break;
1488                 case -1:
1489                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1490                         err++;
1491                 }
1492         }
1493
1494         /* XXX is there anything we can do if err != 0 ? */
1495         Glib::Mutex::Lock lm (capture_info_lock);
1496
1497         if (capture_info.empty()) {
1498                 return;
1499         }
1500
1501         if (abort_capture) {
1502
1503                 if (destructive()) {
1504                         goto outout;
1505                 }
1506
1507                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1508
1509                         if ((*chan)->write_source) {
1510
1511                                 (*chan)->write_source->mark_for_remove ();
1512                                 (*chan)->write_source->drop_references ();
1513                                 (*chan)->write_source.reset ();
1514                         }
1515
1516                         /* new source set up in "out" below */
1517                 }
1518
1519                 goto out;
1520         }
1521
1522         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1523                 total_capture += (*ci)->frames;
1524         }
1525
1526         /* figure out the name for this take */
1527
1528         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1529
1530                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1531
1532                 if (s) {
1533                         srcs.push_back (s);
1534                         s->update_header (capture_info.front()->start, when, twhen);
1535                         s->set_captured_for (_name);
1536                         s->mark_immutable ();
1537                 }
1538         }
1539
1540         /* destructive tracks have a single, never changing region */
1541
1542         if (destructive()) {
1543
1544                 /* send a signal that any UI can pick up to do the right thing. there is
1545                    a small problem here in that a UI may need the peak data to be ready
1546                    for the data that was recorded and this isn't interlocked with that
1547                    process. this problem is deferred to the UI.
1548                  */
1549
1550                 _playlist->Modified();
1551
1552         } else {
1553
1554                 string whole_file_region_name;
1555                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1556
1557                 /* Register a new region with the Session that
1558                    describes the entire source. Do this first
1559                    so that any sub-regions will obviously be
1560                    children of this one (later!)
1561                 */
1562
1563                 try {
1564                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1565                                                                              whole_file_region_name,
1566                                                                              0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1567
1568                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1569                         region->special_set_position (capture_info.front()->start);
1570                 }
1571
1572
1573                 catch (failed_constructor& err) {
1574                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1575                         /* XXX what now? */
1576                 }
1577
1578                 _last_capture_regions.push_back (region);
1579
1580                 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1581
1582                 XMLNode &before = _playlist->get_state();
1583                 _playlist->freeze ();
1584
1585                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1586
1587                         string region_name;
1588
1589                         _session.region_name (region_name, whole_file_region_name, false);
1590
1591                         // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1592
1593                         try {
1594                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1595                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1596                         }
1597
1598                         catch (failed_constructor& err) {
1599                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1600                                 continue; /* XXX is this OK? */
1601                         }
1602
1603                         region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1604
1605                         _last_capture_regions.push_back (region);
1606
1607                         i_am_the_modifier++;
1608                         _playlist->add_region (region, (*ci)->start);
1609                         i_am_the_modifier--;
1610
1611                         buffer_position += (*ci)->frames;
1612                 }
1613
1614                 _playlist->thaw ();
1615                 XMLNode &after = _playlist->get_state();
1616                 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1617         }
1618
1619         mark_write_completed = true;
1620
1621   out:
1622         reset_write_sources (mark_write_completed);
1623
1624   outout:
1625
1626         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1627                 delete *ci;
1628         }
1629
1630         capture_info.clear ();
1631         capture_start_frame = 0;
1632 }
1633
1634 void
1635 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1636 {
1637         was_recording = false;
1638
1639         if (capture_captured == 0) {
1640                 return;
1641         }
1642
1643         if (recordable() && destructive()) {
1644                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1645
1646                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1647                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1648
1649
1650                         if (transvec.len[0] > 0) {
1651                                 transvec.buf[0]->type = CaptureEnd;
1652                                 transvec.buf[0]->capture_val = capture_captured;
1653                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1654                         }
1655                         else {
1656                                 // bad!
1657                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1658                         }
1659                 }
1660         }
1661
1662
1663         CaptureInfo* ci = new CaptureInfo;
1664
1665         ci->start =  capture_start_frame;
1666         ci->frames = capture_captured;
1667
1668         /* XXX theoretical race condition here. Need atomic exchange ?
1669            However, the circumstances when this is called right
1670            now (either on record-disable or transport_stopped)
1671            mean that no actual race exists. I think ...
1672            We now have a capture_info_lock, but it is only to be used
1673            to synchronize in the transport_stop and the capture info
1674            accessors, so that invalidation will not occur (both non-realtime).
1675         */
1676
1677         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1678
1679         capture_info.push_back (ci);
1680         capture_captured = 0;
1681 }
1682
1683 void
1684 AudioDiskstream::set_record_enabled (bool yn)
1685 {
1686         if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
1687                 return;
1688         }
1689
1690         /* can't rec-enable in destructive mode if transport is before start */
1691
1692         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1693                 return;
1694         }
1695
1696         if (yn && channels.reader()->front()->source == 0) {
1697
1698                 /* pick up connections not initiated *from* the IO object
1699                    we're associated with.
1700                 */
1701
1702                 get_input_sources ();
1703         }
1704
1705         /* yes, i know that this not proof against race conditions, but its
1706            good enough. i think.
1707         */
1708
1709         if (record_enabled() != yn) {
1710                 if (yn) {
1711                         engage_record_enable ();
1712                 } else {
1713                         disengage_record_enable ();
1714                 }
1715         }
1716 }
1717
1718 void
1719 AudioDiskstream::engage_record_enable ()
1720 {
1721         bool rolling = _session.transport_speed() != 0.0f;
1722         boost::shared_ptr<ChannelList> c = channels.reader();
1723
1724         g_atomic_int_set (&_record_enabled, 1);
1725         capturing_sources.clear ();
1726
1727         if (Config->get_monitoring_model() == HardwareMonitoring) {
1728
1729                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1730                         if ((*chan)->source) {
1731                                 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1732                         }
1733                         capturing_sources.push_back ((*chan)->write_source);
1734                 }
1735
1736         } else {
1737                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1738                         capturing_sources.push_back ((*chan)->write_source);
1739                 }
1740         }
1741
1742         RecordEnableChanged (); /* EMIT SIGNAL */
1743 }
1744
1745 void
1746 AudioDiskstream::disengage_record_enable ()
1747 {
1748         g_atomic_int_set (&_record_enabled, 0);
1749         boost::shared_ptr<ChannelList> c = channels.reader();
1750         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1751                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1752                         if ((*chan)->source) {
1753                                 (*chan)->source->ensure_monitor_input (false);
1754                         }
1755                 }
1756         }
1757         capturing_sources.clear ();
1758         RecordEnableChanged (); /* EMIT SIGNAL */
1759 }
1760
1761 XMLNode&
1762 AudioDiskstream::get_state ()
1763 {
1764         XMLNode* node = new XMLNode ("AudioDiskstream");
1765         char buf[64] = "";
1766         LocaleGuard lg (X_("POSIX"));
1767         boost::shared_ptr<ChannelList> c = channels.reader();
1768
1769         node->add_property ("flags", enum_2_string (_flags));
1770
1771         snprintf (buf, sizeof(buf), "%zd", c->size());
1772         node->add_property ("channels", buf);
1773
1774         node->add_property ("playlist", _playlist->name());
1775
1776         snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1777         node->add_property ("speed", buf);
1778
1779         node->add_property("name", _name);
1780         id().print (buf, sizeof (buf));
1781         node->add_property("id", buf);
1782
1783         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1784
1785                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1786                 XMLNode* cs_grandchild;
1787
1788                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1789                         cs_grandchild = new XMLNode (X_("file"));
1790                         cs_grandchild->add_property (X_("path"), (*i)->path());
1791                         cs_child->add_child_nocopy (*cs_grandchild);
1792                 }
1793
1794                 /* store the location where capture will start */
1795
1796                 Location* pi;
1797
1798                 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1799                         snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1800                 } else {
1801                         snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1802                 }
1803
1804                 cs_child->add_property (X_("at"), buf);
1805                 node->add_child_nocopy (*cs_child);
1806         }
1807
1808         if (_extra_xml) {
1809                 node->add_child_copy (*_extra_xml);
1810         }
1811
1812         return* node;
1813 }
1814
1815 int
1816 AudioDiskstream::set_state (const XMLNode& node)
1817 {
1818         const XMLProperty* prop;
1819         XMLNodeList nlist = node.children();
1820         XMLNodeIterator niter;
1821         uint32_t nchans = 1;
1822         XMLNode* capture_pending_node = 0;
1823         LocaleGuard lg (X_("POSIX"));
1824
1825         in_set_state = true;
1826
1827         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1828                 if ((*niter)->name() == IO::state_node_name) {
1829                         deprecated_io_node = new XMLNode (**niter);
1830                 }
1831
1832                 if ((*niter)->name() == X_("CapturingSources")) {
1833                         capture_pending_node = *niter;
1834                 }
1835         }
1836
1837         /* prevent write sources from being created */
1838
1839         in_set_state = true;
1840
1841         if ((prop = node.property ("name")) != 0) {
1842                 _name = prop->value();
1843         }
1844
1845         if (deprecated_io_node) {
1846                 if ((prop = deprecated_io_node->property ("id")) != 0) {
1847                         _id = prop->value ();
1848                 }
1849         } else {
1850                 if ((prop = node.property ("id")) != 0) {
1851                         _id = prop->value ();
1852                 }
1853         }
1854
1855         if ((prop = node.property ("flags")) != 0) {
1856                 _flags = Flag (string_2_enum (prop->value(), _flags));
1857         }
1858
1859         if ((prop = node.property ("channels")) != 0) {
1860                 nchans = atoi (prop->value().c_str());
1861         }
1862
1863         // create necessary extra channels
1864         // we are always constructed with one and we always need one
1865
1866         _n_channels = channels.reader()->size();
1867
1868         if (nchans > _n_channels) {
1869
1870                 add_channel (nchans - _n_channels);
1871
1872         } else if (nchans < _n_channels) {
1873
1874                 remove_channel (_n_channels - nchans);
1875         }
1876
1877         if ((prop = node.property ("playlist")) == 0) {
1878                 return -1;
1879         }
1880
1881         {
1882                 bool had_playlist = (_playlist != 0);
1883
1884                 if (find_and_use_playlist (prop->value())) {
1885                         return -1;
1886                 }
1887
1888                 if (!had_playlist) {
1889                         _playlist->set_orig_diskstream_id (_id);
1890                 }
1891
1892                 if (!destructive() && capture_pending_node) {
1893                         /* destructive streams have one and only one source per channel,
1894                            and so they never end up in pending capture in any useful
1895                            sense.
1896                         */
1897                         use_pending_capture_data (*capture_pending_node);
1898                 }
1899
1900         }
1901
1902         if ((prop = node.property ("speed")) != 0) {
1903                 double sp = atof (prop->value().c_str());
1904
1905                 if (realtime_set_speed (sp, false)) {
1906                         non_realtime_set_speed ();
1907                 }
1908         }
1909
1910         in_set_state = false;
1911
1912         /* make sure this is clear before we do anything else */
1913
1914         capturing_sources.clear ();
1915
1916         /* write sources are handled when we handle the input set
1917            up of the IO that owns this DS (::non_realtime_input_change())
1918         */
1919
1920         in_set_state = false;
1921
1922         return 0;
1923 }
1924
1925 int
1926 AudioDiskstream::use_new_write_source (uint32_t n)
1927 {
1928         boost::shared_ptr<ChannelList> c = channels.reader();
1929
1930         if (!recordable()) {
1931                 return 1;
1932         }
1933
1934         if (n >= c->size()) {
1935                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1936                 return -1;
1937         }
1938
1939         ChannelInfo* chan = (*c)[n];
1940
1941         if (chan->write_source) {
1942                 chan->write_source->done_with_peakfile_writes ();
1943                 chan->write_source->set_allow_remove_if_empty (true);
1944                 chan->write_source.reset ();
1945         }
1946
1947         try {
1948                 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
1949                         throw failed_constructor();
1950                 }
1951         }
1952
1953         catch (failed_constructor &err) {
1954                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1955                 chan->write_source.reset ();
1956                 return -1;
1957         }
1958
1959         /* do not remove destructive files even if they are empty */
1960
1961         chan->write_source->set_allow_remove_if_empty (!destructive());
1962
1963         return 0;
1964 }
1965
1966 void
1967 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
1968 {
1969         ChannelList::iterator chan;
1970         boost::shared_ptr<ChannelList> c = channels.reader();
1971         uint32_t n;
1972
1973         if (!recordable()) {
1974                 return;
1975         }
1976
1977         capturing_sources.clear ();
1978
1979         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1980                 if (!destructive()) {
1981
1982                         if ((*chan)->write_source && mark_write_complete) {
1983                                 (*chan)->write_source->mark_streaming_write_completed ();
1984                         }
1985                         use_new_write_source (n);
1986
1987                         if (record_enabled()) {
1988                                 capturing_sources.push_back ((*chan)->write_source);
1989                         }
1990
1991                 } else {
1992                         if ((*chan)->write_source == 0) {
1993                                 use_new_write_source (n);
1994                         }
1995                 }
1996         }
1997
1998         if (destructive()) {
1999
2000                 /* we now have all our write sources set up, so create the
2001                    playlist's single region.
2002                 */
2003
2004                 if (_playlist->empty()) {
2005                         setup_destructive_playlist ();
2006                 }
2007         }
2008 }
2009
2010 int
2011 AudioDiskstream::rename_write_sources ()
2012 {
2013         ChannelList::iterator chan;
2014         boost::shared_ptr<ChannelList> c = channels.reader();
2015         uint32_t n;
2016
2017         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2018                 if ((*chan)->write_source != 0) {
2019                         (*chan)->write_source->set_name (_name, destructive());
2020                         /* XXX what to do if one of them fails ? */
2021                 }
2022         }
2023
2024         return 0;
2025 }
2026
2027 void
2028 AudioDiskstream::set_block_size (nframes_t nframes)
2029 {
2030         if (_session.get_block_size() > speed_buffer_size) {
2031                 speed_buffer_size = _session.get_block_size();
2032                 boost::shared_ptr<ChannelList> c = channels.reader();
2033
2034                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2035                         if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2036                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
2037                 }
2038         }
2039         allocate_temporary_buffers ();
2040 }
2041
2042 void
2043 AudioDiskstream::allocate_temporary_buffers ()
2044 {
2045         /* make sure the wrap buffer is at least large enough to deal
2046            with the speeds up to 1.2, to allow for micro-variation
2047            when slaving to MTC, SMPTE etc.
2048         */
2049
2050         double sp = max (fabsf (_actual_speed), 1.2f);
2051         nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2052
2053         if (required_wrap_size > wrap_buffer_size) {
2054
2055                 boost::shared_ptr<ChannelList> c = channels.reader();
2056
2057                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2058                         if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2059                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2060                         if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2061                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2062                 }
2063
2064                 wrap_buffer_size = required_wrap_size;
2065         }
2066 }
2067
2068 void
2069 AudioDiskstream::monitor_input (bool yn)
2070 {
2071         boost::shared_ptr<ChannelList> c = channels.reader();
2072
2073         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2074
2075                 if ((*chan)->source) {
2076                         (*chan)->source->ensure_monitor_input (yn);
2077                 }
2078         }
2079 }
2080
2081 void
2082 AudioDiskstream::set_align_style_from_io ()
2083 {
2084         bool have_physical = false;
2085
2086         if (_io == 0) {
2087                 return;
2088         }
2089
2090         get_input_sources ();
2091
2092         boost::shared_ptr<ChannelList> c = channels.reader();
2093
2094         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2095                 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2096                         have_physical = true;
2097                         break;
2098                 }
2099         }
2100
2101         if (have_physical) {
2102                 set_align_style (ExistingMaterial);
2103         } else {
2104                 set_align_style (CaptureTime);
2105         }
2106 }
2107
2108 int
2109 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2110 {
2111         while (how_many--) {
2112                 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2113         }
2114
2115         _n_channels = c->size();
2116
2117         return 0;
2118 }
2119
2120 int
2121 AudioDiskstream::add_channel (uint32_t how_many)
2122 {
2123         RCUWriter<ChannelList> writer (channels);
2124         boost::shared_ptr<ChannelList> c = writer.get_copy();
2125
2126         return add_channel_to (c, how_many);
2127 }
2128
2129 int
2130 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2131 {
2132         while (--how_many && !c->empty()) {
2133                 delete c->back();
2134                 c->pop_back();
2135         }
2136
2137         _n_channels = c->size();
2138
2139         return 0;
2140 }
2141
2142 int
2143 AudioDiskstream::remove_channel (uint32_t how_many)
2144 {
2145         RCUWriter<ChannelList> writer (channels);
2146         boost::shared_ptr<ChannelList> c = writer.get_copy();
2147
2148         return remove_channel_from (c, how_many);
2149 }
2150
2151 float
2152 AudioDiskstream::playback_buffer_load () const
2153 {
2154         boost::shared_ptr<ChannelList> c = channels.reader();
2155
2156         return (float) ((double) c->front()->playback_buf->read_space()/
2157                         (double) c->front()->playback_buf->bufsize());
2158 }
2159
2160 float
2161 AudioDiskstream::capture_buffer_load () const
2162 {
2163         boost::shared_ptr<ChannelList> c = channels.reader();
2164
2165         return (float) ((double) c->front()->capture_buf->write_space()/
2166                         (double) c->front()->capture_buf->bufsize());
2167 }
2168
2169 int
2170 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2171 {
2172         const XMLProperty* prop;
2173         XMLNodeList nlist = node.children();
2174         XMLNodeIterator niter;
2175         boost::shared_ptr<AudioFileSource> fs;
2176         boost::shared_ptr<AudioFileSource> first_fs;
2177         SourceList pending_sources;
2178         nframes_t position;
2179
2180         if ((prop = node.property (X_("at"))) == 0) {
2181                 return -1;
2182         }
2183
2184         if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2185                 return -1;
2186         }
2187
2188         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2189                 if ((*niter)->name() == X_("file")) {
2190
2191                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2192                                 continue;
2193                         }
2194
2195                         try {
2196                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
2197                         }
2198
2199                         catch (failed_constructor& err) {
2200                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2201                                                   _name, prop->value())
2202                                       << endmsg;
2203                                 return -1;
2204                         }
2205
2206                         pending_sources.push_back (fs);
2207
2208                         if (first_fs == 0) {
2209                                 first_fs = fs;
2210                         }
2211
2212                         fs->set_captured_for (_name);
2213                 }
2214         }
2215
2216         if (pending_sources.size() == 0) {
2217                 /* nothing can be done */
2218                 return 1;
2219         }
2220
2221         if (pending_sources.size() != _n_channels) {
2222                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2223                       << endmsg;
2224                 return -1;
2225         }
2226
2227         boost::shared_ptr<AudioRegion> region;
2228
2229         try {
2230                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2231                                                                                           region_name_from_path (first_fs->name(), true),
2232                                                                                           0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2233                 region->special_set_position (0);
2234         }
2235
2236         catch (failed_constructor& err) {
2237                 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2238                                   _name)
2239                       << endmsg;
2240
2241                 return -1;
2242         }
2243
2244         try {
2245                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2246         }
2247
2248         catch (failed_constructor& err) {
2249                 error << string_compose (_("%1: cannot create region from pending capture sources"),
2250                                   _name)
2251                       << endmsg;
2252
2253                 return -1;
2254         }
2255
2256         _playlist->add_region (region, position);
2257
2258         return 0;
2259 }
2260
2261 int
2262 AudioDiskstream::set_destructive (bool yn)
2263 {
2264         bool bounce_ignored;
2265
2266         if (yn != destructive()) {
2267
2268                 if (yn) {
2269                         /* requestor should already have checked this and
2270                            bounced if necessary and desired
2271                         */
2272                         if (!can_become_destructive (bounce_ignored)) {
2273                                 return -1;
2274                         }
2275                         _flags = Flag (_flags | Destructive);
2276                         use_destructive_playlist ();
2277                 } else {
2278                         _flags = Flag (_flags & ~Destructive);
2279                         reset_write_sources (true, true);
2280                 }
2281         }
2282
2283         return 0;
2284 }
2285
2286 bool
2287 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2288 {
2289         if (!_playlist) {
2290                 requires_bounce = false;
2291                 return false;
2292         }
2293
2294         /* is there only one region ? */
2295
2296         if (_playlist->n_regions() != 1) {
2297                 requires_bounce = true;
2298                 return false;
2299         }
2300
2301         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2302         assert (first);
2303
2304         /* do the source(s) for the region cover the session start position ? */
2305
2306         if (first->position() != _session.current_start_frame()) {
2307                 if (first->start() > _session.current_start_frame()) {
2308                         requires_bounce = true;
2309                         return false;
2310                 }
2311         }
2312
2313         /* is the source used by only 1 playlist ? */
2314
2315         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2316
2317         assert (afirst);
2318
2319         if (afirst->source()->used() > 1) {
2320                 requires_bounce = true;
2321                 return false;
2322         }
2323
2324         requires_bounce = false;
2325         return true;
2326 }
2327
2328 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2329 {
2330         peak_power = 0.0f;
2331         source = 0;
2332         current_capture_buffer = 0;
2333         current_playback_buffer = 0;
2334         curr_capture_cnt = 0;
2335
2336         speed_buffer = new Sample[speed_size];
2337         playback_wrap_buffer = new Sample[wrap_size];
2338         capture_wrap_buffer = new Sample[wrap_size];
2339
2340         playback_buf = new RingBufferNPT<Sample> (bufsize);
2341         capture_buf = new RingBufferNPT<Sample> (bufsize);
2342         capture_transition_buf = new RingBufferNPT<CaptureTransition> (128);
2343
2344         /* touch the ringbuffer buffers, which will cause
2345            them to be mapped into locked physical RAM if
2346            we're running with mlockall(). this doesn't do
2347            much if we're not.
2348         */
2349
2350         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2351         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2352         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2353 }
2354
2355 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2356 {
2357         if (write_source) {
2358                 write_source.reset ();
2359         }
2360
2361         if (speed_buffer) {
2362                 delete [] speed_buffer;
2363                 speed_buffer = 0;
2364         }
2365
2366         if (playback_wrap_buffer) {
2367                 delete [] playback_wrap_buffer;
2368                 playback_wrap_buffer = 0;
2369         }
2370
2371         if (capture_wrap_buffer) {
2372                 delete [] capture_wrap_buffer;
2373                 capture_wrap_buffer = 0;
2374         }
2375
2376         if (playback_buf) {
2377                 delete playback_buf;
2378                 playback_buf = 0;
2379         }
2380
2381         if (capture_buf) {
2382                 delete capture_buf;
2383                 capture_buf = 0;
2384         }
2385
2386         if (capture_transition_buf) {
2387                 delete capture_transition_buf;
2388                 capture_transition_buf = 0;
2389         }
2390 }