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