libs/ardour/disk_reader.cc

   1 /*
   2     Copyright (C) 2009-2016 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "pbd/enumwriter.h"
  21 #include "pbd/i18n.h"
  22 #include "pbd/memento_command.h"
  23
  24 #include "ardour/audioengine.h"
  25 #include "ardour/audioplaylist.h"
  26 #include "ardour/audio_buffer.h"
  27 #include "ardour/butler.h"
  28 #include "ardour/debug.h"
  29 #include "ardour/disk_reader.h"
  30 #include "ardour/midi_ring_buffer.h"
  31 #include "ardour/midi_playlist.h"
  32 #include "ardour/pannable.h"
  33 #include "ardour/playlist.h"
  34 #include "ardour/playlist_factory.h"
  35 #include "ardour/session.h"
  36 #include "ardour/session_playlists.h"
  37
  38 using namespace ARDOUR;
  39 using namespace PBD;
  40 using namespace std;
  41
  42 ARDOUR::framecnt_t DiskReader::_chunk_frames = default_chunk_frames ();
  43 PBD::Signal0<void> DiskReader::Underrun;
  44 Sample* DiskReader::_mixdown_buffer = 0;
  45 gain_t* DiskReader::_gain_buffer = 0;
  46 framecnt_t DiskReader::midi_readahead = 4096;
  47
  48 DiskReader::DiskReader (Session& s, string const & str, DiskIOProcessor::Flag f)
  49         : DiskIOProcessor (s, str, f)
  50         , _roll_delay (0)
  51         , overwrite_frame (0)
  52         , overwrite_offset (0)
  53         , _pending_overwrite (false)
  54         , overwrite_queued (false)
  55         , _gui_feed_buffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
  56 {
  57 }
  58
  59 DiskReader::~DiskReader ()
  60 {
  61         DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskReader %1 deleted\n", _name));
  62
  63         for (uint32_t n = 0; n < DataType::num_types; ++n) {
  64                 if (_playlists[n]) {
  65                         _playlists[n]->release ();
  66                 }
  67         }
  68
  69         {
  70                 RCUWriter<ChannelList> writer (channels);
  71                 boost::shared_ptr<ChannelList> c = writer.get_copy();
  72
  73                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
  74                         delete *chan;
  75                 }
  76
  77                 c->clear();
  78         }
  79
  80         channels.flush ();
  81
  82         delete _midi_buf;
  83 }
  84
  85 void
  86 DiskReader::allocate_working_buffers()
  87 {
  88         /* with varifill buffer refilling, we compute the read size in bytes (to optimize
  89            for disk i/o bandwidth) and then convert back into samples. These buffers
  90            need to reflect the maximum size we could use, which is 4MB reads, or 2M samples
  91            using 16 bit samples.
  92         */
  93         _mixdown_buffer       = new Sample[2*1048576];
  94         _gain_buffer          = new gain_t[2*1048576];
  95 }
  96
  97 void
  98 DiskReader::free_working_buffers()
  99 {
 100         delete [] _mixdown_buffer;
 101         delete [] _gain_buffer;
 102         _mixdown_buffer       = 0;
 103         _gain_buffer          = 0;
 104 }
 105
 106 framecnt_t
 107 DiskReader::default_chunk_frames()
 108 {
 109         return 65536;
 110 }
 111
 112 bool
 113 DiskReader::set_name (string const & str)
 114 {
 115         string my_name = X_("reader:");
 116         my_name += str;
 117
 118         if (_name != my_name) {
 119                 SessionObject::set_name (my_name);
 120         }
 121
 122         return true;
 123 }
 124
 125 void
 126 DiskReader::set_roll_delay (ARDOUR::framecnt_t nframes)
 127 {
 128         _roll_delay = nframes;
 129 }
 130
 131 XMLNode&
 132 DiskReader::state (bool full)
 133 {
 134         XMLNode& node (DiskIOProcessor::state (full));
 135         node.set_property(X_("type"), X_("diskreader"));
 136         return node;
 137 }
 138
 139 int
 140 DiskReader::set_state (const XMLNode& node, int version)
 141 {
 142         if (DiskIOProcessor::set_state (node, version)) {
 143                 return -1;
 144         }
 145
 146         return 0;
 147 }
 148
 149 void
 150 DiskReader::realtime_handle_transport_stopped ()
 151 {
 152         realtime_speed_change ();
 153 }
 154
 155 void
 156 DiskReader::realtime_locate ()
 157 {
 158 }
 159
 160 float
 161 DiskReader::buffer_load () const
 162 {
 163         /* Note: for MIDI it's not trivial to differentiate the following two cases:
 164
 165            1.  The playback buffer is empty because the system has run out of time to fill it.
 166            2.  The playback buffer is empty because there is no more data on the playlist.
 167
 168            If we use a simple buffer load computation, we will report that the MIDI diskstream
 169            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
 170            are so low compared to audio, just use the audio value here.
 171         */
 172
 173         boost::shared_ptr<ChannelList> c = channels.reader();
 174
 175         if (c->empty ()) {
 176                 /* no channels, so no buffers, so completely full and ready to playback, sir! */
 177                 return 1.0;
 178         }
 179
 180         PBD::RingBufferNPT<Sample> * b = c->front()->buf;
 181         return (float) ((double) b->read_space() / (double) b->bufsize());
 182 }
 183
 184 void
 185 DiskReader::adjust_buffering ()
 186 {
 187         boost::shared_ptr<ChannelList> c = channels.reader();
 188
 189         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 190                 (*chan)->resize (_session.butler()->audio_diskstream_playback_buffer_size());
 191         }
 192 }
 193
 194 void
 195 DiskReader::playlist_changed (const PropertyChange&)
 196 {
 197         playlist_modified ();
 198 }
 199
 200 void
 201 DiskReader::playlist_modified ()
 202 {
 203         if (!i_am_the_modifier && !overwrite_queued) {
 204                 _session.request_overwrite_buffer (_route);
 205                 overwrite_queued = true;
 206         }
 207 }
 208
 209 int
 210 DiskReader::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist)
 211 {
 212         bool prior_playlist = false;
 213
 214         if (_playlists[dt]) {
 215                 prior_playlist = true;
 216         }
 217
 218         if (DiskIOProcessor::use_playlist (dt, playlist)) {
 219                 return -1;
 220         }
 221
 222         /* don't do this if we've already asked for it *or* if we are setting up
 223            the diskstream for the very first time - the input changed handling will
 224            take care of the buffer refill.
 225         */
 226
 227         if (!overwrite_queued && (prior_playlist || _session.loading())) {
 228                 _session.request_overwrite_buffer (_route);
 229                 overwrite_queued = true;
 230         }
 231
 232         return 0;
 233 }
 234
 235 void
 236 DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
 237                  double speed, pframes_t nframes, bool result_required)
 238 {
 239         uint32_t n;
 240         boost::shared_ptr<ChannelList> c = channels.reader();
 241         ChannelList::iterator chan;
 242         frameoffset_t playback_distance = nframes;
 243         MonitorState ms = _route->monitoring_state ();
 244
 245         if (_active) {
 246                 if (!_pending_active) {
 247                         _active = false;
 248                         return;
 249                 }
 250         } else {
 251                 if (_pending_active) {
 252                         _active = true;
 253                 } else {
 254                         return;
 255                 }
 256         }
 257
 258         _need_butler = false;
 259
 260         if (speed != 1.0f && speed != -1.0f) {
 261                 interpolation.set_speed (speed);
 262                 midi_interpolation.set_speed (speed);
 263                 playback_distance = midi_interpolation.distance (nframes);
 264         }
 265
 266         if (speed < 0.0) {
 267                 playback_distance = -playback_distance;
 268         }
 269
 270         BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
 271
 272         if (!result_required || ((ms & MonitoringDisk) == 0)) {
 273
 274                 /* no need for actual disk data, just advance read pointer and return */
 275
 276                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 277                         (*chan)->buf->increment_read_ptr (playback_distance);
 278                 }
 279
 280         } else {
 281
 282                 /* we need audio data from disk */
 283
 284                 size_t n_buffers = bufs.count().n_audio();
 285                 size_t n_chans = c->size();
 286                 gain_t scaling;
 287
 288                 if (n_chans > n_buffers) {
 289                         scaling = ((float) n_buffers)/n_chans;
 290                 } else {
 291                         scaling = 1.0;
 292                 }
 293
 294                 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 295
 296                         ChannelInfo* chaninfo (*chan);
 297                         AudioBuffer& buf (bufs.get_audio (n%n_buffers));
 298                         Sample* outgoing = 0; /* assignment not really needed but it keeps the compiler quiet and helps track bugs */
 299
 300                         if (ms & MonitoringInput) {
 301                                 /* put disk stream in scratch buffer, blend at end */
 302                                 outgoing = scratch_bufs.get_audio(n).data ();
 303                         } else {
 304                                 /* no input stream needed, just overwrite buffers */
 305                                 outgoing = buf.data ();
 306                         }
 307
 308                         chaninfo->buf->get_read_vector (&(*chan)->rw_vector);
 309
 310                         if (playback_distance <= (framecnt_t) chaninfo->rw_vector.len[0]) {
 311
 312                                 if (fabsf (speed) != 1.0f) {
 313                                         (void) interpolation.interpolate (
 314                                                 n, nframes,
 315                                                 chaninfo->rw_vector.buf[0],
 316                                                 outgoing);
 317                                 } else {
 318                                         memcpy (outgoing, chaninfo->rw_vector.buf[0], sizeof (Sample) * playback_distance);
 319                                 }
 320
 321                         } else {
 322
 323                                 const framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
 324
 325                                 if (playback_distance <= total) {
 326
 327                                         /* We have enough samples, but not in one lump.
 328                                          */
 329
 330                                         if (fabsf (speed) != 1.0f) {
 331                                                 interpolation.interpolate (n, chaninfo->rw_vector.len[0],
 332                                                                            chaninfo->rw_vector.buf[0],
 333                                                                            outgoing);
 334                                                 outgoing += chaninfo->rw_vector.len[0];
 335                                                 interpolation.interpolate (n, playback_distance - chaninfo->rw_vector.len[0],
 336                                                                            chaninfo->rw_vector.buf[1],
 337                                                                            outgoing);
 338                                         } else {
 339                                                 memcpy (outgoing,
 340                                                         chaninfo->rw_vector.buf[0],
 341                                                         chaninfo->rw_vector.len[0] * sizeof (Sample));
 342                                                 outgoing += chaninfo->rw_vector.len[0];
 343                                                 memcpy (outgoing,
 344                                                         chaninfo->rw_vector.buf[1],
 345                                                         (playback_distance - chaninfo->rw_vector.len[0]) * sizeof (Sample));
 346                                         }
 347
 348                                 } else {
 349
 350                                         cerr << _name << " Need " << playback_distance << " total = " << total << endl;
 351                                         cerr << "underrun for " << _name << endl;
 352                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
 353                                                                                     DEBUG_THREAD_SELF, name(), total));
 354                                         Underrun ();
 355                                         return;
 356
 357                                 }
 358                         }
 359
 360                         if (scaling != 1.0f) {
 361                                 apply_gain_to_buffer (outgoing, nframes, scaling);
 362                         }
 363
 364                         chaninfo->buf->increment_read_ptr (playback_distance);
 365
 366                         if (ms & MonitoringInput) {
 367                                 /* mix the disk signal into the input signal (already in bufs) */
 368                                 mix_buffers_no_gain (buf.data(), outgoing, speed == 0.0 ? nframes : playback_distance);
 369                         }
 370                 }
 371         }
 372
 373         /* MIDI data handling */
 374
 375         if (!_session.declick_out_pending()) {
 376                 if (ms & MonitoringDisk) {
 377                         get_midi_playback (bufs.get_midi (0), playback_distance, ms, scratch_bufs, speed, playback_distance);
 378                 }
 379         }
 380
 381         if (speed < 0.0) {
 382                 playback_sample -= playback_distance;
 383         } else {
 384                 playback_sample += playback_distance;
 385         }
 386
 387         if (_playlists[DataType::AUDIO]) {
 388                 if (!c->empty()) {
 389                         if (_slaved) {
 390                                 if (c->front()->buf->write_space() >= c->front()->buf->bufsize() / 2) {
 391                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 392                                                                                     c->front()->buf->bufsize()));
 393                                         _need_butler = true;
 394                                 }
 395                         } else {
 396                                 if ((framecnt_t) c->front()->buf->write_space() >= _chunk_frames) {
 397                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 398                                                                                     _chunk_frames));
 399                                         _need_butler = true;
 400                                 }
 401                         }
 402                 }
 403         }
 404
 405         if (_playlists[DataType::MIDI]) {
 406                 /* MIDI butler needed part */
 407
 408                 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
 409                 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
 410
 411                 /*
 412                   cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
 413                   " = " << frames_written - frames_read
 414                   << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
 415                 */
 416
 417                 /* frames_read will generally be less than frames_written, but
 418                  * immediately after an overwrite, we can end up having read some data
 419                  * before we've written any. we don't need to trip an assert() on this,
 420                  * but we do need to check so that the decision on whether or not we
 421                  * need the butler is done correctly.
 422                  */
 423
 424                 /* furthermore..
 425                  *
 426                  * Doing heavy GUI operations[1] can stall also the butler.
 427                  * The RT-thread meanwhile will happily continue and
 428                  * ‘frames_read’ (from buffer to output) will become larger
 429                  * than ‘frames_written’ (from disk to buffer).
 430                  *
 431                  * The disk-stream is now behind..
 432                  *
 433                  * In those cases the butler needs to be summed to refill the buffer (done now)
 434                  * AND we need to skip (frames_read - frames_written). ie remove old events
 435                  * before playback_sample from the rinbuffer.
 436                  *
 437                  * [1] one way to do so is described at #6170.
 438                  * For me just popping up the context-menu on a MIDI-track header
 439                  * of a track with a large (think beethoven :) midi-region also did the
 440                  * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
 441                  *
 442                  * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
 443                  * and can stall
 444                  */
 445                 if (frames_read <= frames_written) {
 446                         if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 447                                 _need_butler = true;
 448                         }
 449                 } else {
 450                         _need_butler = true;
 451                 }
 452
 453         }
 454
 455         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
 456 }
 457
 458 void
 459 DiskReader::set_pending_overwrite (bool yn)
 460 {
 461         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 462
 463         _pending_overwrite = yn;
 464
 465         overwrite_frame = playback_sample;
 466
 467         boost::shared_ptr<ChannelList> c = channels.reader ();
 468         if (!c->empty ()) {
 469                 overwrite_offset = c->front()->buf->get_read_ptr();
 470         }
 471 }
 472
 473 int
 474 DiskReader::overwrite_existing_buffers ()
 475 {
 476         int ret = -1;
 477
 478         boost::shared_ptr<ChannelList> c = channels.reader();
 479
 480         overwrite_queued = false;
 481
 482         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_frame));
 483
 484         if (!c->empty ()) {
 485
 486                 /* AUDIO */
 487
 488                 const bool reversed = _session.transport_speed() < 0.0f;
 489
 490                 /* assume all are the same size */
 491                 framecnt_t size = c->front()->buf->bufsize();
 492
 493                 std::auto_ptr<Sample> mixdown_buffer (new Sample[size]);
 494                 std::auto_ptr<float> gain_buffer (new float[size]);
 495
 496                 /* reduce size so that we can fill the buffer correctly (ringbuffers
 497                    can only handle size-1, otherwise they appear to be empty)
 498                 */
 499                 size--;
 500
 501                 uint32_t n=0;
 502                 framepos_t start;
 503
 504                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 505
 506                         start = overwrite_frame;
 507                         framecnt_t cnt = size;
 508
 509                         /* to fill the buffer without resetting the playback sample, we need to
 510                            do it one or two chunks (normally two).
 511
 512                            |----------------------------------------------------------------------|
 513
 514                            ^
 515                            overwrite_offset
 516                            |<- second chunk->||<----------------- first chunk ------------------>|
 517
 518                         */
 519
 520                         framecnt_t to_read = size - overwrite_offset;
 521
 522                         if (audio_read ((*chan)->buf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
 523                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 524                                                         id(), size, playback_sample) << endmsg;
 525                                 goto midi;
 526                         }
 527
 528                         if (cnt > to_read) {
 529
 530                                 cnt -= to_read;
 531
 532                                 if (audio_read ((*chan)->buf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
 533                                         error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 534                                                                 id(), size, playback_sample) << endmsg;
 535                                         goto midi;
 536                                 }
 537                         }
 538                 }
 539
 540                 ret = 0;
 541
 542         }
 543
 544   midi:
 545
 546         if (_midi_buf && _playlists[DataType::MIDI]) {
 547
 548                 /* Clear the playback buffer contents.  This is safe as long as the butler
 549                    thread is suspended, which it should be.
 550                 */
 551                 _midi_buf->reset ();
 552                 _midi_buf->reset_tracker ();
 553
 554                 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 555                 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 556
 557                 /* Resolve all currently active notes in the playlist.  This is more
 558                    aggressive than it needs to be: ideally we would only resolve what is
 559                    absolutely necessary, but this seems difficult and/or impossible without
 560                    having the old data or knowing what change caused the overwrite.
 561                 */
 562                 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_frame);
 563
 564                 midi_read (overwrite_frame, _chunk_frames, false);
 565
 566                 file_frame = overwrite_frame; // it was adjusted by ::midi_read()
 567         }
 568
 569         _pending_overwrite = false;
 570
 571         return ret;
 572 }
 573
 574 int
 575 DiskReader::seek (framepos_t frame, bool complete_refill)
 576 {
 577         uint32_t n;
 578         int ret = -1;
 579         ChannelList::iterator chan;
 580         boost::shared_ptr<ChannelList> c = channels.reader();
 581
 582         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 583                 (*chan)->buf->reset ();
 584         }
 585
 586         if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
 587                 /* we haven't read anything since the last seek,
 588                    so flush all note trackers to prevent
 589                    wierdness
 590                 */
 591                 reset_tracker ();
 592         }
 593
 594         _midi_buf->reset();
 595         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 596         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 597
 598         playback_sample = frame;
 599         file_frame = frame;
 600
 601         if (complete_refill) {
 602                 /* call _do_refill() to refill the entire buffer, using
 603                    the largest reads possible.
 604                 */
 605                 while ((ret = do_refill_with_alloc (false)) > 0) ;
 606         } else {
 607                 /* call _do_refill() to refill just one chunk, and then
 608                    return.
 609                 */
 610                 ret = do_refill_with_alloc (true);
 611         }
 612
 613
 614         return ret;
 615 }
 616
 617 int
 618 DiskReader::can_internal_playback_seek (framecnt_t distance)
 619 {
 620         /* 1. Audio */
 621
 622         ChannelList::iterator chan;
 623         boost::shared_ptr<ChannelList> c = channels.reader();
 624
 625         for (chan = c->begin(); chan != c->end(); ++chan) {
 626                 if ((*chan)->buf->read_space() < (size_t) distance) {
 627                         return false;
 628                 }
 629         }
 630
 631         /* 2. MIDI */
 632
 633         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 634         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 635
 636         return ((frames_written - frames_read) < distance);
 637 }
 638
 639 int
 640 DiskReader::internal_playback_seek (framecnt_t distance)
 641 {
 642         ChannelList::iterator chan;
 643         boost::shared_ptr<ChannelList> c = channels.reader();
 644
 645         for (chan = c->begin(); chan != c->end(); ++chan) {
 646                 (*chan)->buf->increment_read_ptr (::llabs(distance));
 647         }
 648
 649         playback_sample += distance;
 650
 651         return 0;
 652 }
 653
 654 static
 655 void swap_by_ptr (Sample *first, Sample *last)
 656 {
 657         while (first < last) {
 658                 Sample tmp = *first;
 659                 *first++ = *last;
 660                 *last-- = tmp;
 661         }
 662 }
 663
 664 /** Read some data for 1 channel from our playlist into a buffer.
 665  *  @param buf Buffer to write to.
 666  *  @param start Session frame to start reading from; updated to where we end up
 667  *         after the read.
 668  *  @param cnt Count of samples to read.
 669  *  @param reversed true if we are running backwards, otherwise false.
 670  */
 671 int
 672 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 673                         framepos_t& start, framecnt_t cnt,
 674                         int channel, bool reversed)
 675 {
 676         framecnt_t this_read = 0;
 677         bool reloop = false;
 678         framepos_t loop_end = 0;
 679         framepos_t loop_start = 0;
 680         framecnt_t offset = 0;
 681         Location *loc = 0;
 682
 683         if (!_playlists[DataType::AUDIO]) {
 684                 memset (buf, 0, sizeof (Sample) * cnt);
 685                 return 0;
 686         }
 687
 688         /* XXX we don't currently play loops in reverse. not sure why */
 689
 690         if (!reversed) {
 691
 692                 framecnt_t loop_length = 0;
 693
 694                 /* Make the use of a Location atomic for this read operation.
 695
 696                    Note: Locations don't get deleted, so all we care about
 697                    when I say "atomic" is that we are always pointing to
 698                    the same one and using a start/length values obtained
 699                    just once.
 700                 */
 701
 702                 if ((loc = loop_location) != 0) {
 703                         loop_start = loc->start();
 704                         loop_end = loc->end();
 705                         loop_length = loop_end - loop_start;
 706                 }
 707
 708                 /* if we are looping, ensure that the first frame we read is at the correct
 709                    position within the loop.
 710                 */
 711
 712                 if (loc && start >= loop_end) {
 713                         start = loop_start + ((start - loop_start) % loop_length);
 714                 }
 715
 716         }
 717
 718         if (reversed) {
 719                 start -= cnt;
 720         }
 721
 722         /* We need this while loop in case we hit a loop boundary, in which case our read from
 723            the playlist must be split into more than one section.
 724         */
 725
 726         while (cnt) {
 727
 728                 /* take any loop into account. we can't read past the end of the loop. */
 729
 730                 if (loc && (loop_end - start < cnt)) {
 731                         this_read = loop_end - start;
 732                         reloop = true;
 733                 } else {
 734                         reloop = false;
 735                         this_read = cnt;
 736                 }
 737
 738                 if (this_read == 0) {
 739                         break;
 740                 }
 741
 742                 this_read = min(cnt,this_read);
 743
 744                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 745                         error << string_compose(_("DiskReader %1: cannot read %2 from playlist at frame %3"), id(), this_read,
 746                                          start) << endmsg;
 747                         return -1;
 748                 }
 749
 750                 if (reversed) {
 751
 752                         swap_by_ptr (buf, buf + this_read - 1);
 753
 754                 } else {
 755
 756                         /* if we read to the end of the loop, go back to the beginning */
 757
 758                         if (reloop) {
 759                                 start = loop_start;
 760                         } else {
 761                                 start += this_read;
 762                         }
 763                 }
 764
 765                 cnt -= this_read;
 766                 offset += this_read;
 767         }
 768
 769         return 0;
 770 }
 771
 772 int
 773 DiskReader::_do_refill_with_alloc (bool partial_fill)
 774 {
 775         /* We limit disk reads to at most 4MB chunks, which with floating point
 776            samples would be 1M samples. But we might use 16 or 14 bit samples,
 777            in which case 4MB is more samples than that. Therefore size this for
 778            the smallest sample value .. 4MB = 2M samples (16 bit).
 779         */
 780
 781         {
 782                 std::auto_ptr<Sample> mix_buf (new Sample[2*1048576]);
 783                 std::auto_ptr<float>  gain_buf (new float[2*1048576]);
 784
 785                 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_frames : 0));
 786
 787                 if (ret) {
 788                         return ret;
 789                 }
 790         }
 791
 792         return refill_midi ();
 793 }
 794
 795 int
 796 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 797 {
 798         int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
 799
 800         if (ret) {
 801                 return ret;
 802         }
 803
 804         return refill_midi ();
 805 }
 806
 807
 808 /** Get some more data from disk and put it in our channels' bufs,
 809  *  if there is suitable space in them.
 810  *
 811  * If fill_level is non-zero, then we will refill the buffer so that there is
 812  * still at least fill_level samples of space left to be filled. This is used
 813  * after locates so that we do not need to wait to fill the entire buffer.
 814  *
 815  */
 816
 817 int
 818 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 819 {
 820         /* do not read from disk while session is marked as Loading, to avoid
 821            useless redundant I/O.
 822         */
 823
 824         if (_session.loading()) {
 825                 return 0;
 826         }
 827
 828         int32_t ret = 0;
 829         framecnt_t to_read;
 830         RingBufferNPT<Sample>::rw_vector vector;
 831         bool const reversed = _session.transport_speed() < 0.0f;
 832         framecnt_t total_space;
 833         framecnt_t zero_fill;
 834         uint32_t chan_n;
 835         ChannelList::iterator i;
 836         boost::shared_ptr<ChannelList> c = channels.reader();
 837         framecnt_t ts;
 838
 839         if (c->empty()) {
 840                 return 0;
 841         }
 842
 843         assert(mixdown_buffer);
 844         assert(gain_buffer);
 845
 846         vector.buf[0] = 0;
 847         vector.len[0] = 0;
 848         vector.buf[1] = 0;
 849         vector.len[1] = 0;
 850
 851         c->front()->buf->get_write_vector (&vector);
 852
 853         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
 854                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
 855                 /* nowhere to write to */
 856                 return 0;
 857         }
 858
 859         if (fill_level) {
 860                 if (fill_level < total_space) {
 861                         total_space -= fill_level;
 862                 } else {
 863                         /* we can't do anything with it */
 864                         fill_level = 0;
 865                 }
 866         }
 867
 868         /* if we're running close to normal speed and there isn't enough
 869            space to do disk_read_chunk_frames of I/O, then don't bother.
 870
 871            at higher speeds, just do it because the sync between butler
 872            and audio thread may not be good enough.
 873
 874            Note: it is a design assumption that disk_read_chunk_frames is smaller
 875            than the playback buffer size, so this check should never trip when
 876            the playback buffer is empty.
 877         */
 878
 879         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: space to refill %2 vs. chunk %3 (speed = %4)\n", name(), total_space, _chunk_frames, _session.transport_speed()));
 880         if ((total_space < _chunk_frames) && fabs (_session.transport_speed()) < 2.0f) {
 881                 return 0;
 882         }
 883
 884         /* when slaved, don't try to get too close to the read pointer. this
 885            leaves space for the buffer reversal to have something useful to
 886            work with.
 887         */
 888
 889         if (_slaved && total_space < (framecnt_t) (c->front()->buf->bufsize() / 2)) {
 890                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
 891                 return 0;
 892         }
 893
 894         if (reversed) {
 895
 896                 if (file_frame == 0) {
 897
 898                         /* at start: nothing to do but fill with silence */
 899
 900                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 901
 902                                 ChannelInfo* chan (*i);
 903                                 chan->buf->get_write_vector (&vector);
 904                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 905                                 if (vector.len[1]) {
 906                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 907                                 }
 908                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 909                         }
 910                         return 0;
 911                 }
 912
 913                 if (file_frame < total_space) {
 914
 915                         /* too close to the start: read what we can,
 916                            and then zero fill the rest
 917                         */
 918
 919                         zero_fill = total_space - file_frame;
 920                         total_space = file_frame;
 921
 922                 } else {
 923
 924                         zero_fill = 0;
 925                 }
 926
 927         } else {
 928
 929                 if (file_frame == max_framepos) {
 930
 931                         /* at end: nothing to do but fill with silence */
 932
 933                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 934
 935                                 ChannelInfo* chan (*i);
 936                                 chan->buf->get_write_vector (&vector);
 937                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 938                                 if (vector.len[1]) {
 939                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 940                                 }
 941                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 942                         }
 943                         return 0;
 944                 }
 945
 946                 if (file_frame > max_framepos - total_space) {
 947
 948                         /* to close to the end: read what we can, and zero fill the rest */
 949
 950                         zero_fill = total_space - (max_framepos - file_frame);
 951                         total_space = max_framepos - file_frame;
 952
 953                 } else {
 954                         zero_fill = 0;
 955                 }
 956         }
 957
 958         framepos_t file_frame_tmp = 0;
 959
 960         /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
 961
 962         const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
 963         size_t total_bytes = total_space * bits_per_sample / 8;
 964
 965         /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
 966          */
 967         size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
 968
 969         /* find nearest (lower) multiple of 16384 */
 970
 971         byte_size_for_read = (byte_size_for_read / 16384) * 16384;
 972
 973         /* now back to samples */
 974
 975         framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
 976
 977         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
 978
 979         // uint64_t before = g_get_monotonic_time ();
 980         // uint64_t elapsed;
 981
 982         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 983
 984                 ChannelInfo* chan (*i);
 985                 Sample* buf1;
 986                 Sample* buf2;
 987                 framecnt_t len1, len2;
 988
 989                 chan->buf->get_write_vector (&vector);
 990
 991                 if ((framecnt_t) vector.len[0] > samples_to_read) {
 992
 993                         /* we're not going to fill the first chunk, so certainly do not bother with the
 994                            other part. it won't be connected with the part we do fill, as in:
 995
 996                            .... => writable space
 997                            ++++ => readable space
 998                            ^^^^ => 1 x disk_read_chunk_frames that would be filled
 999
1000                            |......|+++++++++++++|...............................|
1001                            buf1                buf0
1002                                                 ^^^^^^^^^^^^^^^
1003
1004
1005                            So, just pretend that the buf1 part isn't there.
1006
1007                         */
1008
1009                         vector.buf[1] = 0;
1010                         vector.len[1] = 0;
1011
1012                 }
1013
1014                 ts = total_space;
1015                 file_frame_tmp = file_frame;
1016
1017                 buf1 = vector.buf[0];
1018                 len1 = vector.len[0];
1019                 buf2 = vector.buf[1];
1020                 len2 = vector.len[1];
1021
1022                 to_read = min (ts, len1);
1023                 to_read = min (to_read, (framecnt_t) samples_to_read);
1024
1025                 assert (to_read >= 0);
1026
1027                 if (to_read) {
1028
1029                         if (audio_read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1030                                 ret = -1;
1031                                 goto out;
1032                         }
1033
1034                         chan->buf->increment_write_ptr (to_read);
1035                         ts -= to_read;
1036                 }
1037
1038                 to_read = min (ts, len2);
1039
1040                 if (to_read) {
1041
1042                         /* we read all of vector.len[0], but it wasn't the
1043                            entire samples_to_read of data, so read some or
1044                            all of vector.len[1] as well.
1045                         */
1046
1047                         if (audio_read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1048                                 ret = -1;
1049                                 goto out;
1050                         }
1051
1052                         chan->buf->increment_write_ptr (to_read);
1053                 }
1054
1055                 if (zero_fill) {
1056                         /* XXX: do something */
1057                 }
1058
1059         }
1060
1061         // elapsed = g_get_monotonic_time () - before;
1062         // cerr << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1063
1064         file_frame = file_frame_tmp;
1065         assert (file_frame >= 0);
1066
1067         ret = ((total_space - samples_to_read) > _chunk_frames);
1068
1069         c->front()->buf->get_write_vector (&vector);
1070
1071   out:
1072         return ret;
1073 }
1074
1075 void
1076 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<framepos_t> > const & movements_frames, bool from_undo)
1077 {
1078         /* If we're coming from an undo, it will have handled
1079            automation undo (it must, since automation-follows-regions
1080            can lose automation data).  Hence we can do nothing here.
1081         */
1082
1083         if (from_undo) {
1084                 return;
1085         }
1086
1087         if (!_route || Config->get_automation_follows_regions () == false) {
1088                 return;
1089         }
1090
1091         list< Evoral::RangeMove<double> > movements;
1092
1093         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin();
1094              i != movements_frames.end();
1095              ++i) {
1096
1097                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1098         }
1099
1100         /* move panner automation */
1101         boost::shared_ptr<Pannable> pannable = _route->pannable();
1102         Evoral::ControlSet::Controls& c (pannable->controls());
1103
1104         for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1105                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1106                 if (!ac) {
1107                         continue;
1108                 }
1109                 boost::shared_ptr<AutomationList> alist = ac->alist();
1110                 if (!alist->size()) {
1111                         continue;
1112                 }
1113                 XMLNode & before = alist->get_state ();
1114                 bool const things_moved = alist->move_ranges (movements);
1115                 if (things_moved) {
1116                         _session.add_command (new MementoCommand<AutomationList> (
1117                                                       *alist.get(), &before, &alist->get_state ()));
1118                 }
1119         }
1120         /* move processor automation */
1121         _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_frames));
1122 }
1123
1124 void
1125 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<framepos_t> > const & movements_frames)
1126 {
1127         boost::shared_ptr<Processor> processor (p.lock ());
1128         if (!processor) {
1129                 return;
1130         }
1131
1132         list< Evoral::RangeMove<double> > movements;
1133         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) {
1134                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1135         }
1136
1137         set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1138
1139         for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1140                 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1141                 if (!al->size()) {
1142                         continue;
1143                 }
1144                 XMLNode & before = al->get_state ();
1145                 bool const things_moved = al->move_ranges (movements);
1146                 if (things_moved) {
1147                         _session.add_command (
1148                                 new MementoCommand<AutomationList> (
1149                                         *al.get(), &before, &al->get_state ()
1150                                         )
1151                                 );
1152                 }
1153         }
1154 }
1155
1156 boost::shared_ptr<MidiBuffer>
1157 DiskReader::get_gui_feed_buffer () const
1158 {
1159         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1160
1161         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1162         b->copy (_gui_feed_buffer);
1163         return b;
1164 }
1165
1166 void
1167 DiskReader::reset_tracker ()
1168 {
1169         _midi_buf->reset_tracker ();
1170
1171         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1172
1173         if (mp) {
1174                 mp->reset_note_trackers ();
1175         }
1176 }
1177
1178 void
1179 DiskReader::resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time)
1180 {
1181         _midi_buf->resolve_tracker(buffer, time);
1182
1183         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1184
1185         if (mp) {
1186                 mp->reset_note_trackers ();
1187         }
1188 }
1189
1190 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1191  *  so that an event at playback_sample has time = 0
1192  */
1193 void
1194 DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState ms, BufferSet& scratch_bufs, double speed, framecnt_t playback_distance)
1195 {
1196         MidiBuffer* target;
1197
1198         if ((ms & MonitoringInput) == 0) {
1199                 dst.clear();
1200                 target = &dst;
1201         } else {
1202                 target = &scratch_bufs.get_midi (0);
1203         }
1204
1205         if (ms & MonitoringDisk) {
1206                 /* no disk data needed */
1207
1208                 Location* loc = loop_location;
1209
1210                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1211                                      "%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name,
1212                                      _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1213                                      (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes, Port::port_offset()));
1214
1215                 //cerr << "======== PRE ========\n";
1216                 //_midi_buf->dump (cerr);
1217                 //cerr << "----------------\n";
1218
1219                 size_t events_read = 0;
1220
1221                 if (loc) {
1222                         framepos_t effective_start;
1223
1224                         Evoral::Range<framepos_t> loop_range (loc->start(), loc->end() - 1);
1225                         effective_start = loop_range.squish (playback_sample);
1226
1227                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1228
1229                         if (effective_start == loc->start()) {
1230                                 /* We need to turn off notes that may extend
1231                                    beyond the loop end.
1232                                 */
1233
1234                                 _midi_buf->resolve_tracker (*target, 0);
1235                         }
1236
1237                         /* for split-cycles we need to offset the events */
1238
1239                         if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1240
1241                                 /* end of loop is within the range we are reading, so
1242                                    split the read in two, and lie about the location
1243                                    for the 2nd read
1244                                 */
1245
1246                                 framecnt_t first, second;
1247
1248                                 first = loc->end() - effective_start;
1249                                 second = nframes - first;
1250
1251                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n",
1252                                                                                       effective_start, loc->end(), first, second));
1253
1254                                 if (first) {
1255                                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1256                                                                                               effective_start, first));
1257                                         events_read = _midi_buf->read (*target, effective_start, first);
1258                                 }
1259
1260                                 if (second) {
1261                                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1262                                                                                               loc->start(), second));
1263                                         events_read += _midi_buf->read (*target, loc->start(), second);
1264                                 }
1265
1266                         } else {
1267                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1268                                                                                       effective_start, nframes));
1269                                 events_read = _midi_buf->read (*target, effective_start, effective_start + nframes);
1270                         }
1271                 } else {
1272                         const size_t n_skipped = _midi_buf->skip_to (playback_sample);
1273                         if (n_skipped > 0) {
1274                                 warning << string_compose(_("MidiDiskstream %1: skipped %2 events, possible underflow"), id(), n_skipped) << endmsg;
1275                         }
1276                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("playback buffer read, from %1 to %2 (%3)", playback_sample, playback_sample + nframes, nframes));
1277                         events_read = _midi_buf->read (*target, playback_sample, playback_sample + nframes);
1278                 }
1279
1280                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1281                                      "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1282                                      _name, events_read, playback_sample, playback_sample + nframes,
1283                                      _midi_buf->read_space(), _midi_buf->write_space(),
1284                                      _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr()));
1285         }
1286
1287         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1288
1289         /* vari-speed */
1290
1291         if (speed != 0.0 && fabsf (speed) != 1.0f) {
1292                 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1293                         MidiBuffer::TimeType *tme = i.timeptr();
1294                         *tme = (*tme) * nframes / playback_distance;
1295                 }
1296         }
1297
1298         if (ms & MonitoringInput) {
1299                 dst.merge_from (*target, nframes);
1300         }
1301
1302         //cerr << "======== POST ========\n";
1303         //_midi_buf->dump (cerr);
1304         //cerr << "----------------\n";
1305 }
1306
1307 /** @a start is set to the new frame position (TIME) read up to */
1308 int
1309 DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed)
1310 {
1311         framecnt_t this_read   = 0;
1312         framepos_t loop_end    = 0;
1313         framepos_t loop_start  = 0;
1314         framecnt_t loop_length = 0;
1315         Location*  loc         = loop_location;
1316         framepos_t effective_start = start;
1317         Evoral::Range<framepos_t>*  loop_range (0);
1318
1319 //      MidiTrack*         mt     = dynamic_cast<MidiTrack*>(_track);
1320 //      MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0;
1321         MidiChannelFilter* filter = 0;
1322
1323         frameoffset_t loop_offset = 0;
1324
1325         if (!reversed && loc) {
1326                 get_location_times (loc, &loop_start, &loop_end, &loop_length);
1327         }
1328
1329         while (dur) {
1330
1331                 /* take any loop into account. we can't read past the end of the loop. */
1332
1333                 if (loc && !reversed) {
1334
1335                         if (!loop_range) {
1336                                 loop_range = new Evoral::Range<framepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
1337                         }
1338
1339                         /* if we are (seamlessly) looping, ensure that the first frame we read is at the correct
1340                            position within the loop.
1341                         */
1342
1343                         effective_start = loop_range->squish (effective_start);
1344
1345                         if ((loop_end - effective_start) <= dur) {
1346                                 /* too close to end of loop to read "dur", so
1347                                    shorten it.
1348                                 */
1349                                 this_read = loop_end - effective_start;
1350                         } else {
1351                                 this_read = dur;
1352                         }
1353
1354                 } else {
1355                         this_read = dur;
1356                 }
1357
1358                 if (this_read == 0) {
1359                         break;
1360                 }
1361
1362                 this_read = min (dur,this_read);
1363
1364                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset));
1365
1366                 if (midi_playlist()->read (*_midi_buf, effective_start, this_read, loop_range, 0, filter) != this_read) {
1367                         error << string_compose(
1368                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
1369                                         id(), this_read, start) << endmsg;
1370                         return -1;
1371                 }
1372
1373                 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
1374
1375                 if (reversed) {
1376
1377                         // Swap note ons with note offs here.  etc?
1378                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
1379                         // CC values etc.  hard.
1380
1381                 } else {
1382
1383                         /* adjust passed-by-reference argument (note: this is
1384                            monotonic and does not reflect looping.
1385                         */
1386                         start += this_read;
1387
1388                         /* similarly adjust effective_start, but this may be
1389                            readjusted for seamless looping as we continue around
1390                            the loop.
1391                         */
1392                         effective_start += this_read;
1393                 }
1394
1395                 dur -= this_read;
1396                 //offset += this_read;
1397         }
1398
1399         return 0;
1400 }
1401
1402 int
1403 DiskReader::refill_midi ()
1404 {
1405         if (!_playlists[DataType::MIDI]) {
1406                 return 0;
1407         }
1408
1409         size_t  write_space = _midi_buf->write_space();
1410         const bool reversed    = _session.transport_speed() < 0.0f;
1411
1412         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file frame = %2\n", write_space, file_frame));
1413
1414         /* no space to write */
1415         if (write_space == 0) {
1416                 return 0;
1417         }
1418
1419         if (reversed) {
1420                 return 0;
1421         }
1422
1423         /* at end: nothing to do */
1424
1425         if (file_frame == max_framepos) {
1426                 return 0;
1427         }
1428
1429         int ret = 0;
1430         const uint32_t frames_read = g_atomic_int_get (&_frames_read_from_ringbuffer);
1431         const uint32_t frames_written = g_atomic_int_get (&_frames_written_to_ringbuffer);
1432
1433         if ((frames_read < frames_written) && (frames_written - frames_read) >= midi_readahead) {
1434                 return 0;
1435         }
1436
1437         framecnt_t to_read = midi_readahead - ((framecnt_t)frames_written - (framecnt_t)frames_read);
1438
1439         to_read = min (to_read, (framecnt_t) (max_framepos - file_frame));
1440         to_read = min (to_read, (framecnt_t) write_space);
1441
1442         if (midi_read (file_frame, to_read, reversed)) {
1443                 ret = -1;
1444         }
1445
1446         return ret;
1447 }