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                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_track);
 526                 MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0;
 527
 528                 PBD::Timing minsert;
 529                 minsert.start();
 530
 531                 midi_playlist()->render (filter);
 532
 533                 minsert.update();
 534                 assert (midi_playlist()->rendered());
 535                 cerr << "Reading " << name()  << " took " << minsert.elapsed() << " microseconds, final size = " << midi_playlist()->rendered()->size() << endl;
 536         }
 537
 538         g_atomic_int_set (&_pending_overwrite, 0);
 539
 540         return true;
 541 }
 542
 543 int
 544 DiskReader::seek (samplepos_t sample, bool complete_refill)
 545 {
 546         /* called via non_realtime_locate() from butler thread */
 547
 548         uint32_t n;
 549         int ret = -1;
 550         ChannelList::iterator chan;
 551         boost::shared_ptr<ChannelList> c = channels.reader();
 552
 553 #ifndef NDEBUG
 554         if (_declick_amp.gain() != 0) {
 555                 /* this should not happen. new transport should postponse seeking
 556                  * until de-click is complete */
 557                 printf ("LOCATE WITHOUT DECLICK (gain=%f) at %ld seek-to %ld\n", _declick_amp.gain (), playback_sample, sample);
 558                 //return -1;
 559         }
 560         if (sample == playback_sample && !complete_refill) {
 561                 return 0; // XXX double-check this
 562         }
 563 #endif
 564
 565         g_atomic_int_set (&_pending_overwrite, 0);
 566
 567         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("DiskReader::seek %s %ld -> %ld refill=%d\n", owner()->name().c_str(), playback_sample, sample, complete_refill));
 568
 569         const samplecnt_t distance = sample - playback_sample;
 570         if (!complete_refill && can_internal_playback_seek (distance)) {
 571                 internal_playback_seek (distance);
 572                 return 0;
 573         }
 574
 575         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 576                 (*chan)->rbuf->reset ();
 577         }
 578
 579         playback_sample = sample;
 580         file_sample[DataType::AUDIO] = sample;
 581         file_sample[DataType::MIDI] = sample;
 582
 583         if (complete_refill) {
 584                 /* call _do_refill() to refill the entire buffer, using
 585                    the largest reads possible.
 586                 */
 587                 while ((ret = do_refill_with_alloc (false)) > 0) ;
 588         } else {
 589                 /* call _do_refill() to refill just one chunk, and then
 590                    return.
 591                 */
 592                 ret = do_refill_with_alloc (true);
 593         }
 594
 595         return ret;
 596 }
 597
 598 bool
 599 DiskReader::can_internal_playback_seek (sampleoffset_t distance)
 600 {
 601         /* 1. Audio */
 602
 603         ChannelList::iterator chan;
 604         boost::shared_ptr<ChannelList> c = channels.reader();
 605
 606         for (chan = c->begin(); chan != c->end(); ++chan) {
 607                 if (!(*chan)->rbuf->can_seek (distance)) {
 608                         return false;
 609                 }
 610         }
 611
 612         /* 2. MIDI can always seek any distance */
 613
 614         return true;
 615 }
 616
 617 void
 618 DiskReader::internal_playback_seek (sampleoffset_t distance)
 619 {
 620         if (distance == 0) {
 621                 return;
 622         }
 623
 624         sampleoffset_t off = distance;
 625
 626         ChannelList::iterator chan;
 627         boost::shared_ptr<ChannelList> c = channels.reader();
 628         for (chan = c->begin(); chan != c->end(); ++chan) {
 629                 if (distance < 0) {
 630                         off = 0 - (sampleoffset_t) (*chan)->rbuf->decrement_read_ptr (::llabs (distance));
 631                 } else {
 632                         off = (*chan)->rbuf->increment_read_ptr (distance);
 633                 }
 634         }
 635
 636         playback_sample += off;
 637 }
 638
 639 static
 640 void swap_by_ptr (Sample *first, Sample *last)
 641 {
 642         while (first < last) {
 643                 Sample tmp = *first;
 644                 *first++ = *last;
 645                 *last-- = tmp;
 646         }
 647 }
 648
 649 /** Read some data for 1 channel from our playlist into a buffer.
 650  *  @param buf Buffer to write to.
 651  *  @param start Session sample to start reading from; updated to where we end up
 652  *         after the read.
 653  *  @param cnt Count of samples to read.
 654  *  @param reversed true if we are running backwards, otherwise false.
 655  */
 656 int
 657 DiskReader::audio_read (PBD::PlaybackBuffer<Sample>*rb,
 658                         Sample* sum_buffer,
 659                         Sample* mixdown_buffer,
 660                         float* gain_buffer,
 661                         samplepos_t& start, samplecnt_t cnt,
 662                         int channel, bool reversed)
 663 {
 664         samplecnt_t this_read = 0;
 665         bool reloop = false;
 666         samplepos_t loop_end = 0;
 667         samplepos_t loop_start = 0;
 668         Location *loc = 0;
 669
 670         if (!_playlists[DataType::AUDIO]) {
 671                 rb->write_zero (cnt);
 672                 return 0;
 673         }
 674
 675         /* XXX we don't currently play loops in reverse. not sure why */
 676
 677         if (!reversed) {
 678
 679                 samplecnt_t loop_length = 0;
 680
 681                 /* Make the use of a Location atomic for this read operation.
 682
 683                    Note: Locations don't get deleted, so all we care about
 684                    when I say "atomic" is that we are always pointing to
 685                    the same one and using a start/length values obtained
 686                    just once.
 687                 */
 688
 689                 if ((loc = _loop_location) != 0) {
 690                         loop_start = loc->start();
 691                         loop_end = loc->end();
 692                         loop_length = loop_end - loop_start;
 693                 }
 694
 695                 /* if we are looping, ensure that the first sample we read is at the correct
 696                    position within the loop.
 697                 */
 698
 699                 if (loc && start >= loop_end) {
 700                         start = loop_start + ((start - loop_start) % loop_length);
 701                 }
 702
 703         }
 704
 705         if (reversed) {
 706                 start -= cnt;
 707         }
 708
 709         /* We need this while loop in case we hit a loop boundary, in which case our read from
 710            the playlist must be split into more than one section.
 711         */
 712
 713         while (cnt) {
 714
 715                 /* take any loop into account. we can't read past the end of the loop. */
 716
 717                 if (loc && (loop_end - start < cnt)) {
 718                         this_read = loop_end - start;
 719                         reloop = true;
 720                 } else {
 721                         reloop = false;
 722                         this_read = cnt;
 723                 }
 724
 725                 if (this_read == 0) {
 726                         break;
 727                 }
 728
 729                 this_read = min (cnt, this_read);
 730
 731                 if (audio_playlist()->read (sum_buffer, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 732                         error << string_compose(_("DiskReader %1: cannot read %2 from playlist at sample %3"), id(), this_read, start) << endmsg;
 733                         return -1;
 734                 }
 735
 736                 if (reversed) {
 737
 738                         swap_by_ptr (sum_buffer, sum_buffer + this_read - 1);
 739
 740                 } else {
 741
 742                         /* if we read to the end of the loop, go back to the beginning */
 743
 744                         if (reloop) {
 745                                 start = loop_start;
 746                         } else {
 747                                 start += this_read;
 748                         }
 749                 }
 750
 751                 if (rb->write (sum_buffer, this_read) != this_read) {
 752                         cerr << owner()->name() << " Ringbuffer Write overrun" << endl;
 753                 }
 754
 755                 cnt -= this_read;
 756         }
 757
 758         return 0;
 759 }
 760
 761 int
 762 DiskReader::_do_refill_with_alloc (bool partial_fill)
 763 {
 764         /* We limit disk reads to at most 4MB chunks, which with floating point
 765            samples would be 1M samples. But we might use 16 or 14 bit samples,
 766            in which case 4MB is more samples than that. Therefore size this for
 767            the smallest sample value .. 4MB = 2M samples (16 bit).
 768         */
 769
 770         boost::scoped_array<Sample> sum_buf (new Sample[2*1048576]);
 771         boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
 772         boost::scoped_array<float>  gain_buf (new float[2*1048576]);
 773
 774         return refill_audio (sum_buf.get(), mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0));
 775 }
 776
 777 int
 778 DiskReader::refill (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
 779 {
 780         /* nothing to do here for MIDI - the entire playlist has been rendered
 781          * into RAM already.
 782          */
 783         return refill_audio (sum_buffer, mixdown_buffer, gain_buffer, fill_level);
 784 }
 785
 786
 787 /** Get some more data from disk and put it in our channels' bufs,
 788  *  if there is suitable space in them.
 789  *
 790  * If fill_level is non-zero, then we will refill the buffer so that there is
 791  * still at least fill_level samples of space left to be filled. This is used
 792  * after locates so that we do not need to wait to fill the entire buffer.
 793  *
 794  */
 795
 796 int
 797 DiskReader::refill_audio (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
 798 {
 799         /* do not read from disk while session is marked as Loading, to avoid
 800            useless redundant I/O.
 801         */
 802
 803         if (_session.loading()) {
 804                 return 0;
 805         }
 806
 807         int32_t ret = 0;
 808         bool const reversed = _session.transport_speed() < 0.0f;
 809         samplecnt_t zero_fill;
 810         uint32_t chan_n;
 811         ChannelList::iterator i;
 812         boost::shared_ptr<ChannelList> c = channels.reader();
 813
 814         if (c->empty()) {
 815                 return 0;
 816         }
 817
 818         assert(mixdown_buffer);
 819         assert(gain_buffer);
 820
 821         samplecnt_t total_space = c->front()->rbuf->write_space();
 822
 823         if (total_space == 0) {
 824                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
 825                 /* nowhere to write to */
 826                 return 0;
 827         }
 828
 829         if (fill_level) {
 830                 if (fill_level < total_space) {
 831                         total_space -= fill_level;
 832                 } else {
 833                         /* we can't do anything with it */
 834                         fill_level = 0;
 835                 }
 836         }
 837
 838         /* if we're running close to normal speed and there isn't enough
 839            space to do disk_read_chunk_samples of I/O, then don't bother.
 840
 841            at higher speeds, just do it because the sync between butler
 842            and audio thread may not be good enough.
 843
 844            Note: it is a design assumption that disk_read_chunk_samples is smaller
 845            than the playback buffer size, so this check should never trip when
 846            the playback buffer is empty.
 847         */
 848
 849         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()));
 850         if ((total_space < _chunk_samples) && fabs (_session.transport_speed()) < 2.0f) {
 851                 return 0;
 852         }
 853
 854         /* when slaved, don't try to get too close to the read pointer. this
 855            leaves space for the buffer reversal to have something useful to
 856            work with.
 857         */
 858
 859         if (_slaved && total_space < (samplecnt_t) (c->front()->rbuf->bufsize() / 2)) {
 860                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
 861                 return 0;
 862         }
 863
 864         samplepos_t ffa = file_sample[DataType::AUDIO];
 865
 866         if (reversed) {
 867
 868                 if (ffa == 0) {
 869                         /* at start: nothing to do but fill with silence */
 870                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 871                                 ChannelInfo* chan (*i);
 872                                 chan->rbuf->write_zero (chan->rbuf->write_space ());
 873                         }
 874                         return 0;
 875                 }
 876
 877                 if (ffa < total_space) {
 878                         /* too close to the start: read what we can, and then zero fill the rest */
 879                         zero_fill = total_space - ffa;
 880                         total_space = ffa;
 881                 } else {
 882                         zero_fill = 0;
 883                 }
 884
 885         } else {
 886
 887                 if (ffa == max_samplepos) {
 888                         /* at end: nothing to do but fill with silence */
 889                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 890                                 ChannelInfo* chan (*i);
 891                                 chan->rbuf->write_zero (chan->rbuf->write_space ());
 892                         }
 893                         return 0;
 894                 }
 895
 896                 if (ffa > max_samplepos - total_space) {
 897                         /* to close to the end: read what we can, and zero fill the rest */
 898                         zero_fill = total_space - (max_samplepos - ffa);
 899                         total_space = max_samplepos - ffa;
 900
 901                 } else {
 902                         zero_fill = 0;
 903                 }
 904         }
 905
 906         /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
 907         const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
 908         size_t total_bytes = total_space * bits_per_sample / 8;
 909
 910         /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer */
 911         size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
 912
 913         /* find nearest (lower) multiple of 16384 */
 914
 915         byte_size_for_read = (byte_size_for_read / 16384) * 16384;
 916
 917         /* now back to samples */
 918         samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
 919
 920         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
 921
 922         samplepos_t file_sample_tmp = ffa;
 923
 924         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 925                 ChannelInfo* chan (*i);
 926                 file_sample_tmp = ffa;
 927                 samplecnt_t ts = total_space;
 928
 929                 samplecnt_t to_read = min (ts, (samplecnt_t) chan->rbuf->write_space ());
 930                 to_read = min (to_read, samples_to_read);
 931                 assert (to_read >= 0);
 932
 933                 // cerr << owner()->name() << " to-read: " << to_read << endl;
 934
 935                 if (to_read) {
 936                         if (audio_read (chan->rbuf, sum_buffer, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
 937                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"), id(), to_read, ffa) << endmsg;
 938                                 ret = -1;
 939                                 goto out;
 940                         }
 941                 }
 942
 943                 if (zero_fill) {
 944                         /* not sure if action is needed,
 945                          * we'll later hit the "to close to the end" case
 946                          */
 947                         //chan->rbuf->write_zero (zero_fill);
 948                 }
 949         }
 950
 951         // elapsed = g_get_monotonic_time () - before;
 952         // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
 953
 954         file_sample[DataType::AUDIO] = file_sample_tmp;
 955         assert (file_sample[DataType::AUDIO] >= 0);
 956
 957         ret = ((total_space - samples_to_read) > _chunk_samples);
 958
 959   out:
 960         return ret;
 961 }
 962
 963 void
 964 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > const & movements_samples, bool from_undo_or_shift)
 965 {
 966         /* If we're coming from an undo, it will have handled
 967          * automation undo (it must, since automation-follows-regions
 968          * can lose automation data).  Hence we can do nothing here.
 969          *
 970          * Likewise when shifting regions (insert/remove time)
 971          * automation is taken care of separately (busses with
 972          * automation have no disk-reader).
 973          */
 974
 975         if (from_undo_or_shift) {
 976                 return;
 977         }
 978
 979         if (!_track || Config->get_automation_follows_regions () == false) {
 980                 return;
 981         }
 982
 983         list< Evoral::RangeMove<double> > movements;
 984
 985         for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
 986              i != movements_samples.end();
 987              ++i) {
 988
 989                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
 990         }
 991
 992         /* move panner automation */
 993         boost::shared_ptr<Pannable> pannable = _track->pannable();
 994         Evoral::ControlSet::Controls& c (pannable->controls());
 995
 996         for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
 997                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
 998                 if (!ac) {
 999                         continue;
1000                 }
1001                 boost::shared_ptr<AutomationList> alist = ac->alist();
1002                 if (!alist->size()) {
1003                         continue;
1004                 }
1005                 XMLNode & before = alist->get_state ();
1006                 bool const things_moved = alist->move_ranges (movements);
1007                 if (things_moved) {
1008                         _session.add_command (new MementoCommand<AutomationList> (
1009                                                       *alist.get(), &before, &alist->get_state ()));
1010                 }
1011         }
1012         /* move processor automation */
1013         _track->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples));
1014 }
1015
1016 void
1017 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
1018 {
1019         boost::shared_ptr<Processor> processor (p.lock ());
1020         if (!processor) {
1021                 return;
1022         }
1023
1024         list< Evoral::RangeMove<double> > movements;
1025         for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) {
1026                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1027         }
1028
1029         set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1030
1031         for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1032                 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1033                 if (!al->size()) {
1034                         continue;
1035                 }
1036                 XMLNode & before = al->get_state ();
1037                 bool const things_moved = al->move_ranges (movements);
1038                 if (things_moved) {
1039                         _session.add_command (
1040                                 new MementoCommand<AutomationList> (
1041                                         *al.get(), &before, &al->get_state ()
1042                                         )
1043                                 );
1044                 }
1045         }
1046 }
1047
1048 void
1049 DiskReader::reset_tracker ()
1050 {
1051         _tracker.reset ();
1052 }
1053
1054 void
1055 DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
1056 {
1057         _tracker.resolve_notes (buffer, time);
1058 }
1059
1060 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1061  *  so that an event at playback_sample has time = 0
1062  */
1063 void
1064 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)
1065 {
1066         RTMidiBuffer* rtmb = rt_midibuffer();
1067
1068         if (!rtmb || (rtmb->size() == 0)) {
1069                 /* no data to read, so do nothing */
1070                 return;
1071         }
1072
1073         MidiBuffer* target;
1074
1075         if (ms & MonitoringInput) {
1076                 /* data from disk needs to be *merged* not written into the
1077                    dst, because it may contain input data that we want to
1078                    monitor. Since RTMidiBuffer currently (Oct 2019) has no
1079                    suitable method, put the disk data into a scratch buffer and
1080                    then merge later.
1081                 */
1082
1083                 target = &scratch_bufs.get_midi (0);
1084         } else {
1085                 /* No need to preserve the contents of the input buffer. But
1086                  * Route::process_output_buffers() clears the buffer as-needed
1087                  * so know we do not need to clear it.
1088                  */
1089                 target = &dst;
1090         }
1091
1092         /* Note: do not fetch any data from disk if we're moving
1093          * backwards. TODO: reverse MIDI
1094          */
1095
1096         if (!pending_overwrite() && !_no_disk_output && (end_sample >= start_sample)) {
1097
1098                 const samplepos_t nframes = ::llabs (end_sample - start_sample);
1099
1100                 if (ms & MonitoringDisk) {
1101
1102                         /* disk data needed
1103                          *
1104                          * NOTE: we will never be asked to read across loop location
1105                          * boundaries - the session splits processing at the
1106                          * loop end.
1107                          */
1108
1109                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("playback buffer read, from %1 to %2 (%3)", start_sample, end_sample, nframes));
1110                         size_t events_read = rtmb->read (*target, start_sample, end_sample, _tracker, Port::port_offset ());
1111                         DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("%1 MDS events read %2 range %3 .. %4\n", _name, events_read, playback_sample, playback_sample + nframes));
1112                 }
1113
1114                 if (ms & MonitoringInput) {
1115                         /* merges data from disk (in "target", which is a scratch
1116                            buffer in this case) into the actual destination buffer
1117                            (which holds existing input data).
1118                         */
1119                         dst.merge_from (*target, nframes);
1120                 }
1121         }
1122
1123 #if 0
1124         if (!target->empty ()) {
1125                 cerr << "======== MIDI OUT ========\n";
1126                 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1127                         const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
1128                         cerr << "MIDI EVENT (from disk) @ " << ev.time();
1129                         for (size_t xx = 0; xx < ev.size(); ++xx) {
1130                                 cerr << ' ' << hex << (int) ev.buffer()[xx];
1131                         }
1132                         cerr << dec << endl;
1133                 }
1134                 cerr << "----------------\n";
1135         }
1136 #endif
1137 }
1138
1139 void
1140 DiskReader::dec_no_disk_output ()
1141 {
1142         /* this is called unconditionally when things happen that ought to end
1143            a period of "no disk output". It's OK for that to happen when there
1144            was no corresponding call to ::inc_no_disk_output(), but we must
1145            stop the value from becoming negative.
1146         */
1147
1148         do {
1149                 gint v  = g_atomic_int_get (&_no_disk_output);
1150                 if (v > 0) {
1151                         if (g_atomic_int_compare_and_exchange (&_no_disk_output, v, v - 1)) {
1152                                 break;
1153                         }
1154                 } else {
1155                         break;
1156                 }
1157         } while (true);
1158 }
1159
1160 DiskReader::DeclickAmp::DeclickAmp (samplecnt_t sample_rate)
1161 {
1162         _a = 4550.f / (gain_t)sample_rate;
1163         _l = -log1p (_a);
1164         _g = 0;
1165 }
1166
1167 void
1168 DiskReader::DeclickAmp::apply_gain (AudioBuffer& buf, samplecnt_t n_samples, const float target)
1169 {
1170         if (n_samples == 0) {
1171                 return;
1172         }
1173         float g = _g;
1174
1175         if (g == target) {
1176                 Amp::apply_simple_gain (buf, n_samples, target, 0);
1177                 return;
1178         }
1179
1180         const float a = _a;
1181         Sample* const buffer = buf.data ();
1182
1183         const int max_nproc = 16;
1184         uint32_t remain = n_samples;
1185         uint32_t offset = 0;
1186         while (remain > 0) {
1187                 uint32_t n_proc = remain > max_nproc ? max_nproc : remain;
1188                 for (uint32_t i = 0; i < n_proc; ++i) {
1189                         buffer[offset + i] *= g;
1190                 }
1191 #if 1
1192                 g += a * (target - g);
1193 #else /* accurate exponential fade */
1194                 if (n_proc == max_nproc) {
1195                         g += a * (target - g);
1196                 } else {
1197                         g = target - (target - g) * expf (_l * n_proc / max_nproc);
1198                 }
1199 #endif
1200                 remain -= n_proc;
1201                 offset += n_proc;
1202         }
1203
1204         if (fabsf (g - target) < /* GAIN_COEFF_DELTA */ 1e-5) {
1205                 _g = target;
1206         } else {
1207                 _g = g;
1208         }
1209 }
1210
1211 RTMidiBuffer*
1212 DiskReader::rt_midibuffer ()
1213 {
1214         boost::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
1215
1216         if (!pl) {
1217                 return 0;
1218         }
1219
1220         boost::shared_ptr<MidiPlaylist> mpl = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
1221
1222         if (!mpl) {
1223                 /* error, but whatever ... */
1224                 return 0;
1225         }
1226
1227         return mpl->rendered();
1228 }