libs/ardour/audio_diskstream.cc

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