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