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