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::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 (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
 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::Mutex::Lock sm (state_lock, Glib::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 = ap->get_audio_buffer (nframes).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 = ap->get_audio_buffer(nframes).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) floor ((nframes * fabs (_actual_speed))) + 1;
 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                                         /* Copy buf[0] from playback_buf */
 622                                         memcpy ((char *) chaninfo->playback_wrap_buffer,
 623                                                         chaninfo->playback_vector.buf[0],
 624                                                         chaninfo->playback_vector.len[0] * sizeof (Sample));
 625
 626                                         /* Copy buf[1] from playback_buf */
 627                                         memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
 628                                                         chaninfo->playback_vector.buf[1],
 629                                                         (necessary_samples - chaninfo->playback_vector.len[0])
 630                                                                         * sizeof (Sample));
 631
 632                                         chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
 633                                 }
 634                         }
 635                 }
 636
 637                 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 638
 639                         interpolation.set_speed (_target_speed);
 640
 641                         int channel = 0;
 642                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
 643                                 ChannelInfo* chaninfo (*chan);
 644
 645                                 playback_distance = interpolation.interpolate (
 646                                         channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
 647
 648                                 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
 649                         }
 650
 651                 } else {
 652                         playback_distance = nframes;
 653                 }
 654
 655                 _speed = _target_speed;
 656         }
 657
 658         return 0;
 659 }
 660
 661 /** Update various things including playback_sample, read pointer on each channel's playback_buf
 662  *  and write pointer on each channel's capture_buf.  Also wout whether the butler is needed.
 663  *  @return true if the butler is required.
 664  */
 665 bool
 666 AudioDiskstream::commit (framecnt_t playback_distance)
 667 {
 668         bool need_butler = false;
 669
 670         if (!_io || !_io->active()) {
 671                 return false;
 672         }
 673
 674         if (_actual_speed < 0.0) {
 675                 playback_sample -= playback_distance;
 676         } else {
 677                 playback_sample += playback_distance;
 678         }
 679
 680         boost::shared_ptr<ChannelList> c = channels.reader();
 681         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 682
 683                 (*chan)->playback_buf->increment_read_ptr (playback_distance);
 684
 685                 if (adjust_capture_position) {
 686                         (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
 687                 }
 688         }
 689
 690         if (adjust_capture_position != 0) {
 691                 capture_captured += adjust_capture_position;
 692                 adjust_capture_position = 0;
 693         }
 694
 695         if (c->empty()) {
 696                 return false;
 697         }
 698
 699         if (_slaved) {
 700                 if (_io && _io->active()) {
 701                         need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
 702                 } else {
 703                         need_butler = false;
 704                 }
 705         } else {
 706                 if (_io && _io->active()) {
 707                         need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames)
 708                                 || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
 709                 } else {
 710                         need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
 711                 }
 712         }
 713
 714         return need_butler;
 715 }
 716
 717 void
 718 AudioDiskstream::set_pending_overwrite (bool yn)
 719 {
 720         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 721
 722         _pending_overwrite = yn;
 723
 724         overwrite_frame = playback_sample;
 725
 726         boost::shared_ptr<ChannelList> c = channels.reader ();
 727         if (!c->empty ()) {
 728                 overwrite_offset = c->front()->playback_buf->get_read_ptr();
 729         }
 730 }
 731
 732 int
 733 AudioDiskstream::overwrite_existing_buffers ()
 734 {
 735         boost::shared_ptr<ChannelList> c = channels.reader();
 736         if (c->empty ()) {
 737                 _pending_overwrite = false;
 738                 return 0;
 739         }
 740
 741         Sample* mixdown_buffer;
 742         float* gain_buffer;
 743         int ret = -1;
 744         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
 745
 746         overwrite_queued = false;
 747
 748         /* assume all are the same size */
 749         framecnt_t size = c->front()->playback_buf->bufsize();
 750
 751         mixdown_buffer = new Sample[size];
 752         gain_buffer = new float[size];
 753
 754         /* reduce size so that we can fill the buffer correctly (ringbuffers
 755            can only handle size-1, otherwise they appear to be empty)
 756         */
 757         size--;
 758
 759         uint32_t n=0;
 760         framepos_t start;
 761
 762         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 763
 764                 start = overwrite_frame;
 765                 framecnt_t cnt = size;
 766
 767                 /* to fill the buffer without resetting the playback sample, we need to
 768                    do it one or two chunks (normally two).
 769
 770                    |----------------------------------------------------------------------|
 771
 772                                        ^
 773                                        overwrite_offset
 774                     |<- second chunk->||<----------------- first chunk ------------------>|
 775
 776                 */
 777
 778                 framecnt_t to_read = size - overwrite_offset;
 779
 780                 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) {
 781                         error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 782                                                 id(), size, playback_sample) << endmsg;
 783                         goto out;
 784                 }
 785
 786                 if (cnt > to_read) {
 787
 788                         cnt -= to_read;
 789
 790                         if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) {
 791                                 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 792                                                         id(), size, playback_sample) << endmsg;
 793                                 goto out;
 794                         }
 795                 }
 796         }
 797
 798         ret = 0;
 799
 800   out:
 801         _pending_overwrite = false;
 802         delete [] gain_buffer;
 803         delete [] mixdown_buffer;
 804         return ret;
 805 }
 806
 807 int
 808 AudioDiskstream::seek (framepos_t frame, bool complete_refill)
 809 {
 810         uint32_t n;
 811         int ret = -1;
 812         ChannelList::iterator chan;
 813         boost::shared_ptr<ChannelList> c = channels.reader();
 814
 815         Glib::Mutex::Lock lm (state_lock);
 816
 817         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 818                 (*chan)->playback_buf->reset ();
 819                 (*chan)->capture_buf->reset ();
 820         }
 821
 822         /* can't rec-enable in destructive mode if transport is before start */
 823
 824         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 825                 disengage_record_enable ();
 826         }
 827
 828         playback_sample = frame;
 829         file_frame = frame;
 830
 831         if (complete_refill) {
 832                 while ((ret = do_refill_with_alloc ()) > 0) ;
 833         } else {
 834                 ret = do_refill_with_alloc ();
 835         }
 836
 837         return ret;
 838 }
 839
 840 int
 841 AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
 842 {
 843         ChannelList::iterator chan;
 844         boost::shared_ptr<ChannelList> c = channels.reader();
 845
 846         for (chan = c->begin(); chan != c->end(); ++chan) {
 847                 if ((*chan)->playback_buf->read_space() < (size_t) distance) {
 848                         return false;
 849                 }
 850         }
 851         return true;
 852 }
 853
 854 int
 855 AudioDiskstream::internal_playback_seek (framecnt_t distance)
 856 {
 857         ChannelList::iterator chan;
 858         boost::shared_ptr<ChannelList> c = channels.reader();
 859
 860         for (chan = c->begin(); chan != c->end(); ++chan) {
 861                 (*chan)->playback_buf->increment_read_ptr (distance);
 862         }
 863
 864         if (first_recordable_frame < max_framepos) {
 865                 first_recordable_frame += distance;
 866         }
 867         playback_sample += distance;
 868
 869         return 0;
 870 }
 871
 872 /** Read some data for 1 channel from our playlist into a buffer.
 873  *  @param buf Buffer to write to.
 874  *  @param start Session frame to start reading from; updated to where we end up
 875  *         after the read.
 876  *  @param cnt Count of samples to read.
 877  *  @param reversed true if we are running backwards, otherwise false.
 878  */
 879 int
 880 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 881                        framepos_t& start, framecnt_t cnt,
 882                        int channel, bool reversed)
 883 {
 884         framecnt_t this_read = 0;
 885         bool reloop = false;
 886         framepos_t loop_end = 0;
 887         framepos_t loop_start = 0;
 888         framecnt_t offset = 0;
 889         Location *loc = 0;
 890
 891         /* XXX we don't currently play loops in reverse. not sure why */
 892
 893         if (!reversed) {
 894
 895                 framecnt_t loop_length = 0;
 896
 897                 /* Make the use of a Location atomic for this read operation.
 898
 899                    Note: Locations don't get deleted, so all we care about
 900                    when I say "atomic" is that we are always pointing to
 901                    the same one and using a start/length values obtained
 902                    just once.
 903                 */
 904
 905                 if ((loc = loop_location) != 0) {
 906                         loop_start = loc->start();
 907                         loop_end = loc->end();
 908                         loop_length = loop_end - loop_start;
 909                 }
 910
 911                 /* if we are looping, ensure that the first frame we read is at the correct
 912                    position within the loop.
 913                 */
 914
 915                 if (loc && start >= loop_end) {
 916                         start = loop_start + ((start - loop_start) % loop_length);
 917                 }
 918         }
 919
 920         if (reversed) {
 921                 start -= cnt;
 922         }
 923
 924         /* We need this while loop in case we hit a loop boundary, in which case our read from
 925            the playlist must be split into more than one section.
 926         */
 927
 928         while (cnt) {
 929
 930                 /* take any loop into account. we can't read past the end of the loop. */
 931
 932                 if (loc && (loop_end - start < cnt)) {
 933                         this_read = loop_end - start;
 934                         reloop = true;
 935                 } else {
 936                         reloop = false;
 937                         this_read = cnt;
 938                 }
 939
 940                 if (this_read == 0) {
 941                         break;
 942                 }
 943
 944                 this_read = min(cnt,this_read);
 945
 946                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 947                         error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), id(), this_read,
 948                                          start) << endmsg;
 949                         return -1;
 950                 }
 951
 952                 if (reversed) {
 953
 954                         swap_by_ptr (buf, buf + this_read - 1);
 955
 956                 } else {
 957
 958                         /* if we read to the end of the loop, go back to the beginning */
 959
 960                         if (reloop) {
 961                                 start = loop_start;
 962                         } else {
 963                                 start += this_read;
 964                         }
 965                 }
 966
 967                 cnt -= this_read;
 968                 offset += this_read;
 969         }
 970
 971         return 0;
 972 }
 973
 974 int
 975 AudioDiskstream::do_refill_with_alloc ()
 976 {
 977         Sample* mix_buf  = new Sample[disk_io_chunk_frames];
 978         float*  gain_buf = new float[disk_io_chunk_frames];
 979
 980         int ret = _do_refill(mix_buf, gain_buf);
 981
 982         delete [] mix_buf;
 983         delete [] gain_buf;
 984
 985         return ret;
 986 }
 987
 988 /** Get some more data from disk and put it in our channels' playback_bufs,
 989  *  if there is suitable space in them.
 990  */
 991 int
 992 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 993 {
 994         int32_t ret = 0;
 995         framecnt_t to_read;
 996         RingBufferNPT<Sample>::rw_vector vector;
 997         bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
 998         framecnt_t total_space;
 999         framecnt_t zero_fill;
1000         uint32_t chan_n;
1001         ChannelList::iterator i;
1002         boost::shared_ptr<ChannelList> c = channels.reader();
1003         framecnt_t ts;
1004
1005         if (c->empty()) {
1006                 return 0;
1007         }
1008
1009         assert(mixdown_buffer);
1010         assert(gain_buffer);
1011
1012         vector.buf[0] = 0;
1013         vector.len[0] = 0;
1014         vector.buf[1] = 0;
1015         vector.len[1] = 0;
1016
1017         c->front()->playback_buf->get_write_vector (&vector);
1018
1019         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1020                 /* nowhere to write to */
1021                 return 0;
1022         }
1023
1024         /* if there are 2+ chunks of disk i/o possible for
1025            this track, let the caller know so that it can arrange
1026            for us to be called again, ASAP.
1027         */
1028
1029         if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) {
1030                 ret = 1;
1031         }
1032
1033         /* if we're running close to normal speed and there isn't enough
1034            space to do disk_io_chunk_frames of I/O, then don't bother.
1035
1036            at higher speeds, just do it because the sync between butler
1037            and audio thread may not be good enough.
1038
1039            Note: it is a design assumption that disk_io_chunk_frames is smaller
1040            than the playback buffer size, so this check should never trip when
1041            the playback buffer is empty.
1042         */
1043
1044         if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1045                 return 0;
1046         }
1047
1048         /* when slaved, don't try to get too close to the read pointer. this
1049            leaves space for the buffer reversal to have something useful to
1050            work with.
1051         */
1052
1053         if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) {
1054                 return 0;
1055         }
1056
1057         /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1058
1059         total_space = min (disk_io_chunk_frames, total_space);
1060
1061         if (reversed) {
1062
1063                 if (file_frame == 0) {
1064
1065                         /* at start: nothing to do but fill with silence */
1066
1067                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1068
1069                                 ChannelInfo* chan (*i);
1070                                 chan->playback_buf->get_write_vector (&vector);
1071                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1072                                 if (vector.len[1]) {
1073                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1074                                 }
1075                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1076                         }
1077                         return 0;
1078                 }
1079
1080                 if (file_frame < total_space) {
1081
1082                         /* too close to the start: read what we can,
1083                            and then zero fill the rest
1084                         */
1085
1086                         zero_fill = total_space - file_frame;
1087                         total_space = file_frame;
1088
1089                 } else {
1090
1091                         zero_fill = 0;
1092                 }
1093
1094         } else {
1095
1096                 if (file_frame == max_framepos) {
1097
1098                         /* at end: nothing to do but fill with silence */
1099
1100                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1101
1102                                 ChannelInfo* chan (*i);
1103                                 chan->playback_buf->get_write_vector (&vector);
1104                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1105                                 if (vector.len[1]) {
1106                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1107                                 }
1108                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1109                         }
1110                         return 0;
1111                 }
1112
1113                 if (file_frame > max_framepos - total_space) {
1114
1115                         /* to close to the end: read what we can, and zero fill the rest */
1116
1117                         zero_fill = total_space - (max_framepos - file_frame);
1118                         total_space = max_framepos - file_frame;
1119
1120                 } else {
1121                         zero_fill = 0;
1122                 }
1123         }
1124
1125         framepos_t file_frame_tmp = 0;
1126
1127         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1128
1129                 ChannelInfo* chan (*i);
1130                 Sample* buf1;
1131                 Sample* buf2;
1132                 framecnt_t len1, len2;
1133
1134                 chan->playback_buf->get_write_vector (&vector);
1135
1136                 if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
1137
1138                         /* we're not going to fill the first chunk, so certainly do not bother with the
1139                            other part. it won't be connected with the part we do fill, as in:
1140
1141                            .... => writable space
1142                            ++++ => readable space
1143                            ^^^^ => 1 x disk_io_chunk_frames that would be filled
1144
1145                            |......|+++++++++++++|...............................|
1146                            buf1                buf0
1147                                                 ^^^^^^^^^^^^^^^
1148
1149
1150                            So, just pretend that the buf1 part isn't there.
1151
1152                         */
1153
1154                         vector.buf[1] = 0;
1155                         vector.len[1] = 0;
1156
1157                 }
1158
1159                 ts = total_space;
1160                 file_frame_tmp = file_frame;
1161
1162                 buf1 = vector.buf[0];
1163                 len1 = vector.len[0];
1164                 buf2 = vector.buf[1];
1165                 len2 = vector.len[1];
1166
1167                 to_read = min (ts, len1);
1168                 to_read = min (to_read, disk_io_chunk_frames);
1169
1170                 assert (to_read >= 0);
1171
1172                 if (to_read) {
1173
1174                         if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1175                                 ret = -1;
1176                                 goto out;
1177                         }
1178
1179                         chan->playback_buf->increment_write_ptr (to_read);
1180                         ts -= to_read;
1181                 }
1182
1183                 to_read = min (ts, len2);
1184
1185                 if (to_read) {
1186
1187                         /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1188                            so read some or all of vector.len[1] as well.
1189                         */
1190
1191                         if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1192                                 ret = -1;
1193                                 goto out;
1194                         }
1195
1196                         chan->playback_buf->increment_write_ptr (to_read);
1197                 }
1198
1199                 if (zero_fill) {
1200                         /* XXX: do something */
1201                 }
1202
1203         }
1204
1205         file_frame = file_frame_tmp;
1206         assert (file_frame >= 0);
1207
1208   out:
1209
1210         return ret;
1211 }
1212
1213 /** Flush pending data to disk.
1214  *
1215  * Important note: this function will write *AT MOST* disk_io_chunk_frames
1216  * of data to disk. it will never write more than that.  If it writes that
1217  * much and there is more than that waiting to be written, it will return 1,
1218  * otherwise 0 on success or -1 on failure.
1219  *
1220  * If there is less than disk_io_chunk_frames to be written, no data will be
1221  * written at all unless @a force_flush is true.
1222  */
1223 int
1224 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1225 {
1226         uint32_t to_write;
1227         int32_t ret = 0;
1228         RingBufferNPT<Sample>::rw_vector vector;
1229         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1230         framecnt_t total;
1231
1232         transvec.buf[0] = 0;
1233         transvec.buf[1] = 0;
1234         vector.buf[0] = 0;
1235         vector.buf[1] = 0;
1236
1237         boost::shared_ptr<ChannelList> c = channels.reader();
1238         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1239
1240                 (*chan)->capture_buf->get_read_vector (&vector);
1241
1242                 total = vector.len[0] + vector.len[1];
1243
1244                 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1245                         goto out;
1246                 }
1247
1248                 /* if there are 2+ chunks of disk i/o possible for
1249                    this track, let the caller know so that it can arrange
1250                    for us to be called again, ASAP.
1251
1252                    if we are forcing a flush, then if there is* any* extra
1253                    work, let the caller know.
1254
1255                    if we are no longer recording and there is any extra work,
1256                    let the caller know too.
1257                 */
1258
1259                 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1260                         ret = 1;
1261                 }
1262
1263                 to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
1264
1265                 // check the transition buffer when recording destructive
1266                 // important that we get this after the capture buf
1267
1268                 if (destructive()) {
1269                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
1270                         size_t transcount = transvec.len[0] + transvec.len[1];
1271                         size_t ti;
1272
1273                         for (ti=0; ti < transcount; ++ti) {
1274                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1275
1276                                 if (captrans.type == CaptureStart) {
1277                                         // by definition, the first data we got above represents the given capture pos
1278
1279                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
1280                                         (*chan)->curr_capture_cnt = 0;
1281
1282                                 } else if (captrans.type == CaptureEnd) {
1283
1284                                         // capture end, the capture_val represents total frames in capture
1285
1286                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1287
1288                                                 // shorten to make the write a perfect fit
1289                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1290
1291                                                 if (nto_write < to_write) {
1292                                                         ret = 1; // should we?
1293                                                 }
1294                                                 to_write = nto_write;
1295
1296                                                 (*chan)->write_source->mark_capture_end ();
1297
1298                                                 // increment past this transition, but go no further
1299                                                 ++ti;
1300                                                 break;
1301                                         }
1302                                         else {
1303                                                 // actually ends just beyond this chunk, so force more work
1304                                                 ret = 1;
1305                                                 break;
1306                                         }
1307                                 }
1308                         }
1309
1310                         if (ti > 0) {
1311                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1312                         }
1313                 }
1314
1315                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1316                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1317                         return -1;
1318                 }
1319
1320                 (*chan)->capture_buf->increment_read_ptr (to_write);
1321                 (*chan)->curr_capture_cnt += to_write;
1322
1323                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1324
1325                         /* we wrote all of vector.len[0] but it wasn't an entire
1326                            disk_io_chunk_frames of data, so arrange for some part
1327                            of vector.len[1] to be flushed to disk as well.
1328                         */
1329
1330                         to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1331
1332                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1333                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1334                                 return -1;
1335                         }
1336
1337                         (*chan)->capture_buf->increment_read_ptr (to_write);
1338                         (*chan)->curr_capture_cnt += to_write;
1339                 }
1340         }
1341
1342   out:
1343         return ret;
1344 }
1345
1346 void
1347 AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1348 {
1349         uint32_t buffer_position;
1350         bool more_work = true;
1351         int err = 0;
1352         boost::shared_ptr<AudioRegion> region;
1353         framecnt_t total_capture;
1354         SourceList srcs;
1355         SourceList::iterator src;
1356         ChannelList::iterator chan;
1357         vector<CaptureInfo*>::iterator ci;
1358         boost::shared_ptr<ChannelList> c = channels.reader();
1359         uint32_t n = 0;
1360         bool mark_write_completed = false;
1361
1362         finish_capture (c);
1363
1364         /* butler is already stopped, but there may be work to do
1365            to flush remaining data to disk.
1366         */
1367
1368         while (more_work && !err) {
1369                 switch (do_flush (TransportContext, true)) {
1370                 case 0:
1371                         more_work = false;
1372                         break;
1373                 case 1:
1374                         break;
1375                 case -1:
1376                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1377                         err++;
1378                 }
1379         }
1380
1381         /* XXX is there anything we can do if err != 0 ? */
1382         Glib::Mutex::Lock lm (capture_info_lock);
1383
1384         if (capture_info.empty()) {
1385                 return;
1386         }
1387
1388         if (abort_capture) {
1389
1390                 if (destructive()) {
1391                         goto outout;
1392                 }
1393
1394                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1395
1396                         if ((*chan)->write_source) {
1397
1398                                 (*chan)->write_source->mark_for_remove ();
1399                                 (*chan)->write_source->drop_references ();
1400                                 (*chan)->write_source.reset ();
1401                         }
1402
1403                         /* new source set up in "out" below */
1404                 }
1405
1406                 goto out;
1407         }
1408
1409         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1410                 total_capture += (*ci)->frames;
1411         }
1412
1413         /* figure out the name for this take */
1414
1415         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1416
1417                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1418
1419                 if (s) {
1420                         srcs.push_back (s);
1421                         s->update_header (capture_info.front()->start, when, twhen);
1422                         s->set_captured_for (_name.val());
1423                         s->mark_immutable ();
1424
1425                         if (Config->get_auto_analyse_audio()) {
1426                                 Analyser::queue_source_for_analysis (s, true);
1427                         }
1428                 }
1429         }
1430
1431         /* destructive tracks have a single, never changing region */
1432
1433         if (destructive()) {
1434
1435                 /* send a signal that any UI can pick up to do the right thing. there is
1436                    a small problem here in that a UI may need the peak data to be ready
1437                    for the data that was recorded and this isn't interlocked with that
1438                    process. this problem is deferred to the UI.
1439                  */
1440
1441                 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1442
1443         } else {
1444
1445                 string whole_file_region_name;
1446                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1447
1448                 /* Register a new region with the Session that
1449                    describes the entire source. Do this first
1450                    so that any sub-regions will obviously be
1451                    children of this one (later!)
1452                 */
1453
1454                 try {
1455                         PropertyList plist;
1456
1457                         plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1458                         plist.add (Properties::length, total_capture);
1459                         plist.add (Properties::name, whole_file_region_name);
1460                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1461                         rx->set_automatic (true);
1462                         rx->set_whole_file (true);
1463
1464                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1465                         region->special_set_position (capture_info.front()->start);
1466                 }
1467
1468
1469                 catch (failed_constructor& err) {
1470                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1471                         /* XXX what now? */
1472                 }
1473
1474                 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1475
1476                 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1477
1478                 _playlist->clear_changes ();
1479                 _playlist->freeze ();
1480
1481                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1482
1483                         string region_name;
1484
1485                         RegionFactory::region_name (region_name, whole_file_region_name, false);
1486
1487                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1488                                                                               _name, (*ci)->start, (*ci)->frames, region_name));
1489
1490                         try {
1491
1492                                 PropertyList plist;
1493
1494                                 plist.add (Properties::start, buffer_position);
1495                                 plist.add (Properties::length, (*ci)->frames);
1496                                 plist.add (Properties::name, region_name);
1497
1498                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1499                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1500                         }
1501
1502                         catch (failed_constructor& err) {
1503                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1504                                 continue; /* XXX is this OK? */
1505                         }
1506
1507                         i_am_the_modifier++;
1508
1509                         _playlist->add_region (region, (*ci)->start, 1, non_layered());
1510                         _playlist->set_layer (region, DBL_MAX);
1511                         i_am_the_modifier--;
1512
1513                         buffer_position += (*ci)->frames;
1514                 }
1515
1516                 _playlist->thaw ();
1517                 _session.add_command (new StatefulDiffCommand (_playlist));
1518         }
1519
1520         mark_write_completed = true;
1521
1522   out:
1523         reset_write_sources (mark_write_completed);
1524
1525   outout:
1526
1527         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1528                 delete *ci;
1529         }
1530
1531         capture_info.clear ();
1532         capture_start_frame = 0;
1533 }
1534
1535 void
1536 AudioDiskstream::transport_looped (framepos_t transport_frame)
1537 {
1538         if (was_recording) {
1539                 // all we need to do is finish this capture, with modified capture length
1540                 boost::shared_ptr<ChannelList> c = channels.reader();
1541
1542                 // adjust the capture length knowing that the data will be recorded to disk
1543                 // only necessary after the first loop where we're recording
1544                 if (capture_info.size() == 0) {
1545                         capture_captured += _capture_offset;
1546
1547                         if (_alignment_style == ExistingMaterial) {
1548                                 capture_captured += _session.worst_output_latency();
1549                         } else {
1550                                 capture_captured += _roll_delay;
1551                         }
1552                 }
1553
1554                 finish_capture (c);
1555
1556                 // the next region will start recording via the normal mechanism
1557                 // we'll set the start position to the current transport pos
1558                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1559                 capture_start_frame = transport_frame;
1560                 first_recordable_frame = transport_frame; // mild lie
1561                 last_recordable_frame = max_framepos;
1562                 was_recording = true;
1563
1564                 if (recordable() && destructive()) {
1565                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1566
1567                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1568                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1569
1570                                 if (transvec.len[0] > 0) {
1571                                         transvec.buf[0]->type = CaptureStart;
1572                                         transvec.buf[0]->capture_val = capture_start_frame;
1573                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1574                                 }
1575                                 else {
1576                                         // bad!
1577                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1578                                               << endmsg;
1579                                 }
1580                         }
1581                 }
1582
1583         }
1584 }
1585
1586 void
1587 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1588 {
1589         was_recording = false;
1590         first_recordable_frame = max_framepos;
1591         last_recordable_frame = max_framepos;
1592
1593         if (capture_captured == 0) {
1594                 return;
1595         }
1596
1597         if (recordable() && destructive()) {
1598                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1599
1600                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1601                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1602
1603                         if (transvec.len[0] > 0) {
1604                                 transvec.buf[0]->type = CaptureEnd;
1605                                 transvec.buf[0]->capture_val = capture_captured;
1606                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1607                         }
1608                         else {
1609                                 // bad!
1610                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1611                         }
1612                 }
1613         }
1614
1615
1616         CaptureInfo* ci = new CaptureInfo;
1617
1618         ci->start =  capture_start_frame;
1619         ci->frames = capture_captured;
1620
1621         /* XXX theoretical race condition here. Need atomic exchange ?
1622            However, the circumstances when this is called right
1623            now (either on record-disable or transport_stopped)
1624            mean that no actual race exists. I think ...
1625            We now have a capture_info_lock, but it is only to be used
1626            to synchronize in the transport_stop and the capture info
1627            accessors, so that invalidation will not occur (both non-realtime).
1628         */
1629
1630         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1631
1632         capture_info.push_back (ci);
1633         capture_captured = 0;
1634
1635         /* now we've finished a capture, reset first_recordable_frame for next time */
1636         first_recordable_frame = max_framepos;
1637 }
1638
1639 void
1640 AudioDiskstream::set_record_enabled (bool yn)
1641 {
1642         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1643                 return;
1644         }
1645
1646         /* can't rec-enable in destructive mode if transport is before start */
1647
1648         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1649                 return;
1650         }
1651
1652         /* yes, i know that this not proof against race conditions, but its
1653            good enough. i think.
1654         */
1655
1656         if (record_enabled() != yn) {
1657                 if (yn) {
1658                         engage_record_enable ();
1659                 } else {
1660                         disengage_record_enable ();
1661                 }
1662         }
1663 }
1664
1665 void
1666 AudioDiskstream::engage_record_enable ()
1667 {
1668         bool rolling = _session.transport_speed() != 0.0f;
1669         boost::shared_ptr<ChannelList> c = channels.reader();
1670
1671         g_atomic_int_set (&_record_enabled, 1);
1672         capturing_sources.clear ();
1673
1674         if (Config->get_monitoring_model() == HardwareMonitoring) {
1675
1676                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1677                         (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1678                         capturing_sources.push_back ((*chan)->write_source);
1679                         (*chan)->write_source->mark_streaming_write_started ();
1680                 }
1681
1682         } else {
1683                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1684                         capturing_sources.push_back ((*chan)->write_source);
1685                         (*chan)->write_source->mark_streaming_write_started ();
1686                 }
1687         }
1688
1689         RecordEnableChanged (); /* EMIT SIGNAL */
1690 }
1691
1692 void
1693 AudioDiskstream::disengage_record_enable ()
1694 {
1695         g_atomic_int_set (&_record_enabled, 0);
1696         boost::shared_ptr<ChannelList> c = channels.reader();
1697         if (Config->get_monitoring_model() == HardwareMonitoring) {
1698                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1699                         (*chan)->source.request_jack_monitors_input (false);
1700                 }
1701         }
1702         capturing_sources.clear ();
1703         RecordEnableChanged (); /* EMIT SIGNAL */
1704 }
1705
1706 XMLNode&
1707 AudioDiskstream::get_state ()
1708 {
1709         XMLNode& node (Diskstream::get_state());
1710         char buf[64] = "";
1711         LocaleGuard lg (X_("POSIX"));
1712
1713         boost::shared_ptr<ChannelList> c = channels.reader();
1714         snprintf (buf, sizeof(buf), "%zd", c->size());
1715         node.add_property ("channels", buf);
1716
1717         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1718
1719                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1720                 XMLNode* cs_grandchild;
1721
1722                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1723                         cs_grandchild = new XMLNode (X_("file"));
1724                         cs_grandchild->add_property (X_("path"), (*i)->path());
1725                         cs_child->add_child_nocopy (*cs_grandchild);
1726                 }
1727
1728                 /* store the location where capture will start */
1729
1730                 Location* pi;
1731
1732                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1733                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1734                 } else {
1735                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1736                 }
1737
1738                 cs_child->add_property (X_("at"), buf);
1739                 node.add_child_nocopy (*cs_child);
1740         }
1741
1742         return node;
1743 }
1744
1745 int
1746 AudioDiskstream::set_state (const XMLNode& node, int version)
1747 {
1748         const XMLProperty* prop;
1749         XMLNodeList nlist = node.children();
1750         XMLNodeIterator niter;
1751         uint32_t nchans = 1;
1752         XMLNode* capture_pending_node = 0;
1753         LocaleGuard lg (X_("POSIX"));
1754
1755         /* prevent write sources from being created */
1756
1757         in_set_state = true;
1758
1759         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1760                 if ((*niter)->name() == IO::state_node_name) {
1761                         deprecated_io_node = new XMLNode (**niter);
1762                 }
1763
1764                 if ((*niter)->name() == X_("CapturingSources")) {
1765                         capture_pending_node = *niter;
1766                 }
1767         }
1768
1769         if (Diskstream::set_state (node, version)) {
1770                 return -1;
1771         }
1772
1773         if ((prop = node.property ("channels")) != 0) {
1774                 nchans = atoi (prop->value().c_str());
1775         }
1776
1777         // create necessary extra channels
1778         // we are always constructed with one and we always need one
1779
1780         _n_channels.set(DataType::AUDIO, channels.reader()->size());
1781
1782         if (nchans > _n_channels.n_audio()) {
1783
1784                 add_channel (nchans - _n_channels.n_audio());
1785                 IO::PortCountChanged(_n_channels);
1786
1787         } else if (nchans < _n_channels.n_audio()) {
1788
1789                 remove_channel (_n_channels.n_audio() - nchans);
1790         }
1791
1792
1793
1794         if (!destructive() && capture_pending_node) {
1795                 /* destructive streams have one and only one source per channel,
1796                    and so they never end up in pending capture in any useful
1797                    sense.
1798                 */
1799                 use_pending_capture_data (*capture_pending_node);
1800         }
1801
1802         in_set_state = false;
1803
1804         /* make sure this is clear before we do anything else */
1805
1806         capturing_sources.clear ();
1807
1808         /* write sources are handled when we handle the input set
1809            up of the IO that owns this DS (::non_realtime_input_change())
1810         */
1811
1812         return 0;
1813 }
1814
1815 int
1816 AudioDiskstream::use_new_write_source (uint32_t n)
1817 {
1818         boost::shared_ptr<ChannelList> c = channels.reader();
1819
1820         if (!recordable()) {
1821                 return 1;
1822         }
1823
1824         if (n >= c->size()) {
1825                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1826                 return -1;
1827         }
1828
1829         ChannelInfo* chan = (*c)[n];
1830
1831         try {
1832                 if ((chan->write_source = _session.create_audio_source_for_session (
1833                              n_channels().n_audio(), name(), n, destructive())) == 0) {
1834                         throw failed_constructor();
1835                 }
1836         }
1837
1838         catch (failed_constructor &err) {
1839                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1840                 chan->write_source.reset ();
1841                 return -1;
1842         }
1843
1844         /* do not remove destructive files even if they are empty */
1845
1846         chan->write_source->set_allow_remove_if_empty (!destructive());
1847
1848         return 0;
1849 }
1850
1851 list<boost::shared_ptr<Source> >
1852 AudioDiskstream::steal_write_sources()
1853 {
1854         /* not possible to steal audio write sources */
1855         list<boost::shared_ptr<Source> > ret;
1856         return ret;
1857 }
1858
1859 void
1860 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1861 {
1862         ChannelList::iterator chan;
1863         boost::shared_ptr<ChannelList> c = channels.reader();
1864         uint32_t n;
1865
1866         if (!_session.writable() || !recordable()) {
1867                 return;
1868         }
1869
1870         capturing_sources.clear ();
1871
1872         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1873
1874                 if (!destructive()) {
1875
1876                         if ((*chan)->write_source) {
1877
1878                                 if (mark_write_complete) {
1879                                         (*chan)->write_source->mark_streaming_write_completed ();
1880                                         (*chan)->write_source->done_with_peakfile_writes ();
1881                                 }
1882
1883                                 if ((*chan)->write_source->removable()) {
1884                                         (*chan)->write_source->mark_for_remove ();
1885                                         (*chan)->write_source->drop_references ();
1886                                 }
1887
1888                                 (*chan)->write_source.reset ();
1889                         }
1890
1891                         use_new_write_source (n);
1892
1893                         if (record_enabled()) {
1894                                 capturing_sources.push_back ((*chan)->write_source);
1895                         }
1896
1897                 } else {
1898
1899                         if ((*chan)->write_source == 0) {
1900                                 use_new_write_source (n);
1901                         }
1902                 }
1903         }
1904
1905         if (destructive() && !c->empty ()) {
1906
1907                 /* we now have all our write sources set up, so create the
1908                    playlist's single region.
1909                 */
1910
1911                 if (_playlist->empty()) {
1912                         setup_destructive_playlist ();
1913                 }
1914         }
1915 }
1916
1917 void
1918 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1919 {
1920         if (_session.get_block_size() > speed_buffer_size) {
1921                 speed_buffer_size = _session.get_block_size();
1922                 boost::shared_ptr<ChannelList> c = channels.reader();
1923
1924                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1925                         if ((*chan)->speed_buffer)
1926                                 delete [] (*chan)->speed_buffer;
1927                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
1928                 }
1929         }
1930         allocate_temporary_buffers ();
1931 }
1932
1933 void
1934 AudioDiskstream::allocate_temporary_buffers ()
1935 {
1936         /* make sure the wrap buffer is at least large enough to deal
1937            with the speeds up to 1.2, to allow for micro-variation
1938            when slaving to MTC, Timecode etc.
1939         */
1940
1941         double const sp = max (fabsf (_actual_speed), 1.2f);
1942         framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1943
1944         if (required_wrap_size > wrap_buffer_size) {
1945
1946                 boost::shared_ptr<ChannelList> c = channels.reader();
1947
1948                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1949                         if ((*chan)->playback_wrap_buffer) {
1950                                 delete [] (*chan)->playback_wrap_buffer;
1951                         }
1952                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1953                         if ((*chan)->capture_wrap_buffer) {
1954                                 delete [] (*chan)->capture_wrap_buffer;
1955                         }
1956                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1957                 }
1958
1959                 wrap_buffer_size = required_wrap_size;
1960         }
1961 }
1962
1963 void
1964 AudioDiskstream::request_jack_monitors_input (bool yn)
1965 {
1966         boost::shared_ptr<ChannelList> c = channels.reader();
1967
1968         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1969                 (*chan)->source.request_jack_monitors_input (yn);
1970         }
1971 }
1972
1973 void
1974 AudioDiskstream::set_align_style_from_io ()
1975 {
1976         bool have_physical = false;
1977
1978         if (_alignment_choice != Automatic) {
1979                 return;
1980         }
1981
1982         if (_io == 0) {
1983                 return;
1984         }
1985
1986         get_input_sources ();
1987
1988         boost::shared_ptr<ChannelList> c = channels.reader();
1989
1990         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1991                 if ((*chan)->source.is_physical ()) {
1992                         have_physical = true;
1993                         break;
1994                 }
1995         }
1996
1997         if (have_physical) {
1998                 set_align_style (ExistingMaterial);
1999         } else {
2000                 set_align_style (CaptureTime);
2001         }
2002 }
2003
2004 int
2005 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2006 {
2007         while (how_many--) {
2008                 c->push_back (new ChannelInfo(
2009                                       _session.butler()->audio_diskstream_playback_buffer_size(),
2010                                       _session.butler()->audio_diskstream_capture_buffer_size(),
2011                                       speed_buffer_size, wrap_buffer_size));
2012                 interpolation.add_channel_to (
2013                         _session.butler()->audio_diskstream_playback_buffer_size(),
2014                         speed_buffer_size);
2015         }
2016
2017         _n_channels.set(DataType::AUDIO, c->size());
2018
2019         return 0;
2020 }
2021
2022 int
2023 AudioDiskstream::add_channel (uint32_t how_many)
2024 {
2025         RCUWriter<ChannelList> writer (channels);
2026         boost::shared_ptr<ChannelList> c = writer.get_copy();
2027
2028         return add_channel_to (c, how_many);
2029 }
2030
2031 int
2032 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2033 {
2034         while (how_many-- && !c->empty()) {
2035                 delete c->back();
2036                 c->pop_back();
2037                 interpolation.remove_channel_from ();
2038         }
2039
2040         _n_channels.set(DataType::AUDIO, c->size());
2041
2042         return 0;
2043 }
2044
2045 int
2046 AudioDiskstream::remove_channel (uint32_t how_many)
2047 {
2048         RCUWriter<ChannelList> writer (channels);
2049         boost::shared_ptr<ChannelList> c = writer.get_copy();
2050
2051         return remove_channel_from (c, how_many);
2052 }
2053
2054 float
2055 AudioDiskstream::playback_buffer_load () const
2056 {
2057         boost::shared_ptr<ChannelList> c = channels.reader();
2058
2059         if (c->empty ()) {
2060                 return 0;
2061         }
2062
2063         return (float) ((double) c->front()->playback_buf->read_space()/
2064                         (double) c->front()->playback_buf->bufsize());
2065 }
2066
2067 float
2068 AudioDiskstream::capture_buffer_load () const
2069 {
2070         boost::shared_ptr<ChannelList> c = channels.reader();
2071
2072         if (c->empty ()) {
2073                 return 0;
2074         }
2075
2076         return (float) ((double) c->front()->capture_buf->write_space()/
2077                         (double) c->front()->capture_buf->bufsize());
2078 }
2079
2080 int
2081 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2082 {
2083         const XMLProperty* prop;
2084         XMLNodeList nlist = node.children();
2085         XMLNodeIterator niter;
2086         boost::shared_ptr<AudioFileSource> fs;
2087         boost::shared_ptr<AudioFileSource> first_fs;
2088         SourceList pending_sources;
2089         framepos_t position;
2090
2091         if ((prop = node.property (X_("at"))) == 0) {
2092                 return -1;
2093         }
2094
2095         if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2096                 return -1;
2097         }
2098
2099         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2100                 if ((*niter)->name() == X_("file")) {
2101
2102                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2103                                 continue;
2104                         }
2105
2106                         // This protects sessions from errant CapturingSources in stored sessions
2107                         struct stat sbuf;
2108                         if (stat (prop->value().c_str(), &sbuf)) {
2109                                 continue;
2110                         }
2111
2112                         try {
2113                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2114                                         SourceFactory::createWritable (
2115                                                 DataType::AUDIO, _session,
2116                                                 prop->value(), string(), false, _session.frame_rate()));
2117                         }
2118
2119                         catch (failed_constructor& err) {
2120                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2121                                                   _name, prop->value())
2122                                       << endmsg;
2123                                 return -1;
2124                         }
2125
2126                         pending_sources.push_back (fs);
2127
2128                         if (first_fs == 0) {
2129                                 first_fs = fs;
2130                         }
2131
2132                         fs->set_captured_for (_name.val());
2133                 }
2134         }
2135
2136         if (pending_sources.size() == 0) {
2137                 /* nothing can be done */
2138                 return 1;
2139         }
2140
2141         if (pending_sources.size() != _n_channels.n_audio()) {
2142                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2143                       << endmsg;
2144                 return -1;
2145         }
2146
2147         boost::shared_ptr<AudioRegion> region;
2148
2149         try {
2150
2151                 PropertyList plist;
2152
2153                 plist.add (Properties::start, 0);
2154                 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2155                 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2156
2157                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2158
2159                 region->set_automatic (true);
2160                 region->set_whole_file (true);
2161                 region->special_set_position (0);
2162         }
2163
2164         catch (failed_constructor& err) {
2165                 error << string_compose (
2166                                 _("%1: cannot create whole-file region from pending capture sources"),
2167                                 _name) << endmsg;
2168
2169                 return -1;
2170         }
2171
2172         _playlist->add_region (region, position);
2173
2174         return 0;
2175 }
2176
2177 int
2178 AudioDiskstream::set_non_layered (bool yn)
2179 {
2180         if (yn != non_layered()) {
2181
2182                 if (yn) {
2183                         _flags = Flag (_flags | NonLayered);
2184                 } else {
2185                         _flags = Flag (_flags & ~NonLayered);
2186                 }
2187         }
2188
2189         return 0;
2190 }
2191
2192 int
2193 AudioDiskstream::set_destructive (bool yn)
2194 {
2195         if (yn != destructive()) {
2196
2197                 if (yn) {
2198                         bool bounce_ignored;
2199                         /* requestor should already have checked this and
2200                            bounced if necessary and desired
2201                         */
2202                         if (!can_become_destructive (bounce_ignored)) {
2203                                 return -1;
2204                         }
2205                         _flags = Flag (_flags | Destructive);
2206                         use_destructive_playlist ();
2207                 } else {
2208                         _flags = Flag (_flags & ~Destructive);
2209                         reset_write_sources (true, true);
2210                 }
2211         }
2212
2213         return 0;
2214 }
2215
2216 bool
2217 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2218 {
2219         if (!_playlist) {
2220                 requires_bounce = false;
2221                 return false;
2222         }
2223
2224         /* is there only one region ? */
2225
2226         if (_playlist->n_regions() != 1) {
2227                 requires_bounce = true;
2228                 return false;
2229         }
2230
2231         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2232         if (!first) {
2233                 requires_bounce = false;
2234                 return true;
2235         }
2236
2237         /* do the source(s) for the region cover the session start position ? */
2238
2239         if (first->position() != _session.current_start_frame()) {
2240                 if (first->start() > _session.current_start_frame()) {
2241                         requires_bounce = true;
2242                         return false;
2243                 }
2244         }
2245
2246         /* is the source used by only 1 playlist ? */
2247
2248         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2249
2250         assert (afirst);
2251
2252         if (_session.playlists->source_use_count (afirst->source()) > 1) {
2253                 requires_bounce = true;
2254                 return false;
2255         }
2256
2257         requires_bounce = false;
2258         return true;
2259 }
2260
2261 void
2262 AudioDiskstream::adjust_playback_buffering ()
2263 {
2264         boost::shared_ptr<ChannelList> c = channels.reader();
2265
2266         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2267                 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2268         }
2269 }
2270
2271 void
2272 AudioDiskstream::adjust_capture_buffering ()
2273 {
2274         boost::shared_ptr<ChannelList> c = channels.reader();
2275
2276         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2277                 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2278         }
2279 }
2280
2281 bool
2282 AudioDiskstream::ChannelSource::is_physical () const
2283 {
2284         if (name.empty()) {
2285                 return false;
2286         }
2287
2288         return AudioEngine::instance()->port_is_physical (name);
2289 }
2290
2291 void
2292 AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const
2293 {
2294         if (name.empty()) {
2295                 return;
2296         }
2297
2298         return AudioEngine::instance()->request_jack_monitors_input (name, yn);
2299 }
2300
2301 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2302 {
2303         current_capture_buffer = 0;
2304         current_playback_buffer = 0;
2305         curr_capture_cnt = 0;
2306
2307         speed_buffer = new Sample[speed_size];
2308         playback_wrap_buffer = new Sample[wrap_size];
2309         capture_wrap_buffer = new Sample[wrap_size];
2310
2311         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2312         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2313         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2314
2315         /* touch the ringbuffer buffers, which will cause
2316            them to be mapped into locked physical RAM if
2317            we're running with mlockall(). this doesn't do
2318            much if we're not.
2319         */
2320
2321         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2322         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2323         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2324 }
2325
2326 void
2327 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2328 {
2329         delete playback_buf;
2330         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2331         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2332 }
2333
2334 void
2335 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2336 {
2337         delete capture_buf;
2338
2339         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2340         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2341 }
2342
2343 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2344 {
2345         write_source.reset ();
2346
2347         delete [] speed_buffer;
2348         speed_buffer = 0;
2349
2350         delete [] playback_wrap_buffer;
2351         playback_wrap_buffer = 0;
2352
2353         delete [] capture_wrap_buffer;
2354         capture_wrap_buffer = 0;
2355
2356         delete playback_buf;
2357         playback_buf = 0;
2358
2359         delete capture_buf;
2360         capture_buf = 0;
2361
2362         delete capture_transition_buf;
2363         capture_transition_buf = 0;
2364 }
2365
2366
2367 bool
2368 AudioDiskstream::set_name (string const & name)
2369 {
2370         Diskstream::set_name (name);
2371
2372         /* get a new write source so that its name reflects the new diskstream name */
2373
2374         boost::shared_ptr<ChannelList> c = channels.reader();
2375         ChannelList::iterator i;
2376         int n = 0;
2377
2378         for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2379                 use_new_write_source (n);
2380         }
2381
2382         return true;
2383 }