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