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