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