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->set_capture_insertion_in_progress (true);
1480                 _playlist->freeze ();
1481
1482                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1483
1484                         string region_name;
1485
1486                         RegionFactory::region_name (region_name, whole_file_region_name, false);
1487
1488                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1489                                                                               _name, (*ci)->start, (*ci)->frames, region_name));
1490
1491                         try {
1492
1493                                 PropertyList plist;
1494
1495                                 plist.add (Properties::start, buffer_position);
1496                                 plist.add (Properties::length, (*ci)->frames);
1497                                 plist.add (Properties::name, region_name);
1498
1499                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1500                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1501                         }
1502
1503                         catch (failed_constructor& err) {
1504                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1505                                 continue; /* XXX is this OK? */
1506                         }
1507
1508                         i_am_the_modifier++;
1509
1510                         _playlist->add_region (region, (*ci)->start, 1, non_layered());
1511                         _playlist->set_layer (region, DBL_MAX);
1512                         i_am_the_modifier--;
1513
1514                         buffer_position += (*ci)->frames;
1515                 }
1516
1517                 _playlist->thaw ();
1518                 _playlist->set_capture_insertion_in_progress (false);
1519                 _session.add_command (new StatefulDiffCommand (_playlist));
1520         }
1521
1522         mark_write_completed = true;
1523
1524   out:
1525         reset_write_sources (mark_write_completed);
1526
1527   outout:
1528
1529         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1530                 delete *ci;
1531         }
1532
1533         capture_info.clear ();
1534         capture_start_frame = 0;
1535 }
1536
1537 void
1538 AudioDiskstream::transport_looped (framepos_t transport_frame)
1539 {
1540         if (was_recording) {
1541                 // all we need to do is finish this capture, with modified capture length
1542                 boost::shared_ptr<ChannelList> c = channels.reader();
1543
1544                 // adjust the capture length knowing that the data will be recorded to disk
1545                 // only necessary after the first loop where we're recording
1546                 if (capture_info.size() == 0) {
1547                         capture_captured += _capture_offset;
1548
1549                         if (_alignment_style == ExistingMaterial) {
1550                                 capture_captured += _session.worst_output_latency();
1551                         } else {
1552                                 capture_captured += _roll_delay;
1553                         }
1554                 }
1555
1556                 finish_capture (c);
1557
1558                 // the next region will start recording via the normal mechanism
1559                 // we'll set the start position to the current transport pos
1560                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1561                 capture_start_frame = transport_frame;
1562                 first_recordable_frame = transport_frame; // mild lie
1563                 last_recordable_frame = max_framepos;
1564                 was_recording = true;
1565
1566                 if (recordable() && destructive()) {
1567                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1568
1569                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1570                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1571
1572                                 if (transvec.len[0] > 0) {
1573                                         transvec.buf[0]->type = CaptureStart;
1574                                         transvec.buf[0]->capture_val = capture_start_frame;
1575                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1576                                 }
1577                                 else {
1578                                         // bad!
1579                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1580                                               << endmsg;
1581                                 }
1582                         }
1583                 }
1584
1585         }
1586 }
1587
1588 void
1589 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1590 {
1591         was_recording = false;
1592         first_recordable_frame = max_framepos;
1593         last_recordable_frame = max_framepos;
1594
1595         if (capture_captured == 0) {
1596                 return;
1597         }
1598
1599         if (recordable() && destructive()) {
1600                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1601
1602                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1603                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1604
1605                         if (transvec.len[0] > 0) {
1606                                 transvec.buf[0]->type = CaptureEnd;
1607                                 transvec.buf[0]->capture_val = capture_captured;
1608                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1609                         }
1610                         else {
1611                                 // bad!
1612                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1613                         }
1614                 }
1615         }
1616
1617
1618         CaptureInfo* ci = new CaptureInfo;
1619
1620         ci->start =  capture_start_frame;
1621         ci->frames = capture_captured;
1622
1623         /* XXX theoretical race condition here. Need atomic exchange ?
1624            However, the circumstances when this is called right
1625            now (either on record-disable or transport_stopped)
1626            mean that no actual race exists. I think ...
1627            We now have a capture_info_lock, but it is only to be used
1628            to synchronize in the transport_stop and the capture info
1629            accessors, so that invalidation will not occur (both non-realtime).
1630         */
1631
1632         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1633
1634         capture_info.push_back (ci);
1635         capture_captured = 0;
1636
1637         /* now we've finished a capture, reset first_recordable_frame for next time */
1638         first_recordable_frame = max_framepos;
1639 }
1640
1641 void
1642 AudioDiskstream::set_record_enabled (bool yn)
1643 {
1644         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1645                 return;
1646         }
1647
1648         /* can't rec-enable in destructive mode if transport is before start */
1649
1650         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1651                 return;
1652         }
1653
1654         /* yes, i know that this not proof against race conditions, but its
1655            good enough. i think.
1656         */
1657
1658         if (record_enabled() != yn) {
1659                 if (yn) {
1660                         engage_record_enable ();
1661                 } else {
1662                         disengage_record_enable ();
1663                 }
1664         }
1665 }
1666
1667 void
1668 AudioDiskstream::engage_record_enable ()
1669 {
1670         bool rolling = _session.transport_speed() != 0.0f;
1671         boost::shared_ptr<ChannelList> c = channels.reader();
1672
1673         g_atomic_int_set (&_record_enabled, 1);
1674         capturing_sources.clear ();
1675
1676         if (Config->get_monitoring_model() == HardwareMonitoring) {
1677
1678                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1679                         (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1680                         capturing_sources.push_back ((*chan)->write_source);
1681                         (*chan)->write_source->mark_streaming_write_started ();
1682                 }
1683
1684         } else {
1685                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1686                         capturing_sources.push_back ((*chan)->write_source);
1687                         (*chan)->write_source->mark_streaming_write_started ();
1688                 }
1689         }
1690
1691         RecordEnableChanged (); /* EMIT SIGNAL */
1692 }
1693
1694 void
1695 AudioDiskstream::disengage_record_enable ()
1696 {
1697         g_atomic_int_set (&_record_enabled, 0);
1698         boost::shared_ptr<ChannelList> c = channels.reader();
1699         if (Config->get_monitoring_model() == HardwareMonitoring) {
1700                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1701                         (*chan)->source.request_jack_monitors_input (false);
1702                 }
1703         }
1704         capturing_sources.clear ();
1705         RecordEnableChanged (); /* EMIT SIGNAL */
1706 }
1707
1708 XMLNode&
1709 AudioDiskstream::get_state ()
1710 {
1711         XMLNode& node (Diskstream::get_state());
1712         char buf[64] = "";
1713         LocaleGuard lg (X_("POSIX"));
1714
1715         boost::shared_ptr<ChannelList> c = channels.reader();
1716         snprintf (buf, sizeof(buf), "%zd", c->size());
1717         node.add_property ("channels", buf);
1718
1719         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1720
1721                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1722                 XMLNode* cs_grandchild;
1723
1724                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1725                         cs_grandchild = new XMLNode (X_("file"));
1726                         cs_grandchild->add_property (X_("path"), (*i)->path());
1727                         cs_child->add_child_nocopy (*cs_grandchild);
1728                 }
1729
1730                 /* store the location where capture will start */
1731
1732                 Location* pi;
1733
1734                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1735                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1736                 } else {
1737                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1738                 }
1739
1740                 cs_child->add_property (X_("at"), buf);
1741                 node.add_child_nocopy (*cs_child);
1742         }
1743
1744         return node;
1745 }
1746
1747 int
1748 AudioDiskstream::set_state (const XMLNode& node, int version)
1749 {
1750         const XMLProperty* prop;
1751         XMLNodeList nlist = node.children();
1752         XMLNodeIterator niter;
1753         uint32_t nchans = 1;
1754         XMLNode* capture_pending_node = 0;
1755         LocaleGuard lg (X_("POSIX"));
1756
1757         /* prevent write sources from being created */
1758
1759         in_set_state = true;
1760
1761         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1762                 if ((*niter)->name() == IO::state_node_name) {
1763                         deprecated_io_node = new XMLNode (**niter);
1764                 }
1765
1766                 if ((*niter)->name() == X_("CapturingSources")) {
1767                         capture_pending_node = *niter;
1768                 }
1769         }
1770
1771         if (Diskstream::set_state (node, version)) {
1772                 return -1;
1773         }
1774
1775         if ((prop = node.property ("channels")) != 0) {
1776                 nchans = atoi (prop->value().c_str());
1777         }
1778
1779         // create necessary extra channels
1780         // we are always constructed with one and we always need one
1781
1782         _n_channels.set(DataType::AUDIO, channels.reader()->size());
1783
1784         if (nchans > _n_channels.n_audio()) {
1785
1786                 add_channel (nchans - _n_channels.n_audio());
1787                 IO::PortCountChanged(_n_channels);
1788
1789         } else if (nchans < _n_channels.n_audio()) {
1790
1791                 remove_channel (_n_channels.n_audio() - nchans);
1792         }
1793
1794
1795
1796         if (!destructive() && capture_pending_node) {
1797                 /* destructive streams have one and only one source per channel,
1798                    and so they never end up in pending capture in any useful
1799                    sense.
1800                 */
1801                 use_pending_capture_data (*capture_pending_node);
1802         }
1803
1804         in_set_state = false;
1805
1806         /* make sure this is clear before we do anything else */
1807
1808         capturing_sources.clear ();
1809
1810         /* write sources are handled when we handle the input set
1811            up of the IO that owns this DS (::non_realtime_input_change())
1812         */
1813
1814         return 0;
1815 }
1816
1817 int
1818 AudioDiskstream::use_new_write_source (uint32_t n)
1819 {
1820         boost::shared_ptr<ChannelList> c = channels.reader();
1821
1822         if (!recordable()) {
1823                 return 1;
1824         }
1825
1826         if (n >= c->size()) {
1827                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1828                 return -1;
1829         }
1830
1831         ChannelInfo* chan = (*c)[n];
1832
1833         try {
1834                 if ((chan->write_source = _session.create_audio_source_for_session (
1835                              n_channels().n_audio(), name(), n, destructive())) == 0) {
1836                         throw failed_constructor();
1837                 }
1838         }
1839
1840         catch (failed_constructor &err) {
1841                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1842                 chan->write_source.reset ();
1843                 return -1;
1844         }
1845
1846         /* do not remove destructive files even if they are empty */
1847
1848         chan->write_source->set_allow_remove_if_empty (!destructive());
1849
1850         return 0;
1851 }
1852
1853 list<boost::shared_ptr<Source> >
1854 AudioDiskstream::steal_write_sources()
1855 {
1856         /* not possible to steal audio write sources */
1857         list<boost::shared_ptr<Source> > ret;
1858         return ret;
1859 }
1860
1861 void
1862 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1863 {
1864         ChannelList::iterator chan;
1865         boost::shared_ptr<ChannelList> c = channels.reader();
1866         uint32_t n;
1867
1868         if (!_session.writable() || !recordable()) {
1869                 return;
1870         }
1871
1872         capturing_sources.clear ();
1873
1874         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1875
1876                 if (!destructive()) {
1877
1878                         if ((*chan)->write_source) {
1879
1880                                 if (mark_write_complete) {
1881                                         (*chan)->write_source->mark_streaming_write_completed ();
1882                                         (*chan)->write_source->done_with_peakfile_writes ();
1883                                 }
1884
1885                                 if ((*chan)->write_source->removable()) {
1886                                         (*chan)->write_source->mark_for_remove ();
1887                                         (*chan)->write_source->drop_references ();
1888                                 }
1889
1890                                 (*chan)->write_source.reset ();
1891                         }
1892
1893                         use_new_write_source (n);
1894
1895                         if (record_enabled()) {
1896                                 capturing_sources.push_back ((*chan)->write_source);
1897                         }
1898
1899                 } else {
1900
1901                         if ((*chan)->write_source == 0) {
1902                                 use_new_write_source (n);
1903                         }
1904                 }
1905         }
1906
1907         if (destructive() && !c->empty ()) {
1908
1909                 /* we now have all our write sources set up, so create the
1910                    playlist's single region.
1911                 */
1912
1913                 if (_playlist->empty()) {
1914                         setup_destructive_playlist ();
1915                 }
1916         }
1917 }
1918
1919 void
1920 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1921 {
1922         if (_session.get_block_size() > speed_buffer_size) {
1923                 speed_buffer_size = _session.get_block_size();
1924                 boost::shared_ptr<ChannelList> c = channels.reader();
1925
1926                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1927                         if ((*chan)->speed_buffer)
1928                                 delete [] (*chan)->speed_buffer;
1929                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
1930                 }
1931         }
1932         allocate_temporary_buffers ();
1933 }
1934
1935 void
1936 AudioDiskstream::allocate_temporary_buffers ()
1937 {
1938         /* make sure the wrap buffer is at least large enough to deal
1939            with the speeds up to 1.2, to allow for micro-variation
1940            when slaving to MTC, Timecode etc.
1941         */
1942
1943         double const sp = max (fabsf (_actual_speed), 1.2f);
1944         framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1945
1946         if (required_wrap_size > wrap_buffer_size) {
1947
1948                 boost::shared_ptr<ChannelList> c = channels.reader();
1949
1950                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1951                         if ((*chan)->playback_wrap_buffer) {
1952                                 delete [] (*chan)->playback_wrap_buffer;
1953                         }
1954                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1955                         if ((*chan)->capture_wrap_buffer) {
1956                                 delete [] (*chan)->capture_wrap_buffer;
1957                         }
1958                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1959                 }
1960
1961                 wrap_buffer_size = required_wrap_size;
1962         }
1963 }
1964
1965 void
1966 AudioDiskstream::request_jack_monitors_input (bool yn)
1967 {
1968         boost::shared_ptr<ChannelList> c = channels.reader();
1969
1970         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1971                 (*chan)->source.request_jack_monitors_input (yn);
1972         }
1973 }
1974
1975 void
1976 AudioDiskstream::set_align_style_from_io ()
1977 {
1978         bool have_physical = false;
1979
1980         if (_alignment_choice != Automatic) {
1981                 return;
1982         }
1983
1984         if (_io == 0) {
1985                 return;
1986         }
1987
1988         get_input_sources ();
1989
1990         boost::shared_ptr<ChannelList> c = channels.reader();
1991
1992         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1993                 if ((*chan)->source.is_physical ()) {
1994                         have_physical = true;
1995                         break;
1996                 }
1997         }
1998
1999         if (have_physical) {
2000                 set_align_style (ExistingMaterial);
2001         } else {
2002                 set_align_style (CaptureTime);
2003         }
2004 }
2005
2006 int
2007 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2008 {
2009         while (how_many--) {
2010                 c->push_back (new ChannelInfo(
2011                                       _session.butler()->audio_diskstream_playback_buffer_size(),
2012                                       _session.butler()->audio_diskstream_capture_buffer_size(),
2013                                       speed_buffer_size, wrap_buffer_size));
2014                 interpolation.add_channel_to (
2015                         _session.butler()->audio_diskstream_playback_buffer_size(),
2016                         speed_buffer_size);
2017         }
2018
2019         _n_channels.set(DataType::AUDIO, c->size());
2020
2021         return 0;
2022 }
2023
2024 int
2025 AudioDiskstream::add_channel (uint32_t how_many)
2026 {
2027         RCUWriter<ChannelList> writer (channels);
2028         boost::shared_ptr<ChannelList> c = writer.get_copy();
2029
2030         return add_channel_to (c, how_many);
2031 }
2032
2033 int
2034 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2035 {
2036         while (how_many-- && !c->empty()) {
2037                 delete c->back();
2038                 c->pop_back();
2039                 interpolation.remove_channel_from ();
2040         }
2041
2042         _n_channels.set(DataType::AUDIO, c->size());
2043
2044         return 0;
2045 }
2046
2047 int
2048 AudioDiskstream::remove_channel (uint32_t how_many)
2049 {
2050         RCUWriter<ChannelList> writer (channels);
2051         boost::shared_ptr<ChannelList> c = writer.get_copy();
2052
2053         return remove_channel_from (c, how_many);
2054 }
2055
2056 float
2057 AudioDiskstream::playback_buffer_load () const
2058 {
2059         boost::shared_ptr<ChannelList> c = channels.reader();
2060
2061         if (c->empty ()) {
2062                 return 0;
2063         }
2064
2065         return (float) ((double) c->front()->playback_buf->read_space()/
2066                         (double) c->front()->playback_buf->bufsize());
2067 }
2068
2069 float
2070 AudioDiskstream::capture_buffer_load () const
2071 {
2072         boost::shared_ptr<ChannelList> c = channels.reader();
2073
2074         if (c->empty ()) {
2075                 return 0;
2076         }
2077
2078         return (float) ((double) c->front()->capture_buf->write_space()/
2079                         (double) c->front()->capture_buf->bufsize());
2080 }
2081
2082 int
2083 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2084 {
2085         const XMLProperty* prop;
2086         XMLNodeList nlist = node.children();
2087         XMLNodeIterator niter;
2088         boost::shared_ptr<AudioFileSource> fs;
2089         boost::shared_ptr<AudioFileSource> first_fs;
2090         SourceList pending_sources;
2091         framepos_t position;
2092
2093         if ((prop = node.property (X_("at"))) == 0) {
2094                 return -1;
2095         }
2096
2097         if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2098                 return -1;
2099         }
2100
2101         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2102                 if ((*niter)->name() == X_("file")) {
2103
2104                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2105                                 continue;
2106                         }
2107
2108                         // This protects sessions from errant CapturingSources in stored sessions
2109                         struct stat sbuf;
2110                         if (stat (prop->value().c_str(), &sbuf)) {
2111                                 continue;
2112                         }
2113
2114                         try {
2115                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2116                                         SourceFactory::createWritable (
2117                                                 DataType::AUDIO, _session,
2118                                                 prop->value(), string(), false, _session.frame_rate()));
2119                         }
2120
2121                         catch (failed_constructor& err) {
2122                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2123                                                   _name, prop->value())
2124                                       << endmsg;
2125                                 return -1;
2126                         }
2127
2128                         pending_sources.push_back (fs);
2129
2130                         if (first_fs == 0) {
2131                                 first_fs = fs;
2132                         }
2133
2134                         fs->set_captured_for (_name.val());
2135                 }
2136         }
2137
2138         if (pending_sources.size() == 0) {
2139                 /* nothing can be done */
2140                 return 1;
2141         }
2142
2143         if (pending_sources.size() != _n_channels.n_audio()) {
2144                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2145                       << endmsg;
2146                 return -1;
2147         }
2148
2149         boost::shared_ptr<AudioRegion> region;
2150
2151         try {
2152
2153                 PropertyList plist;
2154
2155                 plist.add (Properties::start, 0);
2156                 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2157                 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2158
2159                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2160
2161                 region->set_automatic (true);
2162                 region->set_whole_file (true);
2163                 region->special_set_position (0);
2164         }
2165
2166         catch (failed_constructor& err) {
2167                 error << string_compose (
2168                                 _("%1: cannot create whole-file region from pending capture sources"),
2169                                 _name) << endmsg;
2170
2171                 return -1;
2172         }
2173
2174         _playlist->add_region (region, position);
2175
2176         return 0;
2177 }
2178
2179 int
2180 AudioDiskstream::set_non_layered (bool yn)
2181 {
2182         if (yn != non_layered()) {
2183
2184                 if (yn) {
2185                         _flags = Flag (_flags | NonLayered);
2186                 } else {
2187                         _flags = Flag (_flags & ~NonLayered);
2188                 }
2189         }
2190
2191         return 0;
2192 }
2193
2194 int
2195 AudioDiskstream::set_destructive (bool yn)
2196 {
2197         if (yn != destructive()) {
2198
2199                 if (yn) {
2200                         bool bounce_ignored;
2201                         /* requestor should already have checked this and
2202                            bounced if necessary and desired
2203                         */
2204                         if (!can_become_destructive (bounce_ignored)) {
2205                                 return -1;
2206                         }
2207                         _flags = Flag (_flags | Destructive);
2208                         use_destructive_playlist ();
2209                 } else {
2210                         _flags = Flag (_flags & ~Destructive);
2211                         reset_write_sources (true, true);
2212                 }
2213         }
2214
2215         return 0;
2216 }
2217
2218 bool
2219 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2220 {
2221         if (!_playlist) {
2222                 requires_bounce = false;
2223                 return false;
2224         }
2225
2226         /* is there only one region ? */
2227
2228         if (_playlist->n_regions() != 1) {
2229                 requires_bounce = true;
2230                 return false;
2231         }
2232
2233         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2234         if (!first) {
2235                 requires_bounce = false;
2236                 return true;
2237         }
2238
2239         /* do the source(s) for the region cover the session start position ? */
2240
2241         if (first->position() != _session.current_start_frame()) {
2242                 if (first->start() > _session.current_start_frame()) {
2243                         requires_bounce = true;
2244                         return false;
2245                 }
2246         }
2247
2248         /* is the source used by only 1 playlist ? */
2249
2250         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2251
2252         assert (afirst);
2253
2254         if (_session.playlists->source_use_count (afirst->source()) > 1) {
2255                 requires_bounce = true;
2256                 return false;
2257         }
2258
2259         requires_bounce = false;
2260         return true;
2261 }
2262
2263 void
2264 AudioDiskstream::adjust_playback_buffering ()
2265 {
2266         boost::shared_ptr<ChannelList> c = channels.reader();
2267
2268         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2269                 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2270         }
2271 }
2272
2273 void
2274 AudioDiskstream::adjust_capture_buffering ()
2275 {
2276         boost::shared_ptr<ChannelList> c = channels.reader();
2277
2278         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2279                 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2280         }
2281 }
2282
2283 bool
2284 AudioDiskstream::ChannelSource::is_physical () const
2285 {
2286         if (name.empty()) {
2287                 return false;
2288         }
2289
2290         return AudioEngine::instance()->port_is_physical (name);
2291 }
2292
2293 void
2294 AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const
2295 {
2296         if (name.empty()) {
2297                 return;
2298         }
2299
2300         return AudioEngine::instance()->request_jack_monitors_input (name, yn);
2301 }
2302
2303 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2304 {
2305         current_capture_buffer = 0;
2306         current_playback_buffer = 0;
2307         curr_capture_cnt = 0;
2308
2309         speed_buffer = new Sample[speed_size];
2310         playback_wrap_buffer = new Sample[wrap_size];
2311         capture_wrap_buffer = new Sample[wrap_size];
2312
2313         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2314         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2315         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2316
2317         /* touch the ringbuffer buffers, which will cause
2318            them to be mapped into locked physical RAM if
2319            we're running with mlockall(). this doesn't do
2320            much if we're not.
2321         */
2322
2323         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2324         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2325         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2326 }
2327
2328 void
2329 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2330 {
2331         delete playback_buf;
2332         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2333         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2334 }
2335
2336 void
2337 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2338 {
2339         delete capture_buf;
2340
2341         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2342         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2343 }
2344
2345 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2346 {
2347         write_source.reset ();
2348
2349         delete [] speed_buffer;
2350         speed_buffer = 0;
2351
2352         delete [] playback_wrap_buffer;
2353         playback_wrap_buffer = 0;
2354
2355         delete [] capture_wrap_buffer;
2356         capture_wrap_buffer = 0;
2357
2358         delete playback_buf;
2359         playback_buf = 0;
2360
2361         delete capture_buf;
2362         capture_buf = 0;
2363
2364         delete capture_transition_buf;
2365         capture_transition_buf = 0;
2366 }
2367
2368
2369 bool
2370 AudioDiskstream::set_name (string const & name)
2371 {
2372         Diskstream::set_name (name);
2373
2374         /* get a new write source so that its name reflects the new diskstream name */
2375
2376         boost::shared_ptr<ChannelList> c = channels.reader();
2377         ChannelList::iterator i;
2378         int n = 0;
2379
2380         for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2381                 use_new_write_source (n);
2382         }
2383
2384         return true;
2385 }