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