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