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