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 == 0.0 && (ms == MonitoringDisk)) {
 261                 /* stopped. Don't accidentally pass any data from disk
 262                  * into our outputs (e.g. via interpolation)
 263                  */
 264                 bufs.silence (nframes, 0);
 265                 return;
 266         }
 267
 268         if (speed != 1.0f && speed != -1.0f) {
 269                 interpolation.set_speed (speed);
 270                 midi_interpolation.set_speed (speed);
 271                 playback_distance = midi_interpolation.distance (nframes);
 272         }
 273
 274         if (speed < 0.0) {
 275                 playback_distance = -playback_distance;
 276         }
 277
 278         BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
 279
 280         if (!result_required || ((ms & MonitoringDisk) == 0)) {
 281
 282                 /* no need for actual disk data, just advance read pointer and return */
 283
 284                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 285                         (*chan)->buf->increment_read_ptr (playback_distance);
 286                 }
 287
 288         } else {
 289
 290                 /* we need audio data from disk */
 291
 292                 size_t n_buffers = bufs.count().n_audio();
 293                 size_t n_chans = c->size();
 294                 gain_t scaling;
 295
 296                 if (n_chans > n_buffers) {
 297                         scaling = ((float) n_buffers)/n_chans;
 298                 } else {
 299                         scaling = 1.0;
 300                 }
 301
 302                 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 303
 304                         ChannelInfo* chaninfo (*chan);
 305                         AudioBuffer& buf (bufs.get_audio (n%n_buffers));
 306                         Sample* disk_signal = 0; /* assignment not really needed but it keeps the compiler quiet and helps track bugs */
 307
 308                         if (ms & MonitoringInput) {
 309                                 /* put disk stream in scratch buffer, blend at end */
 310                                 disk_signal = scratch_bufs.get_audio(n).data ();
 311                         } else {
 312                                 /* no input stream needed, just overwrite buffers */
 313                                 disk_signal = buf.data ();
 314                         }
 315
 316                         chaninfo->buf->get_read_vector (&(*chan)->rw_vector);
 317
 318                         if (playback_distance <= (framecnt_t) chaninfo->rw_vector.len[0]) {
 319
 320                                 if (fabsf (speed) != 1.0f) {
 321                                         (void) interpolation.interpolate (
 322                                                 n, nframes,
 323                                                 chaninfo->rw_vector.buf[0],
 324                                                 disk_signal);
 325                                 } else if (speed != 0.0) {
 326                                         memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * playback_distance);
 327                                 }
 328
 329                         } else {
 330
 331                                 const framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
 332
 333                                 if (playback_distance <= total) {
 334
 335                                         /* We have enough samples, but not in one lump.
 336                                          */
 337
 338                                         if (fabsf (speed) != 1.0f) {
 339                                                 interpolation.interpolate (n, chaninfo->rw_vector.len[0],
 340                                                                            chaninfo->rw_vector.buf[0],
 341                                                                            disk_signal);
 342                                                 disk_signal += chaninfo->rw_vector.len[0];
 343                                                 interpolation.interpolate (n, playback_distance - chaninfo->rw_vector.len[0],
 344                                                                            chaninfo->rw_vector.buf[1],
 345                                                                            disk_signal);
 346                                         } else if (speed != 0.0) {
 347                                                 memcpy (disk_signal,
 348                                                         chaninfo->rw_vector.buf[0],
 349                                                         chaninfo->rw_vector.len[0] * sizeof (Sample));
 350                                                 disk_signal += chaninfo->rw_vector.len[0];
 351                                                 memcpy (disk_signal,
 352                                                         chaninfo->rw_vector.buf[1],
 353                                                         (playback_distance - chaninfo->rw_vector.len[0]) * sizeof (Sample));
 354                                         }
 355
 356                                 } else {
 357
 358                                         cerr << _name << " Need " << playback_distance << " total = " << total << endl;
 359                                         cerr << "underrun for " << _name << endl;
 360                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
 361                                                                                     DEBUG_THREAD_SELF, name(), total));
 362                                         Underrun ();
 363                                         return;
 364
 365                                 }
 366                         }
 367
 368                         if (scaling != 1.0f && speed != 0.0) {
 369                                 apply_gain_to_buffer (disk_signal, nframes, scaling);
 370                         }
 371
 372                         chaninfo->buf->increment_read_ptr (playback_distance);
 373
 374                         if ((speed != 0.0) && (ms & MonitoringInput)) {
 375                                 /* mix the disk signal into the input signal (already in bufs) */
 376                                 mix_buffers_no_gain (buf.data(), disk_signal, speed == 0.0 ? nframes : playback_distance);
 377                         }
 378                 }
 379         }
 380
 381         /* MIDI data handling */
 382
 383         if (!_session.declick_out_pending()) {
 384                 if (ms & MonitoringDisk) {
 385                         get_midi_playback (bufs.get_midi (0), playback_distance, ms, scratch_bufs, speed, playback_distance);
 386                 }
 387         }
 388
 389         if (speed < 0.0) {
 390                 playback_sample -= playback_distance;
 391         } else {
 392                 playback_sample += playback_distance;
 393         }
 394
 395         if (_playlists[DataType::AUDIO]) {
 396                 if (!c->empty()) {
 397                         if (_slaved) {
 398                                 if (c->front()->buf->write_space() >= c->front()->buf->bufsize() / 2) {
 399                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 400                                                                                     c->front()->buf->bufsize()));
 401                                         _need_butler = true;
 402                                 }
 403                         } else {
 404                                 if ((framecnt_t) c->front()->buf->write_space() >= _chunk_frames) {
 405                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->buf->write_space(),
 406                                                                                     _chunk_frames));
 407                                         _need_butler = true;
 408                                 }
 409                         }
 410                 }
 411         }
 412
 413         if (_playlists[DataType::MIDI]) {
 414                 /* MIDI butler needed part */
 415
 416                 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
 417                 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
 418
 419                 /*
 420                   cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
 421                   " = " << frames_written - frames_read
 422                   << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
 423                 */
 424
 425                 /* frames_read will generally be less than frames_written, but
 426                  * immediately after an overwrite, we can end up having read some data
 427                  * before we've written any. we don't need to trip an assert() on this,
 428                  * but we do need to check so that the decision on whether or not we
 429                  * need the butler is done correctly.
 430                  */
 431
 432                 /* furthermore..
 433                  *
 434                  * Doing heavy GUI operations[1] can stall also the butler.
 435                  * The RT-thread meanwhile will happily continue and
 436                  * ‘frames_read’ (from buffer to output) will become larger
 437                  * than ‘frames_written’ (from disk to buffer).
 438                  *
 439                  * The disk-stream is now behind..
 440                  *
 441                  * In those cases the butler needs to be summed to refill the buffer (done now)
 442                  * AND we need to skip (frames_read - frames_written). ie remove old events
 443                  * before playback_sample from the rinbuffer.
 444                  *
 445                  * [1] one way to do so is described at #6170.
 446                  * For me just popping up the context-menu on a MIDI-track header
 447                  * of a track with a large (think beethoven :) midi-region also did the
 448                  * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
 449                  *
 450                  * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
 451                  * and can stall
 452                  */
 453                 if (frames_read <= frames_written) {
 454                         if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 455                                 _need_butler = true;
 456                         }
 457                 } else {
 458                         _need_butler = true;
 459                 }
 460
 461         }
 462
 463         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
 464 }
 465
 466 void
 467 DiskReader::set_pending_overwrite (bool yn)
 468 {
 469         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 470
 471         _pending_overwrite = yn;
 472
 473         overwrite_frame = playback_sample;
 474
 475         boost::shared_ptr<ChannelList> c = channels.reader ();
 476         if (!c->empty ()) {
 477                 overwrite_offset = c->front()->buf->get_read_ptr();
 478         }
 479 }
 480
 481 int
 482 DiskReader::overwrite_existing_buffers ()
 483 {
 484         int ret = -1;
 485
 486         boost::shared_ptr<ChannelList> c = channels.reader();
 487
 488         overwrite_queued = false;
 489
 490         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_frame));
 491
 492         if (!c->empty ()) {
 493
 494                 /* AUDIO */
 495
 496                 const bool reversed = _session.transport_speed() < 0.0f;
 497
 498                 /* assume all are the same size */
 499                 framecnt_t size = c->front()->buf->bufsize();
 500
 501                 std::auto_ptr<Sample> mixdown_buffer (new Sample[size]);
 502                 std::auto_ptr<float> gain_buffer (new float[size]);
 503
 504                 /* reduce size so that we can fill the buffer correctly (ringbuffers
 505                    can only handle size-1, otherwise they appear to be empty)
 506                 */
 507                 size--;
 508
 509                 uint32_t n=0;
 510                 framepos_t start;
 511
 512                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 513
 514                         start = overwrite_frame;
 515                         framecnt_t cnt = size;
 516
 517                         /* to fill the buffer without resetting the playback sample, we need to
 518                            do it one or two chunks (normally two).
 519
 520                            |----------------------------------------------------------------------|
 521
 522                            ^
 523                            overwrite_offset
 524                            |<- second chunk->||<----------------- first chunk ------------------>|
 525
 526                         */
 527
 528                         framecnt_t to_read = size - overwrite_offset;
 529
 530                         if (audio_read ((*chan)->buf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
 531                                 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 532                                                         id(), size, playback_sample) << endmsg;
 533                                 goto midi;
 534                         }
 535
 536                         if (cnt > to_read) {
 537
 538                                 cnt -= to_read;
 539
 540                                 if (audio_read ((*chan)->buf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
 541                                         error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"),
 542                                                                 id(), size, playback_sample) << endmsg;
 543                                         goto midi;
 544                                 }
 545                         }
 546                 }
 547
 548                 ret = 0;
 549
 550         }
 551
 552   midi:
 553
 554         if (_midi_buf && _playlists[DataType::MIDI]) {
 555
 556                 /* Clear the playback buffer contents.  This is safe as long as the butler
 557                    thread is suspended, which it should be.
 558                 */
 559                 _midi_buf->reset ();
 560                 _midi_buf->reset_tracker ();
 561
 562                 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 563                 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 564
 565                 /* Resolve all currently active notes in the playlist.  This is more
 566                    aggressive than it needs to be: ideally we would only resolve what is
 567                    absolutely necessary, but this seems difficult and/or impossible without
 568                    having the old data or knowing what change caused the overwrite.
 569                 */
 570                 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_frame);
 571
 572                 midi_read (overwrite_frame, _chunk_frames, false);
 573
 574                 file_frame = overwrite_frame; // it was adjusted by ::midi_read()
 575         }
 576
 577         _pending_overwrite = false;
 578
 579         return ret;
 580 }
 581
 582 int
 583 DiskReader::seek (framepos_t frame, bool complete_refill)
 584 {
 585         uint32_t n;
 586         int ret = -1;
 587         ChannelList::iterator chan;
 588         boost::shared_ptr<ChannelList> c = channels.reader();
 589
 590         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 591                 (*chan)->buf->reset ();
 592         }
 593
 594         if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
 595                 /* we haven't read anything since the last seek,
 596                    so flush all note trackers to prevent
 597                    wierdness
 598                 */
 599                 reset_tracker ();
 600         }
 601
 602         _midi_buf->reset();
 603         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 604         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 605
 606         playback_sample = frame;
 607         file_frame = frame;
 608
 609         if (complete_refill) {
 610                 /* call _do_refill() to refill the entire buffer, using
 611                    the largest reads possible.
 612                 */
 613                 while ((ret = do_refill_with_alloc (false)) > 0) ;
 614         } else {
 615                 /* call _do_refill() to refill just one chunk, and then
 616                    return.
 617                 */
 618                 ret = do_refill_with_alloc (true);
 619         }
 620
 621
 622         return ret;
 623 }
 624
 625 int
 626 DiskReader::can_internal_playback_seek (framecnt_t distance)
 627 {
 628         /* 1. Audio */
 629
 630         ChannelList::iterator chan;
 631         boost::shared_ptr<ChannelList> c = channels.reader();
 632
 633         for (chan = c->begin(); chan != c->end(); ++chan) {
 634                 if ((*chan)->buf->read_space() < (size_t) distance) {
 635                         return false;
 636                 }
 637         }
 638
 639         /* 2. MIDI */
 640
 641         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 642         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 643
 644         return ((frames_written - frames_read) < distance);
 645 }
 646
 647 int
 648 DiskReader::internal_playback_seek (framecnt_t distance)
 649 {
 650         ChannelList::iterator chan;
 651         boost::shared_ptr<ChannelList> c = channels.reader();
 652
 653         for (chan = c->begin(); chan != c->end(); ++chan) {
 654                 (*chan)->buf->increment_read_ptr (::llabs(distance));
 655         }
 656
 657         playback_sample += distance;
 658
 659         return 0;
 660 }
 661
 662 static
 663 void swap_by_ptr (Sample *first, Sample *last)
 664 {
 665         while (first < last) {
 666                 Sample tmp = *first;
 667                 *first++ = *last;
 668                 *last-- = tmp;
 669         }
 670 }
 671
 672 /** Read some data for 1 channel from our playlist into a buffer.
 673  *  @param buf Buffer to write to.
 674  *  @param start Session frame to start reading from; updated to where we end up
 675  *         after the read.
 676  *  @param cnt Count of samples to read.
 677  *  @param reversed true if we are running backwards, otherwise false.
 678  */
 679 int
 680 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 681                         framepos_t& start, framecnt_t cnt,
 682                         int channel, bool reversed)
 683 {
 684         framecnt_t this_read = 0;
 685         bool reloop = false;
 686         framepos_t loop_end = 0;
 687         framepos_t loop_start = 0;
 688         framecnt_t offset = 0;
 689         Location *loc = 0;
 690
 691         if (!_playlists[DataType::AUDIO]) {
 692                 memset (buf, 0, sizeof (Sample) * cnt);
 693                 return 0;
 694         }
 695
 696         /* XXX we don't currently play loops in reverse. not sure why */
 697
 698         if (!reversed) {
 699
 700                 framecnt_t loop_length = 0;
 701
 702                 /* Make the use of a Location atomic for this read operation.
 703
 704                    Note: Locations don't get deleted, so all we care about
 705                    when I say "atomic" is that we are always pointing to
 706                    the same one and using a start/length values obtained
 707                    just once.
 708                 */
 709
 710                 if ((loc = loop_location) != 0) {
 711                         loop_start = loc->start();
 712                         loop_end = loc->end();
 713                         loop_length = loop_end - loop_start;
 714                 }
 715
 716                 /* if we are looping, ensure that the first frame we read is at the correct
 717                    position within the loop.
 718                 */
 719
 720                 if (loc && start >= loop_end) {
 721                         start = loop_start + ((start - loop_start) % loop_length);
 722                 }
 723
 724         }
 725
 726         if (reversed) {
 727                 start -= cnt;
 728         }
 729
 730         /* We need this while loop in case we hit a loop boundary, in which case our read from
 731            the playlist must be split into more than one section.
 732         */
 733
 734         while (cnt) {
 735
 736                 /* take any loop into account. we can't read past the end of the loop. */
 737
 738                 if (loc && (loop_end - start < cnt)) {
 739                         this_read = loop_end - start;
 740                         reloop = true;
 741                 } else {
 742                         reloop = false;
 743                         this_read = cnt;
 744                 }
 745
 746                 if (this_read == 0) {
 747                         break;
 748                 }
 749
 750                 this_read = min(cnt,this_read);
 751
 752                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
 753                         error << string_compose(_("DiskReader %1: cannot read %2 from playlist at frame %3"), id(), this_read,
 754                                          start) << endmsg;
 755                         return -1;
 756                 }
 757
 758                 if (reversed) {
 759
 760                         swap_by_ptr (buf, buf + this_read - 1);
 761
 762                 } else {
 763
 764                         /* if we read to the end of the loop, go back to the beginning */
 765
 766                         if (reloop) {
 767                                 start = loop_start;
 768                         } else {
 769                                 start += this_read;
 770                         }
 771                 }
 772
 773                 cnt -= this_read;
 774                 offset += this_read;
 775         }
 776
 777         return 0;
 778 }
 779
 780 int
 781 DiskReader::_do_refill_with_alloc (bool partial_fill)
 782 {
 783         /* We limit disk reads to at most 4MB chunks, which with floating point
 784            samples would be 1M samples. But we might use 16 or 14 bit samples,
 785            in which case 4MB is more samples than that. Therefore size this for
 786            the smallest sample value .. 4MB = 2M samples (16 bit).
 787         */
 788
 789         {
 790                 std::auto_ptr<Sample> mix_buf (new Sample[2*1048576]);
 791                 std::auto_ptr<float>  gain_buf (new float[2*1048576]);
 792
 793                 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_frames : 0));
 794
 795                 if (ret) {
 796                         return ret;
 797                 }
 798         }
 799
 800         return refill_midi ();
 801 }
 802
 803 int
 804 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 805 {
 806         int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
 807
 808         if (ret) {
 809                 return ret;
 810         }
 811
 812         return refill_midi ();
 813 }
 814
 815
 816 /** Get some more data from disk and put it in our channels' bufs,
 817  *  if there is suitable space in them.
 818  *
 819  * If fill_level is non-zero, then we will refill the buffer so that there is
 820  * still at least fill_level samples of space left to be filled. This is used
 821  * after locates so that we do not need to wait to fill the entire buffer.
 822  *
 823  */
 824
 825 int
 826 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level)
 827 {
 828         /* do not read from disk while session is marked as Loading, to avoid
 829            useless redundant I/O.
 830         */
 831
 832         if (_session.loading()) {
 833                 return 0;
 834         }
 835
 836         int32_t ret = 0;
 837         framecnt_t to_read;
 838         RingBufferNPT<Sample>::rw_vector vector;
 839         bool const reversed = _session.transport_speed() < 0.0f;
 840         framecnt_t total_space;
 841         framecnt_t zero_fill;
 842         uint32_t chan_n;
 843         ChannelList::iterator i;
 844         boost::shared_ptr<ChannelList> c = channels.reader();
 845         framecnt_t ts;
 846
 847         if (c->empty()) {
 848                 return 0;
 849         }
 850
 851         assert(mixdown_buffer);
 852         assert(gain_buffer);
 853
 854         vector.buf[0] = 0;
 855         vector.len[0] = 0;
 856         vector.buf[1] = 0;
 857         vector.len[1] = 0;
 858
 859         c->front()->buf->get_write_vector (&vector);
 860
 861         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
 862                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
 863                 /* nowhere to write to */
 864                 return 0;
 865         }
 866
 867         if (fill_level) {
 868                 if (fill_level < total_space) {
 869                         total_space -= fill_level;
 870                 } else {
 871                         /* we can't do anything with it */
 872                         fill_level = 0;
 873                 }
 874         }
 875
 876         /* if we're running close to normal speed and there isn't enough
 877            space to do disk_read_chunk_frames of I/O, then don't bother.
 878
 879            at higher speeds, just do it because the sync between butler
 880            and audio thread may not be good enough.
 881
 882            Note: it is a design assumption that disk_read_chunk_frames is smaller
 883            than the playback buffer size, so this check should never trip when
 884            the playback buffer is empty.
 885         */
 886
 887         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()));
 888         if ((total_space < _chunk_frames) && fabs (_session.transport_speed()) < 2.0f) {
 889                 return 0;
 890         }
 891
 892         /* when slaved, don't try to get too close to the read pointer. this
 893            leaves space for the buffer reversal to have something useful to
 894            work with.
 895         */
 896
 897         if (_slaved && total_space < (framecnt_t) (c->front()->buf->bufsize() / 2)) {
 898                 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
 899                 return 0;
 900         }
 901
 902         if (reversed) {
 903
 904                 if (file_frame == 0) {
 905
 906                         /* at start: nothing to do but fill with silence */
 907
 908                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 909
 910                                 ChannelInfo* chan (*i);
 911                                 chan->buf->get_write_vector (&vector);
 912                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 913                                 if (vector.len[1]) {
 914                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 915                                 }
 916                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 917                         }
 918                         return 0;
 919                 }
 920
 921                 if (file_frame < total_space) {
 922
 923                         /* too close to the start: read what we can,
 924                            and then zero fill the rest
 925                         */
 926
 927                         zero_fill = total_space - file_frame;
 928                         total_space = file_frame;
 929
 930                 } else {
 931
 932                         zero_fill = 0;
 933                 }
 934
 935         } else {
 936
 937                 if (file_frame == max_framepos) {
 938
 939                         /* at end: nothing to do but fill with silence */
 940
 941                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 942
 943                                 ChannelInfo* chan (*i);
 944                                 chan->buf->get_write_vector (&vector);
 945                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
 946                                 if (vector.len[1]) {
 947                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
 948                                 }
 949                                 chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]);
 950                         }
 951                         return 0;
 952                 }
 953
 954                 if (file_frame > max_framepos - total_space) {
 955
 956                         /* to close to the end: read what we can, and zero fill the rest */
 957
 958                         zero_fill = total_space - (max_framepos - file_frame);
 959                         total_space = max_framepos - file_frame;
 960
 961                 } else {
 962                         zero_fill = 0;
 963                 }
 964         }
 965
 966         framepos_t file_frame_tmp = 0;
 967
 968         /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
 969
 970         const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
 971         size_t total_bytes = total_space * bits_per_sample / 8;
 972
 973         /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
 974          */
 975         size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
 976
 977         /* find nearest (lower) multiple of 16384 */
 978
 979         byte_size_for_read = (byte_size_for_read / 16384) * 16384;
 980
 981         /* now back to samples */
 982
 983         framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
 984
 985         DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
 986
 987         // uint64_t before = g_get_monotonic_time ();
 988         // uint64_t elapsed;
 989
 990         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 991
 992                 ChannelInfo* chan (*i);
 993                 Sample* buf1;
 994                 Sample* buf2;
 995                 framecnt_t len1, len2;
 996
 997                 chan->buf->get_write_vector (&vector);
 998
 999                 if ((framecnt_t) vector.len[0] > samples_to_read) {
1000
1001                         /* we're not going to fill the first chunk, so certainly do not bother with the
1002                            other part. it won't be connected with the part we do fill, as in:
1003
1004                            .... => writable space
1005                            ++++ => readable space
1006                            ^^^^ => 1 x disk_read_chunk_frames that would be filled
1007
1008                            |......|+++++++++++++|...............................|
1009                            buf1                buf0
1010                                                 ^^^^^^^^^^^^^^^
1011
1012
1013                            So, just pretend that the buf1 part isn't there.
1014
1015                         */
1016
1017                         vector.buf[1] = 0;
1018                         vector.len[1] = 0;
1019
1020                 }
1021
1022                 ts = total_space;
1023                 file_frame_tmp = file_frame;
1024
1025                 buf1 = vector.buf[0];
1026                 len1 = vector.len[0];
1027                 buf2 = vector.buf[1];
1028                 len2 = vector.len[1];
1029
1030                 to_read = min (ts, len1);
1031                 to_read = min (to_read, (framecnt_t) samples_to_read);
1032
1033                 assert (to_read >= 0);
1034
1035                 if (to_read) {
1036
1037                         if (audio_read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1038                                 ret = -1;
1039                                 goto out;
1040                         }
1041
1042                         chan->buf->increment_write_ptr (to_read);
1043                         ts -= to_read;
1044                 }
1045
1046                 to_read = min (ts, len2);
1047
1048                 if (to_read) {
1049
1050                         /* we read all of vector.len[0], but it wasn't the
1051                            entire samples_to_read of data, so read some or
1052                            all of vector.len[1] as well.
1053                         */
1054
1055                         if (audio_read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1056                                 ret = -1;
1057                                 goto out;
1058                         }
1059
1060                         chan->buf->increment_write_ptr (to_read);
1061                 }
1062
1063                 if (zero_fill) {
1064                         /* XXX: do something */
1065                 }
1066
1067         }
1068
1069         // elapsed = g_get_monotonic_time () - before;
1070         // cerr << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1071
1072         file_frame = file_frame_tmp;
1073         assert (file_frame >= 0);
1074
1075         ret = ((total_space - samples_to_read) > _chunk_frames);
1076
1077         c->front()->buf->get_write_vector (&vector);
1078
1079   out:
1080         return ret;
1081 }
1082
1083 void
1084 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<framepos_t> > const & movements_frames, bool from_undo)
1085 {
1086         /* If we're coming from an undo, it will have handled
1087            automation undo (it must, since automation-follows-regions
1088            can lose automation data).  Hence we can do nothing here.
1089         */
1090
1091         if (from_undo) {
1092                 return;
1093         }
1094
1095         if (!_route || Config->get_automation_follows_regions () == false) {
1096                 return;
1097         }
1098
1099         list< Evoral::RangeMove<double> > movements;
1100
1101         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin();
1102              i != movements_frames.end();
1103              ++i) {
1104
1105                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1106         }
1107
1108         /* move panner automation */
1109         boost::shared_ptr<Pannable> pannable = _route->pannable();
1110         Evoral::ControlSet::Controls& c (pannable->controls());
1111
1112         for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1113                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1114                 if (!ac) {
1115                         continue;
1116                 }
1117                 boost::shared_ptr<AutomationList> alist = ac->alist();
1118                 if (!alist->size()) {
1119                         continue;
1120                 }
1121                 XMLNode & before = alist->get_state ();
1122                 bool const things_moved = alist->move_ranges (movements);
1123                 if (things_moved) {
1124                         _session.add_command (new MementoCommand<AutomationList> (
1125                                                       *alist.get(), &before, &alist->get_state ()));
1126                 }
1127         }
1128         /* move processor automation */
1129         _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_frames));
1130 }
1131
1132 void
1133 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<framepos_t> > const & movements_frames)
1134 {
1135         boost::shared_ptr<Processor> processor (p.lock ());
1136         if (!processor) {
1137                 return;
1138         }
1139
1140         list< Evoral::RangeMove<double> > movements;
1141         for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) {
1142                 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1143         }
1144
1145         set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1146
1147         for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1148                 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1149                 if (!al->size()) {
1150                         continue;
1151                 }
1152                 XMLNode & before = al->get_state ();
1153                 bool const things_moved = al->move_ranges (movements);
1154                 if (things_moved) {
1155                         _session.add_command (
1156                                 new MementoCommand<AutomationList> (
1157                                         *al.get(), &before, &al->get_state ()
1158                                         )
1159                                 );
1160                 }
1161         }
1162 }
1163
1164 boost::shared_ptr<MidiBuffer>
1165 DiskReader::get_gui_feed_buffer () const
1166 {
1167         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1168
1169         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1170         b->copy (_gui_feed_buffer);
1171         return b;
1172 }
1173
1174 void
1175 DiskReader::reset_tracker ()
1176 {
1177         _midi_buf->reset_tracker ();
1178
1179         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1180
1181         if (mp) {
1182                 mp->reset_note_trackers ();
1183         }
1184 }
1185
1186 void
1187 DiskReader::resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time)
1188 {
1189         _midi_buf->resolve_tracker(buffer, time);
1190
1191         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1192
1193         if (mp) {
1194                 mp->reset_note_trackers ();
1195         }
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_midi_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 }