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