libs/ardour/audio_diskstream.cc

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