libs/ardour/diskstream.cc

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