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