2 Copyright (C) 2009-2016 Paul Davis
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.
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.
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.
20 #include <boost/smart_ptr/scoped_array.hpp>
22 #include "pbd/enumwriter.h"
23 #include "pbd/memento_command.h"
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"
42 using namespace ARDOUR;
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;
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)
61 file_sample[DataType::AUDIO] = 0;
62 file_sample[DataType::MIDI] = 0;
65 DiskReader::~DiskReader ()
67 DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskReader %1 @ %2 deleted\n", _name, this));
69 for (uint32_t n = 0; n < DataType::num_types; ++n) {
71 _playlists[n]->release ();
77 DiskReader::ReaderChannelInfo::resize (samplecnt_t bufsize)
80 /* touch memory to lock it */
81 rbuf = new RingBufferNPT<Sample> (bufsize);
82 memset (rbuf->buffer(), 0, sizeof (Sample) * rbuf->bufsize());
86 DiskReader::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
89 c->push_back (new ReaderChannelInfo (_session.butler()->audio_diskstream_playback_buffer_size()));
90 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: new reader channel, write space = %2 read = %3\n",
92 c->back()->rbuf->write_space(),
93 c->back()->rbuf->read_space()));
100 DiskReader::allocate_working_buffers()
102 /* with varifill buffer refilling, we compute the read size in bytes (to optimize
103 for disk i/o bandwidth) and then convert back into samples. These buffers
104 need to reflect the maximum size we could use, which is 4MB reads, or 2M samples
105 using 16 bit samples.
107 _mixdown_buffer = new Sample[2*1048576];
108 _gain_buffer = new gain_t[2*1048576];
112 DiskReader::free_working_buffers()
114 delete [] _mixdown_buffer;
115 delete [] _gain_buffer;
121 DiskReader::default_chunk_samples()
127 DiskReader::set_name (string const & str)
129 string my_name = X_("player:");
132 if (_name != my_name) {
133 SessionObject::set_name (my_name);
142 XMLNode& node (DiskIOProcessor::state ());
143 node.set_property(X_("type"), X_("diskreader"));
148 DiskReader::set_state (const XMLNode& node, int version)
150 if (DiskIOProcessor::set_state (node, version)) {
158 DiskReader::realtime_handle_transport_stopped ()
163 DiskReader::realtime_locate ()
168 DiskReader::buffer_load () const
170 /* Note: for MIDI it's not trivial to differentiate the following two cases:
172 1. The playback buffer is empty because the system has run out of time to fill it.
173 2. The playback buffer is empty because there is no more data on the playlist.
175 If we use a simple buffer load computation, we will report that the MIDI diskstream
176 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
177 are so low compared to audio, just use the audio value here.
180 boost::shared_ptr<ChannelList> c = channels.reader();
183 /* no channels, so no buffers, so completely full and ready to playback, sir! */
187 PBD::RingBufferNPT<Sample>* b = c->front()->rbuf;
188 return (float) ((double) b->read_space() / (double) b->bufsize());
192 DiskReader::adjust_buffering ()
194 boost::shared_ptr<ChannelList> c = channels.reader();
196 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
197 (*chan)->resize (_session.butler()->audio_diskstream_playback_buffer_size());
202 DiskReader::playlist_changed (const PropertyChange&)
204 playlist_modified ();
208 DiskReader::playlist_modified ()
210 if (!i_am_the_modifier && !overwrite_queued) {
211 _session.request_overwrite_buffer (_route);
212 overwrite_queued = true;
217 DiskReader::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist)
219 bool prior_playlist = false;
221 if (_playlists[dt]) {
222 prior_playlist = true;
225 if (DiskIOProcessor::use_playlist (dt, playlist)) {
229 /* don't do this if we've already asked for it *or* if we are setting up
230 the diskstream for the very first time - the input changed handling will
231 take care of the buffer refill.
234 if (!overwrite_queued && (prior_playlist || _session.loading())) {
235 _session.request_overwrite_buffer (_route);
236 overwrite_queued = true;
243 DiskReader::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
244 double speed, pframes_t nframes, bool result_required)
247 boost::shared_ptr<ChannelList> c = channels.reader();
248 ChannelList::iterator chan;
249 sampleoffset_t disk_samples_to_consume;
250 MonitorState ms = _route->monitoring_state ();
253 if (!_pending_active) {
258 if (_pending_active) {
265 if ((speed == 0.0) && (ms == MonitoringDisk)) {
266 /* no channels, or stopped. Don't accidentally pass any data
267 * from disk into our outputs (e.g. via interpolation)
272 BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
273 const bool still_locating = _session.global_locate_pending();
276 /* do nothing with audio */
280 assert (speed == -1 || speed == 0 || speed == 1);
283 disk_samples_to_consume = -nframes;
284 } else if (speed > 0) {
285 disk_samples_to_consume = nframes;
287 disk_samples_to_consume = 0;
290 if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating || _no_disk_output) {
292 /* no need for actual disk data, just advance read pointer and return */
294 if (!still_locating || _no_disk_output) {
295 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
296 (*chan)->rbuf->increment_read_ptr (disk_samples_to_consume);
300 /* if monitoring disk but locating put silence in the buffers */
302 if ((_no_disk_output || still_locating) && (ms == MonitoringDisk)) {
303 bufs.silence (nframes, 0);
308 /* we need audio data from disk */
310 size_t n_buffers = bufs.count().n_audio();
311 size_t n_chans = c->size();
314 if (n_chans > n_buffers) {
315 scaling = ((float) n_buffers)/n_chans;
320 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
322 ChannelInfo* chaninfo (*chan);
323 AudioBuffer& output (bufs.get_audio (n%n_buffers));
324 Sample* disk_signal = 0; /* assignment not really needed but it keeps the compiler quiet and helps track bugs */
326 if (ms & MonitoringInput) {
327 /* put disk stream in scratch buffer, blend at end */
328 disk_signal = scratch_bufs.get_audio(n).data ();
330 /* no input stream needed, just overwrite buffers */
331 disk_signal = output.data ();
335 if (start_sample < playback_sample) {
336 cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << endl;
339 } else if (speed < 0) {
340 if (playback_sample < start_sample) {
341 cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << " REVERSE" << endl;
346 if ((speed > 0) && (start_sample != playback_sample)) {
348 str << owner()->name() << " playback @ " << start_sample << " not aligned with " << playback_sample << " jump ahead " << (start_sample - playback_sample) << endl;
351 if (can_internal_playback_seek (start_sample - playback_sample)) {
352 internal_playback_seek (start_sample - playback_sample);
354 cerr << owner()->name() << " playback not possible: ss = " << start_sample << " ps = " << playback_sample << endl;
359 chaninfo->rbuf->get_read_vector (&(*chan)->rw_vector);
361 if (disk_samples_to_consume <= (samplecnt_t) chaninfo->rw_vector.len[0]) {
364 memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * disk_samples_to_consume);
369 const samplecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
371 if (disk_samples_to_consume <= total) {
375 chaninfo->rw_vector.buf[0],
376 chaninfo->rw_vector.len[0] * sizeof (Sample));
377 memcpy (disk_signal + chaninfo->rw_vector.len[0],
378 chaninfo->rw_vector.buf[1],
379 (disk_samples_to_consume - chaninfo->rw_vector.len[0]) * sizeof (Sample));
384 cerr << _name << " Need " << disk_samples_to_consume << " total = " << total << endl;
385 cerr << "underrun for " << _name << endl;
386 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
387 DEBUG_THREAD_SELF, name(), total));
394 if (scaling != 1.0f && speed != 0.0) {
395 apply_gain_to_buffer (disk_signal, disk_samples_to_consume, scaling);
398 chaninfo->rbuf->increment_read_ptr (disk_samples_to_consume);
400 if (ms & MonitoringInput) {
401 /* mix the disk signal into the input signal (already in bufs) */
402 mix_buffers_no_gain (output.data(), disk_signal, disk_samples_to_consume);
407 /* MIDI data handling */
410 if (/*!_session.declick_out_pending() && */ bufs.count().n_midi() && _midi_buf) {
413 if (_no_disk_output) {
414 dst = &scratch_bufs.get_midi(0);
416 dst = &bufs.get_midi (0);
419 if ((ms & MonitoringDisk) && !still_locating) {
420 get_midi_playback (*dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume);
424 if (!still_locating) {
426 bool butler_required = false;
429 playback_sample -= disk_samples_to_consume;
431 playback_sample += disk_samples_to_consume;
434 if (_playlists[DataType::AUDIO]) {
437 if (c->front()->rbuf->write_space() >= c->front()->rbuf->bufsize() / 2) {
438 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->rbuf->write_space(), c->front()->rbuf->bufsize()));
439 butler_required = true;
442 if ((samplecnt_t) c->front()->rbuf->write_space() >= _chunk_samples) {
443 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->rbuf->write_space(),
445 butler_required = true;
451 if (_playlists[DataType::MIDI]) {
452 /* MIDI butler needed part */
454 uint32_t samples_read = g_atomic_int_get(const_cast<gint*>(&_samples_read_from_ringbuffer));
455 uint32_t samples_written = g_atomic_int_get(const_cast<gint*>(&_samples_written_to_ringbuffer));
458 cerr << name() << " MDS written: " << samples_written << " - read: " << samples_read <<
459 " = " << samples_written - samples_read
460 << " + " << disk_samples_to_consume << " < " << midi_readahead << " = " << need_butler << ")" << endl;
463 /* samples_read will generally be less than samples_written, but
464 * immediately after an overwrite, we can end up having read some data
465 * before we've written any. we don't need to trip an assert() on this,
466 * but we do need to check so that the decision on whether or not we
467 * need the butler is done correctly.
472 * Doing heavy GUI operations[1] can stall also the butler.
473 * The RT-thread meanwhile will happily continue and
474 * ‘samples_read’ (from buffer to output) will become larger
475 * than ‘samples_written’ (from disk to buffer).
477 * The disk-stream is now behind..
479 * In those cases the butler needs to be summed to refill the buffer (done now)
480 * AND we need to skip (samples_read - samples_written). ie remove old events
481 * before playback_sample from the rinbuffer.
483 * [1] one way to do so is described at #6170.
484 * For me just popping up the context-menu on a MIDI-track header
485 * of a track with a large (think beethoven :) midi-region also did the
486 * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
488 * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
491 if (samples_read <= samples_written) {
492 if ((samples_written - samples_read) + disk_samples_to_consume < midi_readahead) {
493 butler_required = true;
496 butler_required = true;
501 _need_butler = butler_required;
504 // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
508 DiskReader::set_pending_overwrite (bool yn)
510 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
512 _pending_overwrite = yn;
514 overwrite_sample = playback_sample;
516 boost::shared_ptr<ChannelList> c = channels.reader ();
518 overwrite_offset = c->front()->rbuf->get_read_ptr();
523 DiskReader::overwrite_existing_buffers ()
527 boost::shared_ptr<ChannelList> c = channels.reader();
529 overwrite_queued = false;
531 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_sample));
537 const bool reversed = _session.transport_speed() < 0.0f;
539 /* assume all are the same size */
540 samplecnt_t size = c->front()->rbuf->bufsize();
542 boost::scoped_array<Sample> mixdown_buffer (new Sample[size]);
543 boost::scoped_array<float> gain_buffer (new float[size]);
545 /* reduce size so that we can fill the buffer correctly (ringbuffers
546 can only handle size-1, otherwise they appear to be empty)
553 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
555 start = overwrite_sample;
556 samplecnt_t cnt = size;
558 /* to fill the buffer without resetting the playback sample, we need to
559 do it one or two chunks (normally two).
561 |----------------------------------------------------------------------|
565 |<- second chunk->||<----------------- first chunk ------------------>|
569 samplecnt_t to_read = size - overwrite_offset;
571 if (audio_read ((*chan)->rbuf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
572 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"),
573 id(), size, playback_sample) << endmsg;
581 if (audio_read ((*chan)->rbuf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
582 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"),
583 id(), size, playback_sample) << endmsg;
595 if (_midi_buf && _playlists[DataType::MIDI]) {
597 /* Clear the playback buffer contents. This is safe as long as the butler
598 thread is suspended, which it should be.
601 _midi_buf->reset_tracker ();
603 g_atomic_int_set (&_samples_read_from_ringbuffer, 0);
604 g_atomic_int_set (&_samples_written_to_ringbuffer, 0);
606 /* Resolve all currently active notes in the playlist. This is more
607 aggressive than it needs to be: ideally we would only resolve what is
608 absolutely necessary, but this seems difficult and/or impossible without
609 having the old data or knowing what change caused the overwrite.
611 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_sample);
613 midi_read (overwrite_sample, _chunk_samples, false);
614 file_sample[DataType::MIDI] = overwrite_sample; // overwrite_sample was adjusted by ::midi_read() to the new position
617 _pending_overwrite = false;
623 DiskReader::seek (samplepos_t sample, bool complete_refill)
627 ChannelList::iterator chan;
628 boost::shared_ptr<ChannelList> c = channels.reader();
630 //sample = std::max ((samplecnt_t)0, sample -_session.worst_output_latency ());
632 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
633 (*chan)->rbuf->reset ();
636 if (g_atomic_int_get (&_samples_read_from_ringbuffer) == 0) {
637 /* we haven't read anything since the last seek,
638 so flush all note trackers to prevent
647 g_atomic_int_set(&_samples_read_from_ringbuffer, 0);
648 g_atomic_int_set(&_samples_written_to_ringbuffer, 0);
650 playback_sample = sample;
651 file_sample[DataType::AUDIO] = sample;
652 file_sample[DataType::MIDI] = sample;
654 if (complete_refill) {
655 /* call _do_refill() to refill the entire buffer, using
656 the largest reads possible.
658 while ((ret = do_refill_with_alloc (false)) > 0) ;
660 /* call _do_refill() to refill just one chunk, and then
663 ret = do_refill_with_alloc (true);
671 DiskReader::can_internal_playback_seek (samplecnt_t distance)
675 ChannelList::iterator chan;
676 boost::shared_ptr<ChannelList> c = channels.reader();
678 for (chan = c->begin(); chan != c->end(); ++chan) {
679 if ((*chan)->rbuf->read_space() < (size_t) distance) {
686 uint32_t samples_read = g_atomic_int_get(&_samples_read_from_ringbuffer);
687 uint32_t samples_written = g_atomic_int_get(&_samples_written_to_ringbuffer);
689 return ((samples_written - samples_read) < distance);
693 DiskReader::internal_playback_seek (samplecnt_t distance)
695 ChannelList::iterator chan;
696 boost::shared_ptr<ChannelList> c = channels.reader();
698 for (chan = c->begin(); chan != c->end(); ++chan) {
699 (*chan)->rbuf->increment_read_ptr (::llabs(distance));
702 playback_sample += distance;
708 void swap_by_ptr (Sample *first, Sample *last)
710 while (first < last) {
717 /** Read some data for 1 channel from our playlist into a buffer.
718 * @param buf Buffer to write to.
719 * @param start Session sample to start reading from; updated to where we end up
721 * @param cnt Count of samples to read.
722 * @param reversed true if we are running backwards, otherwise false.
725 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
726 samplepos_t& start, samplecnt_t cnt,
727 int channel, bool reversed)
729 samplecnt_t this_read = 0;
731 samplepos_t loop_end = 0;
732 samplepos_t loop_start = 0;
733 samplecnt_t offset = 0;
736 if (!_playlists[DataType::AUDIO]) {
737 memset (buf, 0, sizeof (Sample) * cnt);
741 /* XXX we don't currently play loops in reverse. not sure why */
745 samplecnt_t loop_length = 0;
747 /* Make the use of a Location atomic for this read operation.
749 Note: Locations don't get deleted, so all we care about
750 when I say "atomic" is that we are always pointing to
751 the same one and using a start/length values obtained
755 if ((loc = _loop_location) != 0) {
756 loop_start = loc->start();
757 loop_end = loc->end();
758 loop_length = loop_end - loop_start;
761 /* if we are looping, ensure that the first sample we read is at the correct
762 position within the loop.
765 if (loc && start >= loop_end) {
766 start = loop_start + ((start - loop_start) % loop_length);
775 /* We need this while loop in case we hit a loop boundary, in which case our read from
776 the playlist must be split into more than one section.
781 /* take any loop into account. we can't read past the end of the loop. */
783 if (loc && (loop_end - start < cnt)) {
784 this_read = loop_end - start;
791 if (this_read == 0) {
795 this_read = min(cnt,this_read);
797 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
798 error << string_compose(_("DiskReader %1: cannot read %2 from playlist at sample %3"), id(), this_read,
805 swap_by_ptr (buf, buf + this_read - 1);
809 /* if we read to the end of the loop, go back to the beginning */
826 DiskReader::_do_refill_with_alloc (bool partial_fill)
828 /* We limit disk reads to at most 4MB chunks, which with floating point
829 samples would be 1M samples. But we might use 16 or 14 bit samples,
830 in which case 4MB is more samples than that. Therefore size this for
831 the smallest sample value .. 4MB = 2M samples (16 bit).
835 boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
836 boost::scoped_array<float> gain_buf (new float[2*1048576]);
838 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0));
845 return refill_midi ();
849 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
851 int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
857 return refill_midi ();
861 /** Get some more data from disk and put it in our channels' bufs,
862 * if there is suitable space in them.
864 * If fill_level is non-zero, then we will refill the buffer so that there is
865 * still at least fill_level samples of space left to be filled. This is used
866 * after locates so that we do not need to wait to fill the entire buffer.
871 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
873 /* do not read from disk while session is marked as Loading, to avoid
874 useless redundant I/O.
877 if (_session.loading()) {
883 RingBufferNPT<Sample>::rw_vector vector;
884 bool const reversed = _session.transport_speed() < 0.0f;
885 samplecnt_t total_space;
886 samplecnt_t zero_fill;
888 ChannelList::iterator i;
889 boost::shared_ptr<ChannelList> c = channels.reader();
896 assert(mixdown_buffer);
904 c->front()->rbuf->get_write_vector (&vector);
906 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
907 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
908 /* nowhere to write to */
913 if (fill_level < total_space) {
914 total_space -= fill_level;
916 /* we can't do anything with it */
921 /* if we're running close to normal speed and there isn't enough
922 space to do disk_read_chunk_samples of I/O, then don't bother.
924 at higher speeds, just do it because the sync between butler
925 and audio thread may not be good enough.
927 Note: it is a design assumption that disk_read_chunk_samples is smaller
928 than the playback buffer size, so this check should never trip when
929 the playback buffer is empty.
932 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()));
933 if ((total_space < _chunk_samples) && fabs (_session.transport_speed()) < 2.0f) {
937 /* when slaved, don't try to get too close to the read pointer. this
938 leaves space for the buffer reversal to have something useful to
942 if (_slaved && total_space < (samplecnt_t) (c->front()->rbuf->bufsize() / 2)) {
943 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
947 samplepos_t ffa = file_sample[DataType::AUDIO];
953 /* at start: nothing to do but fill with silence */
955 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
957 ChannelInfo* chan (*i);
958 chan->rbuf->get_write_vector (&vector);
959 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
961 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
963 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
968 if (ffa < total_space) {
970 /* too close to the start: read what we can,
971 and then zero fill the rest
974 zero_fill = total_space - ffa;
984 if (ffa == max_samplepos) {
986 /* at end: nothing to do but fill with silence */
988 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
990 ChannelInfo* chan (*i);
991 chan->rbuf->get_write_vector (&vector);
992 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
994 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
996 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
1001 if (ffa > max_samplepos - total_space) {
1003 /* to close to the end: read what we can, and zero fill the rest */
1005 zero_fill = total_space - (max_samplepos - ffa);
1006 total_space = max_samplepos - ffa;
1013 samplepos_t file_sample_tmp = 0;
1015 /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
1017 const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
1018 size_t total_bytes = total_space * bits_per_sample / 8;
1020 /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
1022 size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
1024 /* find nearest (lower) multiple of 16384 */
1026 byte_size_for_read = (byte_size_for_read / 16384) * 16384;
1028 /* now back to samples */
1030 samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
1032 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
1034 // uint64_t before = g_get_monotonic_time ();
1035 // uint64_t elapsed;
1037 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1039 ChannelInfo* chan (*i);
1042 samplecnt_t len1, len2;
1044 chan->rbuf->get_write_vector (&vector);
1046 if ((samplecnt_t) vector.len[0] > samples_to_read) {
1048 /* we're not going to fill the first chunk, so certainly do not bother with the
1049 other part. it won't be connected with the part we do fill, as in:
1051 .... => writable space
1052 ++++ => readable space
1053 ^^^^ => 1 x disk_read_chunk_samples that would be filled
1055 |......|+++++++++++++|...............................|
1060 So, just pretend that the buf1 part isn't there.
1070 file_sample_tmp = ffa;
1072 buf1 = vector.buf[0];
1073 len1 = vector.len[0];
1074 buf2 = vector.buf[1];
1075 len2 = vector.len[1];
1077 to_read = min (ts, len1);
1078 to_read = min (to_read, (samplecnt_t) samples_to_read);
1080 assert (to_read >= 0);
1084 if (audio_read (buf1, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1088 chan->rbuf->increment_write_ptr (to_read);
1092 to_read = min (ts, len2);
1096 /* we read all of vector.len[0], but it wasn't the
1097 entire samples_to_read of data, so read some or
1098 all of vector.len[1] as well.
1101 if (audio_read (buf2, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1106 chan->rbuf->increment_write_ptr (to_read);
1110 /* XXX: do something */
1115 // elapsed = g_get_monotonic_time () - before;
1116 // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1118 file_sample[DataType::AUDIO] = file_sample_tmp;
1119 assert (file_sample[DataType::AUDIO] >= 0);
1121 ret = ((total_space - samples_to_read) > _chunk_samples);
1123 c->front()->rbuf->get_write_vector (&vector);
1130 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > const & movements_samples, bool from_undo)
1132 /* If we're coming from an undo, it will have handled
1133 automation undo (it must, since automation-follows-regions
1134 can lose automation data). Hence we can do nothing here.
1141 if (!_route || Config->get_automation_follows_regions () == false) {
1145 list< Evoral::RangeMove<double> > movements;
1147 for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
1148 i != movements_samples.end();
1151 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1154 /* move panner automation */
1155 boost::shared_ptr<Pannable> pannable = _route->pannable();
1156 Evoral::ControlSet::Controls& c (pannable->controls());
1158 for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1159 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1163 boost::shared_ptr<AutomationList> alist = ac->alist();
1164 if (!alist->size()) {
1167 XMLNode & before = alist->get_state ();
1168 bool const things_moved = alist->move_ranges (movements);
1170 _session.add_command (new MementoCommand<AutomationList> (
1171 *alist.get(), &before, &alist->get_state ()));
1174 /* move processor automation */
1175 _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples));
1179 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
1181 boost::shared_ptr<Processor> processor (p.lock ());
1186 list< Evoral::RangeMove<double> > movements;
1187 for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) {
1188 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1191 set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1193 for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1194 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1198 XMLNode & before = al->get_state ();
1199 bool const things_moved = al->move_ranges (movements);
1201 _session.add_command (
1202 new MementoCommand<AutomationList> (
1203 *al.get(), &before, &al->get_state ()
1211 DiskReader::reset_tracker ()
1214 _midi_buf->reset_tracker ();
1217 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1220 mp->reset_note_trackers ();
1225 DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
1228 _midi_buf->resolve_tracker(buffer, time);
1231 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1234 mp->reset_note_trackers ();
1238 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1239 * so that an event at playback_sample has time = 0
1242 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)
1245 samplepos_t nframes = end_sample - start_sample;
1249 if ((ms & MonitoringInput) == 0) {
1250 /* Route::process_output_buffers() clears the buffer as-needed */
1253 target = &scratch_bufs.get_midi (0);
1256 if (ms & MonitoringDisk) {
1257 /* disk data needed */
1259 Location* loc = _loop_location;
1261 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1262 "%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name,
1263 _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), start_sample, end_sample,
1264 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes, Port::port_offset()));
1266 //cerr << "======== PRE ========\n";
1267 //_midi_buf->dump (cerr);
1268 //cerr << "----------------\n";
1270 size_t events_read = 0;
1273 samplepos_t effective_start;
1275 Evoral::Range<samplepos_t> loop_range (loc->start(), loc->end() - 1);
1276 effective_start = loop_range.squish (start_sample);
1278 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1280 if (effective_start == loc->start()) {
1281 /* We need to turn off notes that may extend
1282 beyond the loop end.
1285 _midi_buf->resolve_tracker (*target, 0);
1288 /* for split-cycles we need to offset the events */
1290 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1292 /* end of loop is within the range we are reading, so
1293 split the read in two, and lie about the location
1297 samplecnt_t first, second;
1299 first = loc->end() - effective_start;
1300 second = nframes - first;
1302 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n",
1303 effective_start, loc->end(), first, second));
1306 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1307 effective_start, first));
1308 events_read = _midi_buf->read (*target, effective_start, first);
1312 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1313 loc->start(), second));
1314 events_read += _midi_buf->read (*target, loc->start(), second);
1318 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1319 effective_start, nframes));
1320 events_read = _midi_buf->read (*target, effective_start, effective_start + nframes);
1323 const size_t n_skipped = _midi_buf->skip_to (start_sample);
1324 if (n_skipped > 0) {
1325 warning << string_compose(_("MidiDiskstream %1: skipped %2 events, possible underflow"), id(), n_skipped) << endmsg;
1327 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("playback buffer read, from %1 to %2 (%3)", start_sample, end_sample, nframes));
1328 events_read = _midi_buf->read (*target, start_sample, end_sample, Port::port_offset ());
1331 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1332 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1333 _name, events_read, playback_sample, playback_sample + nframes,
1334 _midi_buf->read_space(), _midi_buf->write_space(),
1335 _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr()));
1338 g_atomic_int_add (&_samples_read_from_ringbuffer, nframes);
1341 if (speed != 0.0 && fabsf (speed) != 1.0f) {
1342 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1343 MidiBuffer::TimeType *tme = i.timeptr();
1344 // XXX need to subtract port offsets before scaling
1345 // also we must only scale events read from disk
1346 // and not existing input data in the buffer.
1347 *tme = (*tme) * nframes / disk_samples_to_consume;
1351 if (ms & MonitoringInput) {
1352 dst.merge_from (*target, nframes);
1356 if (!target->empty ()) {
1357 cerr << "======== MIDI OUT ========\n";
1358 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1359 const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
1360 cerr << "MIDI EVENT (from disk) @ " << ev.time();
1361 for (size_t xx = 0; xx < ev.size(); ++xx) {
1362 cerr << ' ' << hex << (int) ev.buffer()[xx];
1364 cerr << dec << endl;
1366 cerr << "----------------\n";
1370 cerr << "======== MIDI Disk Buffer ========\n";
1371 _midi_buf->dump (cerr);
1372 cerr << "----------------\n";
1376 /** @a start is set to the new sample position (TIME) read up to */
1378 DiskReader::midi_read (samplepos_t& start, samplecnt_t dur, bool reversed)
1380 samplecnt_t this_read = 0;
1381 samplepos_t loop_end = 0;
1382 samplepos_t loop_start = 0;
1383 samplecnt_t loop_length = 0;
1384 Location* loc = _loop_location;
1385 samplepos_t effective_start = start;
1386 Evoral::Range<samplepos_t>* loop_range (0);
1390 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS::midi_read @ %1 cnt %2\n", start, dur));
1392 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
1393 MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0;
1394 sampleoffset_t loop_offset = 0;
1396 if (!reversed && loc) {
1397 get_location_times (loc, &loop_start, &loop_end, &loop_length);
1402 /* take any loop into account. we can't read past the end of the loop. */
1404 if (loc && !reversed) {
1407 loop_range = new Evoral::Range<samplepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
1410 /* if we are (seamlessly) looping, ensure that the first sample we read is at the correct
1411 position within the loop.
1414 effective_start = loop_range->squish (effective_start);
1416 if ((loop_end - effective_start) <= dur) {
1417 /* too close to end of loop to read "dur", so
1420 this_read = loop_end - effective_start;
1429 if (this_read == 0) {
1433 this_read = min (dur,this_read);
1435 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset));
1437 if (midi_playlist()->read (*_midi_buf, effective_start, this_read, loop_range, 0, filter) != this_read) {
1438 error << string_compose(
1439 _("MidiDiskstream %1: cannot read %2 from playlist at sample %3"),
1440 id(), this_read, start) << endmsg;
1444 g_atomic_int_add (&_samples_written_to_ringbuffer, this_read);
1448 // Swap note ons with note offs here. etc?
1449 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
1450 // CC values etc. hard.
1454 /* adjust passed-by-reference argument (note: this is
1455 monotonic and does not reflect looping.
1459 /* similarly adjust effective_start, but this may be
1460 readjusted for seamless looping as we continue around
1463 effective_start += this_read;
1473 DiskReader::refill_midi ()
1475 if (!_playlists[DataType::MIDI] || !_midi_buf) {
1479 const size_t write_space = _midi_buf->write_space();
1480 const bool reversed = _session.transport_speed() < 0.0f;
1482 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file sample = %2\n", write_space, file_sample[DataType::MIDI]));
1484 /* no space to write */
1485 if (write_space == 0) {
1493 /* at end: nothing to do */
1495 samplepos_t ffm = file_sample[DataType::MIDI];
1497 if (ffm == max_samplepos) {
1502 const uint32_t samples_read = g_atomic_int_get (&_samples_read_from_ringbuffer);
1503 const uint32_t samples_written = g_atomic_int_get (&_samples_written_to_ringbuffer);
1505 if ((samples_read < samples_written) && (samples_written - samples_read) >= midi_readahead) {
1509 samplecnt_t to_read = midi_readahead - ((samplecnt_t)samples_written - (samplecnt_t)samples_read);
1511 to_read = min (to_read, (samplecnt_t) (max_samplepos - ffm));
1512 to_read = min (to_read, (samplecnt_t) write_space);
1514 if (midi_read (ffm, to_read, reversed)) {
1518 file_sample[DataType::MIDI] = ffm;
1524 DiskReader::set_no_disk_output (bool yn)
1526 /* this MUST be called as part of the process call tree, before any
1527 disk readers are invoked. We use it when the session needs the
1528 transport (and thus effective read position for DiskReaders) to keep
1529 advancing as part of syncing up with a transport master, but we
1530 don't want any actual disk output yet because we are still not
1533 _no_disk_output = yn;