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                         MidiBuffer& mbuf (bufs.get_midi (0));
 378                         get_playback (mbuf, playback_distance, ms, scratch_bufs, speed, playback_distance);
 379                 }
 380         }
 381
 382         if (speed < 0.0) {
 383                 playback_sample -= playback_distance;
 384         } else {
 385                 playback_sample += playback_distance;
 386         }
 387
 388         if (_playlists[DataType::AUDIO]) {
 389                 if (!c->empty()) {
 390                         if (_slaved) {
 391                                 if (c->front()->buf->write_space() >= c->front()->buf->bufsize() / 2) {
 392                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 393                                                                                     c->front()->buf->bufsize()));
 394                                         _need_butler = true;
 395                                 }
 396                         } else {
 397                                 if ((framecnt_t) c->front()->buf->write_space() >= _chunk_frames) {
 398                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 399                                                                                     _chunk_frames));
 400                                         _need_butler = true;
 401                                 }
 402                         }
 403                 }
 404         }
 405
 406         if (_playlists[DataType::MIDI]) {
 407                 /* MIDI butler needed part */
 408
 409                 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
 410                 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
 411
 412                 /*
 413                   cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
 414                   " = " << frames_written - frames_read
 415                   << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
 416                 */
 417
 418                 /* frames_read will generally be less than frames_written, but
 419                  * immediately after an overwrite, we can end up having read some data
 420                  * before we've written any. we don't need to trip an assert() on this,
 421                  * but we do need to check so that the decision on whether or not we
 422                  * need the butler is done correctly.
 423                  */
 424
 425                 /* furthermore..
 426                  *
 427                  * Doing heavy GUI operations[1] can stall also the butler.
 428                  * The RT-thread meanwhile will happily continue and
 429                  * ‘frames_read’ (from buffer to output) will become larger
 430                  * than ‘frames_written’ (from disk to buffer).
 431                  *
 432                  * The disk-stream is now behind..
 433                  *
 434                  * In those cases the butler needs to be summed to refill the buffer (done now)
 435                  * AND we need to skip (frames_read - frames_written). ie remove old events
 436                  * before playback_sample from the rinbuffer.
 437                  *
 438                  * [1] one way to do so is described at #6170.
 439                  * For me just popping up the context-menu on a MIDI-track header
 440                  * of a track with a large (think beethoven :) midi-region also did the
 441                  * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
 442                  *
 443                  * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
 444                  * and can stall
 445                  */
 446                 if (frames_read <= frames_written) {
 447                         if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 448                                 _need_butler = true;
 449                         }
 450                 } else {
 451                         _need_butler = true;
 452                 }
 453
 454         }
 455
 456         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
 457 }
 458
 459 void
 460 DiskReader::set_pending_overwrite (bool yn)
 461 {
 462         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 463
 464         _pending_overwrite = yn;
 465
 466         overwrite_frame = playback_sample;
 467
 468         boost::shared_ptr<ChannelList> c = channels.reader ();
 469         if (!c->empty ()) {
 470                 overwrite_offset = c->front()->buf->get_read_ptr();
 471         }
 472 }
 473
 474 int
 475 DiskReader::overwrite_existing_buffers ()
 476 {
 477         int ret = -1;
 478
 479         boost::shared_ptr<ChannelList> c = channels.reader();
 480
 481         overwrite_queued = false;
 482
 483         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_frame));
 484
 485         if (!c->empty ()) {
 486
 487                 /* AUDIO */
 488
 489                 const bool reversed = _session.transport_speed() < 0.0f;
 490
 491                 /* assume all are the same size */
 492                 framecnt_t size = c->front()->buf->bufsize();
 493
 494                 std::auto_ptr<Sample> mixdown_buffer (new Sample[size]);
 495                 std::auto_ptr<float> gain_buffer (new float[size]);
 496
 497                 /* reduce size so that we can fill the buffer correctly (ringbuffers
 498                    can only handle size-1, otherwise they appear to be empty)
 499                 */
 500                 size--;
 501
 502                 uint32_t n=0;
 503                 framepos_t start;
 504
 505                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 506
 507                         start = overwrite_frame;
 508                         framecnt_t cnt = size;
 509
 510                         /* to fill the buffer without resetting the playback sample, we need to
 511                            do it one or two chunks (normally two).
 512
 513                            |----------------------------------------------------------------------|
 514
 515                            ^
 516                            overwrite_offset
 517                            |<- second chunk->||<----------------- first chunk ------------------>|
 518
 519                         */
 520
 521                         framecnt_t to_read = size - overwrite_offset;
 522
 523                         if (audio_read ((*chan)->buf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
 524                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 525                                                         id(), size, playback_sample) << endmsg;
 526                                 goto midi;
 527                         }
 528
 529                         if (cnt > to_read) {
 530
 531                                 cnt -= to_read;
 532
 533                                 if (audio_read ((*chan)->buf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
 534                                         error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 535                                                                 id(), size, playback_sample) << endmsg;
 536                                         goto midi;
 537                                 }
 538                         }
 539                 }
 540
 541                 ret = 0;
 542
 543         }
 544
 545   midi:
 546
 547         if (_midi_buf && _playlists[DataType::MIDI]) {
 548
 549                 /* Clear the playback buffer contents.  This is safe as long as the butler
 550                    thread is suspended, which it should be.
 551                 */
 552                 _midi_buf->reset ();
 553                 _midi_buf->reset_tracker ();
 554
 555                 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 556                 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 557
 558                 /* Resolve all currently active notes in the playlist.  This is more
 559                    aggressive than it needs to be: ideally we would only resolve what is
 560                    absolutely necessary, but this seems difficult and/or impossible without
 561                    having the old data or knowing what change caused the overwrite.
 562                 */
 563                 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_frame);
 564
 565                 midi_read (overwrite_frame, _chunk_frames, false);
 566
 567                 file_frame = overwrite_frame; // it was adjusted by ::midi_read()
 568         }
 569
 570         _pending_overwrite = false;
 571
 572         return ret;
 573 }
 574
 575 int
 576 DiskReader::seek (framepos_t frame, bool complete_refill)
 577 {
 578         uint32_t n;
 579         int ret = -1;
 580         ChannelList::iterator chan;
 581         boost::shared_ptr<ChannelList> c = channels.reader();
 582
 583         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 584                 (*chan)->buf->reset ();
 585         }
 586
 587         if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
 588                 /* we haven't read anything since the last seek,
 589                    so flush all note trackers to prevent
 590                    wierdness
 591                 */
 592                 reset_tracker ();
 593         }
 594
 595         _midi_buf->reset();
 596         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 597         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 598
 599         playback_sample = frame;
 600         file_frame = frame;
 601
 602         if (complete_refill) {
 603                 /* call _do_refill() to refill the entire buffer, using
 604                    the largest reads possible.
 605                 */
 606                 while ((ret = do_refill_with_alloc (false)) > 0) ;
 607         } else {
 608                 /* call _do_refill() to refill just one chunk, and then
 609                    return.
 610                 */
 611                 ret = do_refill_with_alloc (true);
 612         }
 613
 614
 615         return ret;
 616 }
 617
 618 int
 619 DiskReader::can_internal_playback_seek (framecnt_t distance)
 620 {
 621         /* 1. Audio */
 622
 623         ChannelList::iterator chan;
 624         boost::shared_ptr<ChannelList> c = channels.reader();
 625
 626         for (chan = c->begin(); chan != c->end(); ++chan) {
 627                 if ((*chan)->buf->read_space() < (size_t) distance) {
 628                         return false;
 629                 }
 630         }
 631
 632         /* 2. MIDI */
 633
 634         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 635         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 636
 637         return ((frames_written - frames_read) < distance);
 638 }
 639
 640 int
 641 DiskReader::internal_playback_seek (framecnt_t distance)
 642 {
 643         ChannelList::iterator chan;
 644         boost::shared_ptr<ChannelList> c = channels.reader();
 645
 646         for (chan = c->begin(); chan != c->end(); ++chan) {
 647                 (*chan)->buf->increment_read_ptr (::llabs(distance));
 648         }
 649
 650         playback_sample += distance;
 651
 652         return 0;
 653 }
 654
 655 static
 656 void swap_by_ptr (Sample *first, Sample *last)
 657 {
 658         while (first < last) {
 659                 Sample tmp = *first;
 660                 *first++ = *last;
 661                 *last-- = tmp;
 662         }
 663 }
 664
 665 /** Read some data for 1 channel from our playlist into a buffer.
 666  *  @param buf Buffer to write to.
 667  *  @param start Session frame to start reading from; updated to where we end up
 668  *         after the read.
 669  *  @param cnt Count of samples to read.
 670  *  @param reversed true if we are running backwards, otherwise false.
 671  */
 672 int
 673 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 674                         framepos_t& start, framecnt_t cnt,
 675                         int channel, bool reversed)
 676 {
 677         framecnt_t this_read = 0;
 678         bool reloop = false;
 679         framepos_t loop_end = 0;
 680         framepos_t loop_start = 0;
 681         framecnt_t offset = 0;
 682         Location *loc = 0;
 683
 684         if (!_playlists[DataType::AUDIO]) {
 685                 memset (buf, 0, sizeof (Sample) * cnt);
 686                 return 0;
 687         }
 688
 689         /* XXX we don't currently play loops in reverse. not sure why */
 690
 691         if (!reversed) {
 692
 693                 framecnt_t loop_length = 0;
 694
 695                 /* Make the use of a Location atomic for this read operation.
 696
 697                    Note: Locations don't get deleted, so all we care about
 698                    when I say "atomic" is that we are always pointing to
 699                    the same one and using a start/length values obtained
 700                    just once.
 701                 */
 702
 703                 if ((loc = loop_location) != 0) {
 704                         loop_start = loc->start();
 705                         loop_end = loc->end();
 706                         loop_length = loop_end - loop_start;
 707                 }
 708
 709                 /* if we are looping, ensure that the first frame we read is at the correct
 710                    position within the loop.
 711                 */
 712
 713                 if (loc && start >= loop_end) {
 714                         start = loop_start + ((start - loop_start) % loop_length);
 715                 }
 716
 717         }
 718
 719         if (reversed) {
 720                 start -= cnt;
 721         }
 722
 723         /* We need this while loop in case we hit a loop boundary, in which case our read from
 724            the playlist must be split into more than one section.
 725         */
 726
 727         while (cnt) {
 728
 729                 /* take any loop into account. we can't read past the end of the loop. */
 730
 731                 if (loc && (loop_end - start < cnt)) {
 732                         this_read = loop_end - start;
 733                         reloop = true;
 734                 } else {
 735                         reloop = false;
 736                         this_read = cnt;
 737                 }
 738
 739                 if (this_read == 0) {
 740                         break;
 741                 }
 742
 743                 this_read = min(cnt,this_read);
 744
 745                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 746                         error << string_compose(_("DiskReader %1: cannot read %2 from playlist at frame %3"), id(), this_read,
 747                                          start) << endmsg;
 748                         return -1;
 749                 }
 750
 751                 if (reversed) {
 752
 753                         swap_by_ptr (buf, buf + this_read - 1);
 754
 755                 } else {
 756
 757                         /* if we read to the end of the loop, go back to the beginning */
 758
 759                         if (reloop) {
 760                                 start = loop_start;
 761                         } else {
 762                                 start += this_read;
 763                         }
 764                 }
 765
 766                 cnt -= this_read;
 767                 offset += this_read;
 768         }
 769
 770         return 0;
 771 }
 772
 773 int
 774 DiskReader::_do_refill_with_alloc (bool partial_fill)
 775 {
 776         /* We limit disk reads to at most 4MB chunks, which with floating point
 777            samples would be 1M samples. But we might use 16 or 14 bit samples,
 778            in which case 4MB is more samples than that. Therefore size this for
 779            the smallest sample value .. 4MB = 2M samples (16 bit).
 780         */
 781
 782         {
 783                 std::auto_ptr<Sample> mix_buf (new Sample[2*1048576]);
 784                 std::auto_ptr<float>  gain_buf (new float[2*1048576]);
 785
 786                 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_frames : 0));
 787
 788                 if (ret) {
 789                         return ret;
 790                 }
 791         }
 792
 793         return refill_midi ();
 794 }
 795
 796 int
 797 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 798 {
 799         int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
 800
 801         if (ret) {
 802                 return ret;
 803         }
 804
 805         return refill_midi ();
 806 }
 807
 808
 809 /** Get some more data from disk and put it in our channels' bufs,
 810  *  if there is suitable space in them.
 811  *
 812  * If fill_level is non-zero, then we will refill the buffer so that there is
 813  * still at least fill_level samples of space left to be filled. This is used
 814  * after locates so that we do not need to wait to fill the entire buffer.
 815  *
 816  */
 817
 818 int
 819 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 820 {
 821         /* do not read from disk while session is marked as Loading, to avoid
 822            useless redundant I/O.
 823         */
 824
 825         if (_session.loading()) {
 826                 return 0;
 827         }
 828
 829         int32_t ret = 0;
 830         framecnt_t to_read;
 831         RingBufferNPT<Sample>::rw_vector vector;
 832         bool const reversed = _session.transport_speed() < 0.0f;
 833         framecnt_t total_space;
 834         framecnt_t zero_fill;
 835         uint32_t chan_n;
 836         ChannelList::iterator i;
 837         boost::shared_ptr<ChannelList> c = channels.reader();
 838         framecnt_t ts;
 839
 840         if (c->empty()) {
 841                 return 0;
 842         }
 843
 844         assert(mixdown_buffer);
 845         assert(gain_buffer);
 846
 847         vector.buf[0] = 0;
 848         vector.len[0] = 0;
 849         vector.buf[1] = 0;
 850         vector.len[1] = 0;
 851
 852         c->front()->buf->get_write_vector (&vector);
 853
 854         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
 855                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
 856                 /* nowhere to write to */
 857                 return 0;
 858         }
 859
 860         if (fill_level) {
 861                 if (fill_level < total_space) {
 862                         total_space -= fill_level;
 863                 } else {
 864                         /* we can't do anything with it */
 865                         fill_level = 0;
 866                 }
 867         }
 868
 869         /* if we're running close to normal speed and there isn't enough
 870            space to do disk_read_chunk_frames of I/O, then don't bother.
 871
 872            at higher speeds, just do it because the sync between butler
 873            and audio thread may not be good enough.
 874
 875            Note: it is a design assumption that disk_read_chunk_frames is smaller
 876            than the playback buffer size, so this check should never trip when
 877            the playback buffer is empty.
 878         */
 879
 880         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()));
 881         if ((total_space < _chunk_frames) && fabs (_session.transport_speed()) < 2.0f) {
 882                 return 0;
 883         }
 884
 885         /* when slaved, don't try to get too close to the read pointer. this
 886            leaves space for the buffer reversal to have something useful to
 887            work with.
 888         */
 889
 890         if (_slaved && total_space < (framecnt_t) (c->front()->buf->bufsize() / 2)) {
 891                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
 892                 return 0;
 893         }
 894
 895         if (reversed) {
 896
 897                 if (file_frame == 0) {
 898
 899                         /* at start: nothing to do but fill with silence */
 900
 901                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 902
 903                                 ChannelInfo* chan (*i);
 904                                 chan->buf->get_write_vector (&vector);
 905                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 906                                 if (vector.len[1]) {
 907                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 908                                 }
 909                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 910                         }
 911                         return 0;
 912                 }
 913
 914                 if (file_frame < total_space) {
 915
 916                         /* too close to the start: read what we can,
 917                            and then zero fill the rest
 918                         */
 919
 920                         zero_fill = total_space - file_frame;
 921                         total_space = file_frame;
 922
 923                 } else {
 924
 925                         zero_fill = 0;
 926                 }
 927
 928         } else {
 929
 930                 if (file_frame == max_framepos) {
 931
 932                         /* at end: nothing to do but fill with silence */
 933
 934                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 935
 936                                 ChannelInfo* chan (*i);
 937                                 chan->buf->get_write_vector (&vector);
 938                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 939                                 if (vector.len[1]) {
 940                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 941                                 }
 942                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 943                         }
 944                         return 0;
 945                 }
 946
 947                 if (file_frame > max_framepos - total_space) {
 948
 949                         /* to close to the end: read what we can, and zero fill the rest */
 950
 951                         zero_fill = total_space - (max_framepos - file_frame);
 952                         total_space = max_framepos - file_frame;
 953
 954                 } else {
 955                         zero_fill = 0;
 956                 }
 957         }
 958
 959         framepos_t file_frame_tmp = 0;
 960
 961         /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
 962
 963         const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
 964         size_t total_bytes = total_space * bits_per_sample / 8;
 965
 966         /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
 967          */
 968         size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
 969
 970         /* find nearest (lower) multiple of 16384 */
 971
 972         byte_size_for_read = (byte_size_for_read / 16384) * 16384;
 973
 974         /* now back to samples */
 975
 976         framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
 977
 978         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
 979
 980         // uint64_t before = g_get_monotonic_time ();
 981         // uint64_t elapsed;
 982
 983         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 984
 985                 ChannelInfo* chan (*i);
 986                 Sample* buf1;
 987                 Sample* buf2;
 988                 framecnt_t len1, len2;
 989
 990                 chan->buf->get_write_vector (&vector);
 991
 992                 if ((framecnt_t) vector.len[0] > samples_to_read) {
 993
 994                         /* we're not going to fill the first chunk, so certainly do not bother with the
 995                            other part. it won't be connected with the part we do fill, as in:
 996
 997                            .... => writable space
 998                            ++++ => readable space
 999                            ^^^^ => 1 x disk_read_chunk_frames that would be filled
1000
1001                            |......|+++++++++++++|...............................|
1002                            buf1                buf0
1003                                                 ^^^^^^^^^^^^^^^
1004
1005
1006                            So, just pretend that the buf1 part isn't there.
1007
1008                         */
1009
1010                         vector.buf[1] = 0;
1011                         vector.len[1] = 0;
1012
1013                 }
1014
1015                 ts = total_space;
1016                 file_frame_tmp = file_frame;
1017
1018                 buf1 = vector.buf[0];
1019                 len1 = vector.len[0];
1020                 buf2 = vector.buf[1];
1021                 len2 = vector.len[1];
1022
1023                 to_read = min (ts, len1);
1024                 to_read = min (to_read, (framecnt_t) samples_to_read);
1025
1026                 assert (to_read >= 0);
1027
1028                 if (to_read) {
1029
1030                         if (audio_read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1031                                 ret = -1;
1032                                 goto out;
1033                         }
1034
1035                         chan->buf->increment_write_ptr (to_read);
1036                         ts -= to_read;
1037                 }
1038
1039                 to_read = min (ts, len2);
1040
1041                 if (to_read) {
1042
1043                         /* we read all of vector.len[0], but it wasn't the
1044                            entire samples_to_read of data, so read some or
1045                            all of vector.len[1] as well.
1046                         */
1047
1048                         if (audio_read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1049                                 ret = -1;
1050                                 goto out;
1051                         }
1052
1053                         chan->buf->increment_write_ptr (to_read);
1054                 }
1055
1056                 if (zero_fill) {
1057                         /* XXX: do something */
1058                 }
1059
1060         }
1061
1062         // elapsed = g_get_monotonic_time () - before;
1063         // cerr << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1064
1065         file_frame = file_frame_tmp;
1066         assert (file_frame >= 0);
1067
1068         ret = ((total_space - samples_to_read) > _chunk_frames);
1069
1070         c->front()->buf->get_write_vector (&vector);
1071
1072   out:
1073         return ret;
1074 }
1075
1076 void
1077 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<framepos_t> > const & movements_frames, bool from_undo)
1078 {
1079         /* If we're coming from an undo, it will have handled
1080            automation undo (it must, since automation-follows-regions
1081            can lose automation data).  Hence we can do nothing here.
1082         */
1083
1084         if (from_undo) {
1085                 return;
1086         }
1087
1088         if (!_route || Config->get_automation_follows_regions () == false) {
1089                 return;
1090         }
1091
1092         list< Evoral::RangeMove<double> > movements;
1093
1094         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin();
1095              i != movements_frames.end();
1096              ++i) {
1097
1098                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1099         }
1100
1101         /* move panner automation */
1102         boost::shared_ptr<Pannable> pannable = _route->pannable();
1103         Evoral::ControlSet::Controls& c (pannable->controls());
1104
1105         for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1106                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1107                 if (!ac) {
1108                         continue;
1109                 }
1110                 boost::shared_ptr<AutomationList> alist = ac->alist();
1111                 if (!alist->size()) {
1112                         continue;
1113                 }
1114                 XMLNode & before = alist->get_state ();
1115                 bool const things_moved = alist->move_ranges (movements);
1116                 if (things_moved) {
1117                         _session.add_command (new MementoCommand<AutomationList> (
1118                                                       *alist.get(), &before, &alist->get_state ()));
1119                 }
1120         }
1121         /* move processor automation */
1122         _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_frames));
1123 }
1124
1125 void
1126 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<framepos_t> > const & movements_frames)
1127 {
1128         boost::shared_ptr<Processor> processor (p.lock ());
1129         if (!processor) {
1130                 return;
1131         }
1132
1133         list< Evoral::RangeMove<double> > movements;
1134         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) {
1135                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1136         }
1137
1138         set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1139
1140         for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1141                 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1142                 if (!al->size()) {
1143                         continue;
1144                 }
1145                 XMLNode & before = al->get_state ();
1146                 bool const things_moved = al->move_ranges (movements);
1147                 if (things_moved) {
1148                         _session.add_command (
1149                                 new MementoCommand<AutomationList> (
1150                                         *al.get(), &before, &al->get_state ()
1151                                         )
1152                                 );
1153                 }
1154         }
1155 }
1156
1157 boost::shared_ptr<MidiBuffer>
1158 DiskReader::get_gui_feed_buffer () const
1159 {
1160         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1161
1162         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1163         b->copy (_gui_feed_buffer);
1164         return b;
1165 }
1166
1167 void
1168 DiskReader::reset_tracker ()
1169 {
1170         _midi_buf->reset_tracker ();
1171
1172         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1173
1174         if (mp) {
1175                 mp->reset_note_trackers ();
1176         }
1177 }
1178
1179 void
1180 DiskReader::resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time)
1181 {
1182         _midi_buf->resolve_tracker(buffer, time);
1183
1184         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1185
1186         if (mp) {
1187                 mp->reset_note_trackers ();
1188         }
1189 }
1190
1191 void
1192 DiskReader::flush_playback (framepos_t start, framepos_t end)
1193 {
1194         _midi_buf->flush (start, end);
1195         g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1196 }
1197
1198 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1199  *  so that an event at playback_sample has time = 0
1200  */
1201 void
1202 DiskReader::get_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState ms, BufferSet& scratch_bufs, double speed, framecnt_t playback_distance)
1203 {
1204         MidiBuffer* target;
1205
1206         if ((ms & MonitoringInput) == 0) {
1207                 dst.clear();
1208                 target = &dst;
1209         } else {
1210                 target = &scratch_bufs.get_midi (0);
1211         }
1212
1213         if (ms & MonitoringDisk) {
1214                 /* no disk data needed */
1215
1216                 Location* loc = loop_location;
1217
1218                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1219                                      "%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name,
1220                                      _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1221                                      (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes, Port::port_offset()));
1222
1223                 //cerr << "======== PRE ========\n";
1224                 //_midi_buf->dump (cerr);
1225                 //cerr << "----------------\n";
1226
1227                 size_t events_read = 0;
1228
1229                 if (loc) {
1230                         framepos_t effective_start;
1231
1232                         Evoral::Range<framepos_t> loop_range (loc->start(), loc->end() - 1);
1233                         effective_start = loop_range.squish (playback_sample);
1234
1235                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1236
1237                         if (effective_start == loc->start()) {
1238                                 /* We need to turn off notes that may extend
1239                                    beyond the loop end.
1240                                 */
1241
1242                                 _midi_buf->resolve_tracker (*target, 0);
1243                         }
1244
1245                         /* for split-cycles we need to offset the events */
1246
1247                         if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1248
1249                                 /* end of loop is within the range we are reading, so
1250                                    split the read in two, and lie about the location
1251                                    for the 2nd read
1252                                 */
1253
1254                                 framecnt_t first, second;
1255
1256                                 first = loc->end() - effective_start;
1257                                 second = nframes - first;
1258
1259                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n",
1260                                                                                       effective_start, loc->end(), first, second));
1261
1262                                 if (first) {
1263                                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1264                                                                                               effective_start, first));
1265                                         events_read = _midi_buf->read (*target, effective_start, first);
1266                                 }
1267
1268                                 if (second) {
1269                                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1270                                                                                               loc->start(), second));
1271                                         events_read += _midi_buf->read (*target, loc->start(), second);
1272                                 }
1273
1274                         } else {
1275                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1276                                                                                       effective_start, nframes));
1277                                 events_read = _midi_buf->read (*target, effective_start, effective_start + nframes);
1278                         }
1279                 } else {
1280                         const size_t n_skipped = _midi_buf->skip_to (playback_sample);
1281                         if (n_skipped > 0) {
1282                                 warning << string_compose(_("MidiDiskstream %1: skipped %2 events, possible underflow"), id(), n_skipped) << endmsg;
1283                         }
1284                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("playback buffer read, from %1 to %2 (%3)", playback_sample, playback_sample + nframes, nframes));
1285                         events_read = _midi_buf->read (*target, playback_sample, playback_sample + nframes);
1286                 }
1287
1288                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1289                                      "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1290                                      _name, events_read, playback_sample, playback_sample + nframes,
1291                                      _midi_buf->read_space(), _midi_buf->write_space(),
1292                                      _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr()));
1293         }
1294
1295         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1296
1297         /* vari-speed */
1298
1299         if (speed != 0.0 && fabsf (speed) != 1.0f) {
1300                 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1301                         MidiBuffer::TimeType *tme = i.timeptr();
1302                         *tme = (*tme) * nframes / playback_distance;
1303                 }
1304         }
1305
1306         if (ms & MonitoringInput) {
1307                 dst.merge_from (*target, nframes);
1308         }
1309
1310         //cerr << "======== POST ========\n";
1311         //_midi_buf->dump (cerr);
1312         //cerr << "----------------\n";
1313 }
1314
1315 /** @a start is set to the new frame position (TIME) read up to */
1316 int
1317 DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed)
1318 {
1319         framecnt_t this_read   = 0;
1320         framepos_t loop_end    = 0;
1321         framepos_t loop_start  = 0;
1322         framecnt_t loop_length = 0;
1323         Location*  loc         = loop_location;
1324         framepos_t effective_start = start;
1325         Evoral::Range<framepos_t>*  loop_range (0);
1326
1327 //      MidiTrack*         mt     = dynamic_cast<MidiTrack*>(_track);
1328 //      MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0;
1329         MidiChannelFilter* filter = 0;
1330
1331         frameoffset_t loop_offset = 0;
1332
1333         if (!reversed && loc) {
1334                 get_location_times (loc, &loop_start, &loop_end, &loop_length);
1335         }
1336
1337         while (dur) {
1338
1339                 /* take any loop into account. we can't read past the end of the loop. */
1340
1341                 if (loc && !reversed) {
1342
1343                         if (!loop_range) {
1344                                 loop_range = new Evoral::Range<framepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
1345                         }
1346
1347                         /* if we are (seamlessly) looping, ensure that the first frame we read is at the correct
1348                            position within the loop.
1349                         */
1350
1351                         effective_start = loop_range->squish (effective_start);
1352
1353                         if ((loop_end - effective_start) <= dur) {
1354                                 /* too close to end of loop to read "dur", so
1355                                    shorten it.
1356                                 */
1357                                 this_read = loop_end - effective_start;
1358                         } else {
1359                                 this_read = dur;
1360                         }
1361
1362                 } else {
1363                         this_read = dur;
1364                 }
1365
1366                 if (this_read == 0) {
1367                         break;
1368                 }
1369
1370                 this_read = min (dur,this_read);
1371
1372                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset));
1373
1374                 if (midi_playlist()->read (*_midi_buf, effective_start, this_read, loop_range, 0, filter) != this_read) {
1375                         error << string_compose(
1376                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
1377                                         id(), this_read, start) << endmsg;
1378                         return -1;
1379                 }
1380
1381                 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
1382
1383                 if (reversed) {
1384
1385                         // Swap note ons with note offs here.  etc?
1386                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
1387                         // CC values etc.  hard.
1388
1389                 } else {
1390
1391                         /* adjust passed-by-reference argument (note: this is
1392                            monotonic and does not reflect looping.
1393                         */
1394                         start += this_read;
1395
1396                         /* similarly adjust effective_start, but this may be
1397                            readjusted for seamless looping as we continue around
1398                            the loop.
1399                         */
1400                         effective_start += this_read;
1401                 }
1402
1403                 dur -= this_read;
1404                 //offset += this_read;
1405         }
1406
1407         return 0;
1408 }
1409
1410 int
1411 DiskReader::refill_midi ()
1412 {
1413         if (!_playlists[DataType::MIDI]) {
1414                 return 0;
1415         }
1416
1417         size_t  write_space = _midi_buf->write_space();
1418         const bool reversed    = _session.transport_speed() < 0.0f;
1419
1420         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file frame = %2\n", write_space, file_frame));
1421
1422         /* no space to write */
1423         if (write_space == 0) {
1424                 return 0;
1425         }
1426
1427         if (reversed) {
1428                 return 0;
1429         }
1430
1431         /* at end: nothing to do */
1432
1433         if (file_frame == max_framepos) {
1434                 return 0;
1435         }
1436
1437         int ret = 0;
1438         const uint32_t frames_read = g_atomic_int_get (&_frames_read_from_ringbuffer);
1439         const uint32_t frames_written = g_atomic_int_get (&_frames_written_to_ringbuffer);
1440
1441         if ((frames_read < frames_written) && (frames_written - frames_read) >= midi_readahead) {
1442                 return 0;
1443         }
1444
1445         framecnt_t to_read = midi_readahead - ((framecnt_t)frames_written - (framecnt_t)frames_read);
1446
1447         to_read = min (to_read, (framecnt_t) (max_framepos - file_frame));
1448         to_read = min (to_read, (framecnt_t) write_space);
1449
1450         if (midi_read (file_frame, to_read, reversed)) {
1451                 ret = -1;
1452         }
1453
1454         return ret;
1455 }