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