libs/ardour/disk_reader.cc

   1 /*
   2  * Copyright (C) 2017-2018 Paul Davis <paul@linuxaudiosystems.com>
   3  * Copyright (C) 2017-2019 Robin Gareus <robin@gareus.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <boost/smart_ptr/scoped_array.hpp>
  21
  22 #include "pbd/enumwriter.h"
  23 #include "pbd/memento_command.h"
  24 #include "pbd/playback_buffer.h"
  25
  26 #include "ardour/amp.h"
  27 #include "ardour/audioengine.h"
  28 #include "ardour/audioplaylist.h"
  29 #include "ardour/audio_buffer.h"
  30 #include "ardour/butler.h"
  31 #include "ardour/debug.h"
  32 #include "ardour/disk_reader.h"
  33 #include "ardour/midi_ring_buffer.h"
  34 #include "ardour/midi_playlist.h"
  35 #include "ardour/midi_track.h"
  36 #include "ardour/pannable.h"
  37 #include "ardour/playlist.h"
  38 #include "ardour/playlist_factory.h"
  39 #include "ardour/session.h"
  40 #include "ardour/session_playlists.h"
  41
  42 #include "pbd/i18n.h"
  43
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46 using namespace std;
  47
  48 ARDOUR::samplecnt_t DiskReader::_chunk_samples = default_chunk_samples ();
  49 PBD::Signal0<void> DiskReader::Underrun;
  50 Sample* DiskReader::_sum_buffer = 0;
  51 Sample* DiskReader::_mixdown_buffer = 0;
  52 gain_t* DiskReader::_gain_buffer = 0;
  53 samplecnt_t DiskReader::midi_readahead = 4096;
  54 gint DiskReader::_no_disk_output (0);
  55
  56 DiskReader::DiskReader (Session& s, string const & str, DiskIOProcessor::Flag f)
  57         : DiskIOProcessor (s, str, f)
  58         , overwrite_sample (0)
  59         , overwrite_queued (false)
  60         , run_must_resolve (false)
  61         , _declick_amp (s.nominal_sample_rate ())
  62         , _declick_offs (0)
  63 {
  64         file_sample[DataType::AUDIO] = 0;
  65         file_sample[DataType::MIDI] = 0;
  66         g_atomic_int_set (&_pending_overwrite, 0);
  67 }
  68
  69 DiskReader::~DiskReader ()
  70 {
  71         DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskReader %1 @ %2 deleted\n", _name, this));
  72 }
  73
  74 void
  75 DiskReader::ReaderChannelInfo::resize (samplecnt_t bufsize)
  76 {
  77         delete rbuf;
  78         rbuf = new PlaybackBuffer<Sample> (bufsize);
  79         /* touch memory to lock it */
  80         memset (rbuf->buffer(), 0, sizeof (Sample) * rbuf->bufsize());
  81 }
  82
  83 int
  84 DiskReader::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
  85 {
  86         while (how_many--) {
  87                 c->push_back (new ReaderChannelInfo (_session.butler()->audio_diskstream_playback_buffer_size()));
  88                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: new reader channel, write space = %2 read = %3\n",
  89                                                             name(),
  90                                                             c->back()->rbuf->write_space(),
  91                                                             c->back()->rbuf->read_space()));
  92         }
  93
  94         return 0;
  95 }
  96
  97 void
  98 DiskReader::allocate_working_buffers()
  99 {
 100         /* with varifill buffer refilling, we compute the read size in bytes (to optimize
 101            for disk i/o bandwidth) and then convert back into samples. These buffers
 102            need to reflect the maximum size we could use, which is 4MB reads, or 2M samples
 103            using 16 bit samples.
 104         */
 105         _sum_buffer           = new Sample[2*1048576];
 106         _mixdown_buffer       = new Sample[2*1048576];
 107         _gain_buffer          = new gain_t[2*1048576];
 108 }
 109
 110 void
 111 DiskReader::free_working_buffers()
 112 {
 113         delete [] _sum_buffer;
 114         delete [] _mixdown_buffer;
 115         delete [] _gain_buffer;
 116         _sum_buffer     = 0;
 117         _mixdown_buffer = 0;
 118         _gain_buffer    = 0;
 119 }
 120
 121 samplecnt_t
 122 DiskReader::default_chunk_samples()
 123 {
 124         return 65536;
 125 }
 126
 127 bool
 128 DiskReader::set_name (string const & str)
 129 {
 130         string my_name = X_("player:");
 131         my_name += str;
 132
 133         if (_name != my_name) {
 134                 SessionObject::set_name (my_name);
 135         }
 136
 137         return true;
 138 }
 139
 140 XMLNode&
 141 DiskReader::state ()
 142 {
 143         XMLNode& node (DiskIOProcessor::state ());
 144         node.set_property(X_("type"), X_("diskreader"));
 145         return node;
 146 }
 147
 148 int
 149 DiskReader::set_state (const XMLNode& node, int version)
 150 {
 151         if (DiskIOProcessor::set_state (node, version)) {
 152                 return -1;
 153         }
 154
 155         return 0;
 156 }
 157
 158 void
 159 DiskReader::realtime_handle_transport_stopped ()
 160 {
 161         /* can't do the resolve here because we don't have a place to put the
 162          * note resolving data. Defer to
 163          * MidiTrack::realtime_handle_transport_stopped() which will call
 164          * ::resolve_tracker() and put the output in its _immediate_events store.
 165          */
 166 }
 167
 168 void
 169 DiskReader::realtime_locate ()
 170 {
 171 }
 172
 173 float
 174 DiskReader::buffer_load () const
 175 {
 176         /* Note: for MIDI it's not trivial to differentiate the following two cases:
 177
 178            1.  The playback buffer is empty because the system has run out of time to fill it.
 179            2.  The playback buffer is empty because there is no more data on the playlist.
 180
 181            If we use a simple buffer load computation, we will report that the MIDI diskstream
 182            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
 183            are so low compared to audio, just use the audio value here.
 184         */
 185
 186         boost::shared_ptr<ChannelList> c = channels.reader();
 187
 188         if (c->empty ()) {
 189                 /* no channels, so no buffers, so completely full and ready to playback, sir! */
 190                 return 1.0;
 191         }
 192
 193         PBD::PlaybackBuffer<Sample>* b = c->front()->rbuf;
 194         return (float) ((double) b->read_space() / (double) b->bufsize());
 195 }
 196
 197 void
 198 DiskReader::adjust_buffering ()
 199 {
 200         boost::shared_ptr<ChannelList> c = channels.reader();
 201
 202         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 203                 (*chan)->resize (_session.butler()->audio_diskstream_playback_buffer_size());
 204         }
 205 }
 206
 207 void
 208 DiskReader::playlist_modified ()
 209 {
 210         if (!overwrite_queued) {
 211                 _session.request_overwrite_buffer (_track);
 212                 overwrite_queued = true;
 213         }
 214 }
 215
 216 int
 217 DiskReader::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist)
 218 {
 219         bool prior_playlist = false;
 220
 221         if (_playlists[dt]) {
 222                 prior_playlist = true;
 223         }
 224
 225         if (DiskIOProcessor::use_playlist (dt, playlist)) {
 226                 return -1;
 227         }
 228
 229         /* don't do this if we've already asked for it *or* if we are setting up
 230            the diskstream for the very first time - the input changed handling will
 231            take care of the buffer refill.
 232         */
 233
 234         cerr << "DR " << _track->name() << " using playlist, loading ? " << _session.loading() << endl;
 235
 236         if (!overwrite_queued && (prior_playlist || _session.loading())) {
 237                 _session.request_overwrite_buffer (_track);
 238                 overwrite_queued = true;
 239         }
 240
 241         return 0;
 242 }
 243
 244 void
 245 DiskReader::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
 246                  double speed, pframes_t nframes, bool result_required)
 247 {
 248         uint32_t n;
 249         boost::shared_ptr<ChannelList> c = channels.reader();
 250         ChannelList::iterator chan;
 251         sampleoffset_t disk_samples_to_consume;
 252         MonitorState ms = _track->monitoring_state ();
 253
 254         if (run_must_resolve) {
 255                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (_track);
 256                 if (mt) {
 257                         resolve_tracker (mt->immediate_events(), start_sample);
 258                 }
 259                 run_must_resolve = false;
 260         }
 261
 262         if (_active) {
 263                 if (!_pending_active) {
 264                         _active = false;
 265                         return;
 266                 }
 267         } else {
 268                 if (_pending_active) {
 269                         _active = true;
 270                 } else {
 271                         return;
 272                 }
 273         }
 274
 275         const bool declick_out = _session.declick_in_progress();
 276         const gain_t target_gain = (declick_out || (speed == 0.0) || ((ms & MonitoringDisk) == 0)) ? 0.0 : 1.0;
 277
 278         if (!_session.cfg ()->get_use_transport_fades ()) {
 279                 _declick_amp.set_gain (target_gain);
 280         }
 281
 282         if (declick_out && (ms == MonitoringDisk) && _declick_amp.gain () == target_gain) {
 283                 /* no channels, or stopped. Don't accidentally pass any data
 284                  * from disk into our outputs (e.g. via interpolation)
 285                  */
 286                 return;
 287         }
 288
 289         BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
 290         const bool still_locating = _session.global_locate_pending() || pending_overwrite ();
 291
 292         assert (speed == -1 || speed == 0 || speed == 1);
 293
 294         if (speed == 0) {
 295                 disk_samples_to_consume = 0;
 296         } else {
 297                 disk_samples_to_consume = nframes;
 298         }
 299
 300         if (c->empty()) {
 301                 /* do nothing with audio */
 302                 goto midi;
 303         }
 304
 305         if (_declick_amp.gain () != target_gain && target_gain == 0) {
 306                 /* fade-out */
 307 #if 0
 308                 printf ("DR fade-out speed=%.1f gain=%.3f off=%ld start=%ld playpos=%ld (%s)\n",
 309                                 speed, _declick_amp.gain (), _declick_offs, start_sample, playback_sample, owner()->name().c_str());
 310 #endif
 311                 ms = MonitorState (ms | MonitoringDisk);
 312                 assert (result_required);
 313                 result_required = true;
 314         } else {
 315                 _declick_offs = 0;
 316         }
 317
 318         if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating || _no_disk_output) {
 319
 320                 /* no need for actual disk data, just advance read pointer and return */
 321
 322                 if (!still_locating || _no_disk_output) {
 323                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 324                                 (*chan)->rbuf->increment_read_ptr (disk_samples_to_consume);
 325                         }
 326                 }
 327
 328                 /* if monitoring disk but locating put silence in the buffers */
 329
 330                 if ((_no_disk_output || still_locating) && (ms == MonitoringDisk)) {
 331                         bufs.silence (nframes, 0);
 332                 }
 333
 334         } else {
 335
 336                 /* we need audio data from disk */
 337
 338                 size_t n_buffers = bufs.count().n_audio();
 339                 size_t n_chans = c->size();
 340                 gain_t scaling;
 341
 342                 if (n_chans > n_buffers) {
 343                         scaling = ((float) n_buffers) / n_chans;
 344                 } else {
 345                         scaling = 1.0;
 346                 }
 347
 348                 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 349
 350                         ChannelInfo* chaninfo (*chan);
 351                         AudioBuffer& output (bufs.get_audio (n % n_buffers));
 352
 353                         AudioBuffer& disk_buf ((ms & MonitoringInput) ? scratch_bufs.get_audio(n) : output);
 354
 355                         if (start_sample != playback_sample && target_gain != 0) {
 356                                 if (can_internal_playback_seek (start_sample - playback_sample)) {
 357                                         internal_playback_seek (start_sample - playback_sample);
 358                                 } else {
 359                                         disk_samples_to_consume = 0; /* will force an underrun below */
 360                                 }
 361                         }
 362
 363                         if (!declick_out) {
 364                                 const samplecnt_t total = chaninfo->rbuf->read (disk_buf.data(), disk_samples_to_consume);
 365                                 if (disk_samples_to_consume > total) {
 366                                         cerr << _name << " Need " << total << " have only " << disk_samples_to_consume << endl;
 367                                         cerr << "underrun for " << _name << endl;
 368                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
 369                                                                                     DEBUG_THREAD_SELF, name(), total));
 370                                         Underrun ();
 371                                         return;
 372                                 }
 373                         } else if (_declick_amp.gain () != target_gain) {
 374                                 assert (target_gain == 0);
 375                                 const samplecnt_t total = chaninfo->rbuf->read (disk_buf.data(), nframes, false, _declick_offs);
 376                                 _declick_offs += total;
 377                         }
 378
 379                         _declick_amp.apply_gain (disk_buf, nframes, target_gain);
 380
 381                         Amp::apply_simple_gain (disk_buf, nframes, scaling);
 382
 383                         if (ms & MonitoringInput) {
 384                                 /* mix the disk signal into the input signal (already in bufs) */
 385                                 mix_buffers_no_gain (output.data(), disk_buf.data(), nframes);
 386                         }
 387                 }
 388         }
 389
 390         /* MIDI data handling */
 391
 392   midi:
 393         if (!declick_in_progress() && bufs.count().n_midi()) {
 394                 MidiBuffer* dst;
 395
 396                 if (_no_disk_output) {
 397                         dst = &scratch_bufs.get_midi(0);
 398                 } else {
 399                         dst = &bufs.get_midi (0);
 400                 }
 401
 402                 if ((ms & MonitoringDisk) && !still_locating && speed) {
 403                         get_midi_playback (*dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume);
 404                 }
 405         }
 406
 407         if (!still_locating) {
 408
 409                 bool butler_required = false;
 410
 411                 if (speed < 0.0) {
 412                         playback_sample -= disk_samples_to_consume;
 413                 } else {
 414                         playback_sample += disk_samples_to_consume;
 415                 }
 416
 417                 Location* loc = _loop_location;
 418                 if (loc) {
 419                         Evoral::Range<samplepos_t> loop_range (loc->start(), loc->end() - 1);
 420                         playback_sample = loop_range.squish (playback_sample);
 421                 }
 422
 423                 if (_playlists[DataType::AUDIO]) {
 424                         if (!c->empty()) {
 425                                 if (_slaved) {
 426                                         if (c->front()->rbuf->write_space() >= c->front()->rbuf->bufsize() / 2) {
 427                                                 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->rbuf->write_space(), c->front()->rbuf->bufsize()));
 428                                                 butler_required = true;
 429                                         }
 430                                 } else {
 431                                         if ((samplecnt_t) c->front()->rbuf->write_space() >= _chunk_samples) {
 432                                                 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->rbuf->write_space(),
 433                                                                                             _chunk_samples));
 434                                                 butler_required = true;
 435                                         }
 436                                 }
 437                         }
 438                 }
 439
 440                 /* All of MIDI is in RAM, no need to call the butler unless we
 441                  * have to overwrite buffers because of a playlist change.
 442                  */
 443
 444                 _need_butler = butler_required;
 445         }
 446
 447         // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
 448 }
 449
 450 bool
 451 DiskReader::declick_in_progress () const
 452 {
 453         return _declick_amp.gain() != 0; // declick-out
 454 }
 455
 456 bool
 457 DiskReader::pending_overwrite () const {
 458         return g_atomic_int_get (&_pending_overwrite) != 0;
 459 }
 460
 461 void
 462 DiskReader::set_pending_overwrite ()
 463 {
 464         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 465
 466         assert (!pending_overwrite ());
 467         overwrite_sample = playback_sample;
 468
 469         boost::shared_ptr<ChannelList> c = channels.reader ();
 470         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 471                 (*chan)->rbuf->read_flush ();
 472         }
 473
 474         g_atomic_int_set (&_pending_overwrite, 1);
 475         run_must_resolve = true;
 476 }
 477
 478 bool
 479 DiskReader::overwrite_existing_buffers ()
 480 {
 481         /* called from butler thread */
 482         assert (pending_overwrite ());
 483         overwrite_queued = false;
 484
 485         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_sample));
 486
 487         boost::shared_ptr<ChannelList> c = channels.reader();
 488         if (!c->empty ()) {
 489                 /* AUDIO */
 490
 491                 const bool reversed = _session.transport_speed() < 0.0f;
 492
 493                 /* assume all are the same size */
 494                 samplecnt_t size = c->front()->rbuf->write_space ();
 495                 assert (size > 0);
 496
 497                 boost::scoped_array<Sample> sum_buffer (new Sample[size]);
 498                 boost::scoped_array<Sample> mixdown_buffer (new Sample[size]);
 499                 boost::scoped_array<float> gain_buffer (new float[size]);
 500
 501                 /* reduce size so that we can fill the buffer correctly (ringbuffers
 502                  * can only handle size-1, otherwise they appear to be empty)
 503                  */
 504                 size--;
 505
 506                 uint32_t n=0;
 507
 508                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 509
 510                         samplepos_t start = overwrite_sample;
 511                         samplecnt_t to_read = size;
 512
 513                         if (audio_read ((*chan)->rbuf, sum_buffer.get(), mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
 514                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"), id(), size, overwrite_sample) << endmsg;
 515                                 goto midi;
 516                         }
 517                 }
 518         }
 519
 520   midi:
 521
 522         RTMidiBuffer* mbuf = rt_midibuffer ();
 523
 524         if (mbuf) {
 525                 PBD::Timing minsert;
 526                 minsert.start();
 527                 midi_playlist()->render (0);
 528                 minsert.update();
 529                 assert (midi_playlist()->rendered());
 530                 // cerr << "Reading " << name()  << " took " << minsert.elapsed() << " microseconds, final size = " << midi_playlist()->rendered()->size() << endl;
 531         }
 532
 533         g_atomic_int_set (&_pending_overwrite, 0);
 534
 535         return true;
 536 }
 537
 538 int
 539 DiskReader::seek (samplepos_t sample, bool complete_refill)
 540 {
 541         /* called via non_realtime_locate() from butler thread */
 542
 543         uint32_t n;
 544         int ret = -1;
 545         ChannelList::iterator chan;
 546         boost::shared_ptr<ChannelList> c = channels.reader();
 547
 548 #ifndef NDEBUG
 549         if (_declick_amp.gain() != 0) {
 550                 /* this should not happen. new transport should postponse seeking
 551                  * until de-click is complete */
 552                 printf ("LOCATE WITHOUT DECLICK (gain=%f) at %ld seek-to %ld\n", _declick_amp.gain (), playback_sample, sample);
 553                 //return -1;
 554         }
 555         if (sample == playback_sample && !complete_refill) {
 556                 return 0; // XXX double-check this
 557         }
 558 #endif
 559
 560         g_atomic_int_set (&_pending_overwrite, 0);
 561
 562         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("DiskReader::seek %s %ld -> %ld refill=%d\n", owner()->name().c_str(), playback_sample, sample, complete_refill));
 563
 564         const samplecnt_t distance = sample - playback_sample;
 565         if (!complete_refill && can_internal_playback_seek (distance)) {
 566                 internal_playback_seek (distance);
 567                 return 0;
 568         }
 569
 570         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 571                 (*chan)->rbuf->reset ();
 572         }
 573
 574         playback_sample = sample;
 575         file_sample[DataType::AUDIO] = sample;
 576         file_sample[DataType::MIDI] = sample;
 577
 578         if (complete_refill) {
 579                 /* call _do_refill() to refill the entire buffer, using
 580                    the largest reads possible.
 581                 */
 582                 while ((ret = do_refill_with_alloc (false)) > 0) ;
 583         } else {
 584                 /* call _do_refill() to refill just one chunk, and then
 585                    return.
 586                 */
 587                 ret = do_refill_with_alloc (true);
 588         }
 589
 590         return ret;
 591 }
 592
 593 bool
 594 DiskReader::can_internal_playback_seek (sampleoffset_t distance)
 595 {
 596         /* 1. Audio */
 597
 598         ChannelList::iterator chan;
 599         boost::shared_ptr<ChannelList> c = channels.reader();
 600
 601         for (chan = c->begin(); chan != c->end(); ++chan) {
 602                 if (!(*chan)->rbuf->can_seek (distance)) {
 603                         return false;
 604                 }
 605         }
 606
 607         /* 2. MIDI can always seek any distance */
 608
 609         return true;
 610 }
 611
 612 void
 613 DiskReader::internal_playback_seek (sampleoffset_t distance)
 614 {
 615         if (distance == 0) {
 616                 return;
 617         }
 618
 619         sampleoffset_t off = distance;
 620
 621         ChannelList::iterator chan;
 622         boost::shared_ptr<ChannelList> c = channels.reader();
 623         for (chan = c->begin(); chan != c->end(); ++chan) {
 624                 if (distance < 0) {
 625                         off = 0 - (sampleoffset_t) (*chan)->rbuf->decrement_read_ptr (::llabs (distance));
 626                 } else {
 627                         off = (*chan)->rbuf->increment_read_ptr (distance);
 628                 }
 629         }
 630
 631         playback_sample += off;
 632 }
 633
 634 static
 635 void swap_by_ptr (Sample *first, Sample *last)
 636 {
 637         while (first < last) {
 638                 Sample tmp = *first;
 639                 *first++ = *last;
 640                 *last-- = tmp;
 641         }
 642 }
 643
 644 /** Read some data for 1 channel from our playlist into a buffer.
 645  *  @param buf Buffer to write to.
 646  *  @param start Session sample to start reading from; updated to where we end up
 647  *         after the read.
 648  *  @param cnt Count of samples to read.
 649  *  @param reversed true if we are running backwards, otherwise false.
 650  */
 651 int
 652 DiskReader::audio_read (PBD::PlaybackBuffer<Sample>*rb,
 653                         Sample* sum_buffer,
 654                         Sample* mixdown_buffer,
 655                         float* gain_buffer,
 656                         samplepos_t& start, samplecnt_t cnt,
 657                         int channel, bool reversed)
 658 {
 659         samplecnt_t this_read = 0;
 660         bool reloop = false;
 661         samplepos_t loop_end = 0;
 662         samplepos_t loop_start = 0;
 663         Location *loc = 0;
 664
 665         if (!_playlists[DataType::AUDIO]) {
 666                 rb->write_zero (cnt);
 667                 return 0;
 668         }
 669
 670         /* XXX we don't currently play loops in reverse. not sure why */
 671
 672         if (!reversed) {
 673
 674                 samplecnt_t loop_length = 0;
 675
 676                 /* Make the use of a Location atomic for this read operation.
 677
 678                    Note: Locations don't get deleted, so all we care about
 679                    when I say "atomic" is that we are always pointing to
 680                    the same one and using a start/length values obtained
 681                    just once.
 682                 */
 683
 684                 if ((loc = _loop_location) != 0) {
 685                         loop_start = loc->start();
 686                         loop_end = loc->end();
 687                         loop_length = loop_end - loop_start;
 688                 }
 689
 690                 /* if we are looping, ensure that the first sample we read is at the correct
 691                    position within the loop.
 692                 */
 693
 694                 if (loc && start >= loop_end) {
 695                         start = loop_start + ((start - loop_start) % loop_length);
 696                 }
 697
 698         }
 699
 700         if (reversed) {
 701                 start -= cnt;
 702         }
 703
 704         /* We need this while loop in case we hit a loop boundary, in which case our read from
 705            the playlist must be split into more than one section.
 706         */
 707
 708         while (cnt) {
 709
 710                 /* take any loop into account. we can't read past the end of the loop. */
 711
 712                 if (loc && (loop_end - start < cnt)) {
 713                         this_read = loop_end - start;
 714                         reloop = true;
 715                 } else {
 716                         reloop = false;
 717                         this_read = cnt;
 718                 }
 719
 720                 if (this_read == 0) {
 721                         break;
 722                 }
 723
 724                 this_read = min (cnt, this_read);
 725
 726                 if (audio_playlist()->read (sum_buffer, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 727                         error << string_compose(_("DiskReader %1: cannot read %2 from playlist at sample %3"), id(), this_read, start) << endmsg;
 728                         return -1;
 729                 }
 730
 731                 if (reversed) {
 732
 733                         swap_by_ptr (sum_buffer, sum_buffer + this_read - 1);
 734
 735                 } else {
 736
 737                         /* if we read to the end of the loop, go back to the beginning */
 738
 739                         if (reloop) {
 740                                 start = loop_start;
 741                         } else {
 742                                 start += this_read;
 743                         }
 744                 }
 745
 746                 if (rb->write (sum_buffer, this_read) != this_read) {
 747                         cerr << owner()->name() << " Ringbuffer Write overrun" << endl;
 748                 }
 749
 750                 cnt -= this_read;
 751         }
 752
 753         return 0;
 754 }
 755
 756 int
 757 DiskReader::_do_refill_with_alloc (bool partial_fill)
 758 {
 759         /* We limit disk reads to at most 4MB chunks, which with floating point
 760            samples would be 1M samples. But we might use 16 or 14 bit samples,
 761            in which case 4MB is more samples than that. Therefore size this for
 762            the smallest sample value .. 4MB = 2M samples (16 bit).
 763         */
 764
 765         {
 766                 boost::scoped_array<Sample> sum_buf (new Sample[2*1048576]);
 767                 boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
 768                 boost::scoped_array<float>  gain_buf (new float[2*1048576]);
 769
 770                 int ret = refill_audio (sum_buf.get(), mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0));
 771
 772                 if (ret) {
 773                         return ret;
 774                 }
 775         }
 776
 777         return refill_midi ();
 778 }
 779
 780 int
 781 DiskReader::refill (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
 782 {
 783         int ret = refill_audio (sum_buffer, mixdown_buffer, gain_buffer, fill_level);
 784
 785         if (ret) {
 786                 return ret;
 787         }
 788
 789         return refill_midi ();
 790 }
 791
 792
 793 /** Get some more data from disk and put it in our channels' bufs,
 794  *  if there is suitable space in them.
 795  *
 796  * If fill_level is non-zero, then we will refill the buffer so that there is
 797  * still at least fill_level samples of space left to be filled. This is used
 798  * after locates so that we do not need to wait to fill the entire buffer.
 799  *
 800  */
 801
 802 int
 803 DiskReader::refill_audio (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
 804 {
 805         /* do not read from disk while session is marked as Loading, to avoid
 806            useless redundant I/O.
 807         */
 808
 809         if (_session.loading()) {
 810                 return 0;
 811         }
 812
 813         int32_t ret = 0;
 814         bool const reversed = _session.transport_speed() < 0.0f;
 815         samplecnt_t zero_fill;
 816         uint32_t chan_n;
 817         ChannelList::iterator i;
 818         boost::shared_ptr<ChannelList> c = channels.reader();
 819
 820         if (c->empty()) {
 821                 return 0;
 822         }
 823
 824         assert(mixdown_buffer);
 825         assert(gain_buffer);
 826
 827         samplecnt_t total_space = c->front()->rbuf->write_space();
 828
 829         if (total_space == 0) {
 830                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
 831                 /* nowhere to write to */
 832                 return 0;
 833         }
 834
 835         if (fill_level) {
 836                 if (fill_level < total_space) {
 837                         total_space -= fill_level;
 838                 } else {
 839                         /* we can't do anything with it */
 840                         fill_level = 0;
 841                 }
 842         }
 843
 844         /* if we're running close to normal speed and there isn't enough
 845            space to do disk_read_chunk_samples of I/O, then don't bother.
 846
 847            at higher speeds, just do it because the sync between butler
 848            and audio thread may not be good enough.
 849
 850            Note: it is a design assumption that disk_read_chunk_samples is smaller
 851            than the playback buffer size, so this check should never trip when
 852            the playback buffer is empty.
 853         */
 854
 855         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: space to refill %2 vs. chunk %3 (speed = %4)\n", name(), total_space, _chunk_samples, _session.transport_speed()));
 856         if ((total_space < _chunk_samples) && fabs (_session.transport_speed()) < 2.0f) {
 857                 return 0;
 858         }
 859
 860         /* when slaved, don't try to get too close to the read pointer. this
 861            leaves space for the buffer reversal to have something useful to
 862            work with.
 863         */
 864
 865         if (_slaved && total_space < (samplecnt_t) (c->front()->rbuf->bufsize() / 2)) {
 866                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
 867                 return 0;
 868         }
 869
 870         samplepos_t ffa = file_sample[DataType::AUDIO];
 871
 872         if (reversed) {
 873
 874                 if (ffa == 0) {
 875                         /* at start: nothing to do but fill with silence */
 876                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 877                                 ChannelInfo* chan (*i);
 878                                 chan->rbuf->write_zero (chan->rbuf->write_space ());
 879                         }
 880                         return 0;
 881                 }
 882
 883                 if (ffa < total_space) {
 884                         /* too close to the start: read what we can, and then zero fill the rest */
 885                         zero_fill = total_space - ffa;
 886                         total_space = ffa;
 887                 } else {
 888                         zero_fill = 0;
 889                 }
 890
 891         } else {
 892
 893                 if (ffa == max_samplepos) {
 894                         /* at end: nothing to do but fill with silence */
 895                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 896                                 ChannelInfo* chan (*i);
 897                                 chan->rbuf->write_zero (chan->rbuf->write_space ());
 898                         }
 899                         return 0;
 900                 }
 901
 902                 if (ffa > max_samplepos - total_space) {
 903                         /* to close to the end: read what we can, and zero fill the rest */
 904                         zero_fill = total_space - (max_samplepos - ffa);
 905                         total_space = max_samplepos - ffa;
 906
 907                 } else {
 908                         zero_fill = 0;
 909                 }
 910         }
 911
 912         /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
 913         const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
 914         size_t total_bytes = total_space * bits_per_sample / 8;
 915
 916         /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer */
 917         size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
 918
 919         /* find nearest (lower) multiple of 16384 */
 920
 921         byte_size_for_read = (byte_size_for_read / 16384) * 16384;
 922
 923         /* now back to samples */
 924         samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
 925
 926         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
 927
 928         samplepos_t file_sample_tmp = ffa;
 929
 930         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 931                 ChannelInfo* chan (*i);
 932                 file_sample_tmp = ffa;
 933                 samplecnt_t ts = total_space;
 934
 935                 samplecnt_t to_read = min (ts, (samplecnt_t) chan->rbuf->write_space ());
 936                 to_read = min (to_read, samples_to_read);
 937                 assert (to_read >= 0);
 938
 939                 // cerr << owner()->name() << " to-read: " << to_read << endl;
 940
 941                 if (to_read) {
 942                         if (audio_read (chan->rbuf, sum_buffer, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
 943                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"), id(), to_read, ffa) << endmsg;
 944                                 ret = -1;
 945                                 goto out;
 946                         }
 947                 }
 948
 949                 if (zero_fill) {
 950                         /* not sure if action is needed,
 951                          * we'll later hit the "to close to the end" case
 952                          */
 953                         //chan->rbuf->write_zero (zero_fill);
 954                 }
 955         }
 956
 957         // elapsed = g_get_monotonic_time () - before;
 958         // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
 959
 960         file_sample[DataType::AUDIO] = file_sample_tmp;
 961         assert (file_sample[DataType::AUDIO] >= 0);
 962
 963         ret = ((total_space - samples_to_read) > _chunk_samples);
 964
 965   out:
 966         return ret;
 967 }
 968
 969 void
 970 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > const & movements_samples, bool from_undo_or_shift)
 971 {
 972         /* If we're coming from an undo, it will have handled
 973          * automation undo (it must, since automation-follows-regions
 974          * can lose automation data).  Hence we can do nothing here.
 975          *
 976          * Likewise when shifting regions (insert/remove time)
 977          * automation is taken care of separately (busses with
 978          * automation have no disk-reader).
 979          */
 980
 981         if (from_undo_or_shift) {
 982                 return;
 983         }
 984
 985         if (!_track || Config->get_automation_follows_regions () == false) {
 986                 return;
 987         }
 988
 989         list< Evoral::RangeMove<double> > movements;
 990
 991         for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
 992              i != movements_samples.end();
 993              ++i) {
 994
 995                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
 996         }
 997
 998         /* move panner automation */
 999         boost::shared_ptr<Pannable> pannable = _track->pannable();
1000         Evoral::ControlSet::Controls& c (pannable->controls());
1001
1002         for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1003                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1004                 if (!ac) {
1005                         continue;
1006                 }
1007                 boost::shared_ptr<AutomationList> alist = ac->alist();
1008                 if (!alist->size()) {
1009                         continue;
1010                 }
1011                 XMLNode & before = alist->get_state ();
1012                 bool const things_moved = alist->move_ranges (movements);
1013                 if (things_moved) {
1014                         _session.add_command (new MementoCommand<AutomationList> (
1015                                                       *alist.get(), &before, &alist->get_state ()));
1016                 }
1017         }
1018         /* move processor automation */
1019         _track->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples));
1020 }
1021
1022 void
1023 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
1024 {
1025         boost::shared_ptr<Processor> processor (p.lock ());
1026         if (!processor) {
1027                 return;
1028         }
1029
1030         list< Evoral::RangeMove<double> > movements;
1031         for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) {
1032                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1033         }
1034
1035         set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1036
1037         for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1038                 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1039                 if (!al->size()) {
1040                         continue;
1041                 }
1042                 XMLNode & before = al->get_state ();
1043                 bool const things_moved = al->move_ranges (movements);
1044                 if (things_moved) {
1045                         _session.add_command (
1046                                 new MementoCommand<AutomationList> (
1047                                         *al.get(), &before, &al->get_state ()
1048                                         )
1049                                 );
1050                 }
1051         }
1052 }
1053
1054 void
1055 DiskReader::reset_tracker ()
1056 {
1057         _tracker.reset ();
1058 }
1059
1060 void
1061 DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
1062 {
1063         _tracker.resolve_notes (buffer, time);
1064 }
1065
1066 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1067  *  so that an event at playback_sample has time = 0
1068  */
1069 void
1070 DiskReader::get_midi_playback (MidiBuffer& dst, samplepos_t start_sample, samplepos_t end_sample, MonitorState ms, BufferSet& scratch_bufs, double speed, samplecnt_t disk_samples_to_consume)
1071 {
1072         MidiBuffer* target;
1073         samplepos_t nframes = ::llabs (end_sample - start_sample);
1074
1075         RTMidiBuffer* rtmb = rt_midibuffer();
1076
1077         if (!rtmb || (rtmb->size() == 0)) {
1078                 /* no data to read, so do nothing */
1079                 return;
1080         }
1081
1082         if ((ms & MonitoringInput) == 0) {
1083                 /* Route::process_output_buffers() clears the buffer as-needed */
1084                 target = &dst;
1085         } else {
1086                 target = &scratch_bufs.get_midi (0);
1087         }
1088
1089         size_t events_read = 0;
1090
1091         if (!pending_overwrite() && (ms & MonitoringDisk)) {
1092
1093                 /* disk data needed */
1094
1095                 Location* loc = _loop_location;
1096
1097                 if (loc) {
1098                         samplepos_t effective_start;
1099
1100                         Evoral::Range<samplepos_t> loop_range (loc->start(), loc->end() - 1);
1101                         effective_start = loop_range.squish (start_sample);
1102
1103                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1104
1105                         if (effective_start == loc->start()) {
1106                                 /* We need to turn off notes that may extend
1107                                    beyond the loop end.
1108                                 */
1109
1110                                 _tracker.resolve_notes (*target, 0);
1111                         }
1112
1113                         /* for split-cycles we need to offset the events */
1114
1115                         if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1116
1117                                 /* end of loop is within the range we are reading, so
1118                                    split the read in two, and lie about the location
1119                                    for the 2nd read
1120                                 */
1121
1122                                 samplecnt_t first, second;
1123
1124                                 first = loc->end() - effective_start;
1125                                 second = nframes - first;
1126
1127                                 DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n",
1128                                                                                       effective_start, loc->end(), first, second));
1129
1130                                 if (first) {
1131                                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #1, from %1 for %2\n",
1132                                                                                               effective_start, first));
1133                                         events_read = rtmb->read (*target, effective_start, effective_start + first, _tracker);
1134                                 }
1135
1136                                 if (second) {
1137                                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #2, from %1 for %2\n",
1138                                                                                               loc->start(), second));
1139                                         events_read += rtmb->read (*target, loc->start(), loc->start() + second, _tracker);
1140                                 }
1141
1142                         } else {
1143                                 DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1144                                                                                 effective_start, nframes));
1145                                 events_read = rtmb->read (*target, effective_start, effective_start + nframes, _tracker);
1146                         }
1147                 } else {
1148                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("playback buffer read, from %1 to %2 (%3)", start_sample, end_sample, nframes));
1149                         events_read = rtmb->read (*target, start_sample, end_sample, _tracker, Port::port_offset ());
1150                 }
1151
1152                 DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("%1 MDS events read %2 range %3 .. %4\n", _name, events_read, playback_sample, playback_sample + nframes));
1153         }
1154
1155
1156         if (!_no_disk_output && (ms & MonitoringInput)) {
1157                 dst.merge_from (*target, nframes);
1158         }
1159
1160 #if 0
1161         if (!target->empty ()) {
1162                 cerr << "======== MIDI OUT ========\n";
1163                 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1164                         const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
1165                         cerr << "MIDI EVENT (from disk) @ " << ev.time();
1166                         for (size_t xx = 0; xx < ev.size(); ++xx) {
1167                                 cerr << ' ' << hex << (int) ev.buffer()[xx];
1168                         }
1169                         cerr << dec << endl;
1170                 }
1171                 cerr << "----------------\n";
1172         }
1173 #endif
1174 }
1175
1176 /** @a start is set to the new sample position (TIME) read up to */
1177 int
1178 DiskReader::midi_read (samplepos_t& start, samplecnt_t dur, bool reversed)
1179 {
1180         return 0;
1181 }
1182
1183 int
1184 DiskReader::refill_midi ()
1185 {
1186         /* nothing to do ... it's all in RAM thanks to overwrite */
1187         return 0;
1188 }
1189
1190 void
1191 DiskReader::dec_no_disk_output ()
1192 {
1193         /* this is called unconditionally when things happen that ought to end
1194            a period of "no disk output". It's OK for that to happen when there
1195            was no corresponding call to ::inc_no_disk_output(), but we must
1196            stop the value from becoming negative.
1197         */
1198
1199         do {
1200                 gint v  = g_atomic_int_get (&_no_disk_output);
1201                 if (v > 0) {
1202                         if (g_atomic_int_compare_and_exchange (&_no_disk_output, v, v - 1)) {
1203                                 break;
1204                         }
1205                 } else {
1206                         break;
1207                 }
1208         } while (true);
1209 }
1210
1211 DiskReader::DeclickAmp::DeclickAmp (samplecnt_t sample_rate)
1212 {
1213         _a = 4550.f / (gain_t)sample_rate;
1214         _l = -log1p (_a);
1215         _g = 0;
1216 }
1217
1218 void
1219 DiskReader::DeclickAmp::apply_gain (AudioBuffer& buf, samplecnt_t n_samples, const float target)
1220 {
1221         if (n_samples == 0) {
1222                 return;
1223         }
1224         float g = _g;
1225
1226         if (g == target) {
1227                 Amp::apply_simple_gain (buf, n_samples, target, 0);
1228                 return;
1229         }
1230
1231         const float a = _a;
1232         Sample* const buffer = buf.data ();
1233
1234         const int max_nproc = 16;
1235         uint32_t remain = n_samples;
1236         uint32_t offset = 0;
1237         while (remain > 0) {
1238                 uint32_t n_proc = remain > max_nproc ? max_nproc : remain;
1239                 for (uint32_t i = 0; i < n_proc; ++i) {
1240                         buffer[offset + i] *= g;
1241                 }
1242 #if 1
1243                 g += a * (target - g);
1244 #else /* accurate exponential fade */
1245                 if (n_proc == max_nproc) {
1246                         g += a * (target - g);
1247                 } else {
1248                         g = target - (target - g) * expf (_l * n_proc / max_nproc);
1249                 }
1250 #endif
1251                 remain -= n_proc;
1252                 offset += n_proc;
1253         }
1254
1255         if (fabsf (g - target) < /* GAIN_COEFF_DELTA */ 1e-5) {
1256                 _g = target;
1257         } else {
1258                 _g = g;
1259         }
1260 }
1261
1262 RTMidiBuffer*
1263 DiskReader::rt_midibuffer ()
1264 {
1265         boost::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
1266
1267         if (!pl) {
1268                 return 0;
1269         }
1270
1271         boost::shared_ptr<MidiPlaylist> mpl = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
1272
1273         if (!mpl) {
1274                 /* error, but whatever ... */
1275                 return 0;
1276         }
1277
1278         return mpl->rendered();
1279 }