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 ();
78 DiskReader::ReaderChannelInfo::resize (samplecnt_t bufsize)
81 /* touch memory to lock it */
82 rbuf = new RingBufferNPT<Sample> (bufsize);
83 memset (rbuf->buffer(), 0, sizeof (Sample) * rbuf->bufsize());
87 DiskReader::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t 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",
93 c->back()->rbuf->write_space(),
94 c->back()->rbuf->read_space()));
101 DiskReader::allocate_working_buffers()
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.
108 _mixdown_buffer = new Sample[2*1048576];
109 _gain_buffer = new gain_t[2*1048576];
113 DiskReader::free_working_buffers()
115 delete [] _mixdown_buffer;
116 delete [] _gain_buffer;
122 DiskReader::default_chunk_samples()
128 DiskReader::set_name (string const & str)
130 string my_name = X_("player:");
133 if (_name != my_name) {
134 SessionObject::set_name (my_name);
143 XMLNode& node (DiskIOProcessor::state ());
144 node.set_property(X_("type"), X_("diskreader"));
149 DiskReader::set_state (const XMLNode& node, int version)
151 if (DiskIOProcessor::set_state (node, version)) {
159 DiskReader::realtime_handle_transport_stopped ()
164 DiskReader::realtime_locate ()
169 DiskReader::buffer_load () const
171 /* Note: for MIDI it's not trivial to differentiate the following two cases:
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.
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.
181 boost::shared_ptr<ChannelList> c = channels.reader();
184 /* no channels, so no buffers, so completely full and ready to playback, sir! */
188 PBD::RingBufferNPT<Sample>* b = c->front()->rbuf;
189 return (float) ((double) b->read_space() / (double) b->bufsize());
193 DiskReader::adjust_buffering ()
195 boost::shared_ptr<ChannelList> c = channels.reader();
197 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
198 (*chan)->resize (_session.butler()->audio_diskstream_playback_buffer_size());
203 DiskReader::playlist_changed (const PropertyChange&)
205 playlist_modified ();
209 DiskReader::playlist_modified ()
211 if (!i_am_the_modifier && !overwrite_queued) {
212 _session.request_overwrite_buffer (_route);
213 overwrite_queued = true;
218 DiskReader::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist)
220 bool prior_playlist = false;
222 if (_playlists[dt]) {
223 prior_playlist = true;
226 if (DiskIOProcessor::use_playlist (dt, playlist)) {
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.
235 if (!overwrite_queued && (prior_playlist || _session.loading())) {
236 _session.request_overwrite_buffer (_route);
237 overwrite_queued = true;
244 DiskReader::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
245 double speed, pframes_t nframes, bool result_required)
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 ();
254 if (!_pending_active) {
259 if (_pending_active) {
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)
273 BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
274 const bool still_locating = _session.global_locate_pending();
277 /* do nothing with audio */
281 assert (speed == -1 || speed == 0 || speed == 1);
284 disk_samples_to_consume = -nframes;
285 } else if (speed > 0) {
286 disk_samples_to_consume = nframes;
288 disk_samples_to_consume = 0;
291 if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating || _no_disk_output) {
293 /* no need for actual disk data, just advance read pointer and return */
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);
301 /* if monitoring disk but locating put silence in the buffers */
303 if ((_no_disk_output || still_locating) && (ms == MonitoringDisk)) {
304 bufs.silence (nframes, 0);
309 /* we need audio data from disk */
311 size_t n_buffers = bufs.count().n_audio();
312 size_t n_chans = c->size();
315 if (n_chans > n_buffers) {
316 scaling = ((float) n_buffers)/n_chans;
321 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
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 */
327 if (ms & MonitoringInput) {
328 /* put disk stream in scratch buffer, blend at end */
329 disk_signal = scratch_bufs.get_audio(n).data ();
331 /* no input stream needed, just overwrite buffers */
332 disk_signal = output.data ();
336 if (start_sample < playback_sample) {
337 cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << endl;
340 } else if (speed < 0) {
341 if (playback_sample < start_sample) {
342 cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << " REVERSE" << endl;
347 if ((speed > 0) && (start_sample != playback_sample)) {
348 cerr << owner()->name() << " playback not aligned, jump ahead " << (start_sample - playback_sample) << endl;
350 if (can_internal_playback_seek (start_sample - playback_sample)) {
351 internal_playback_seek (start_sample - playback_sample);
353 cerr << owner()->name() << " playback not possible: ss = " << start_sample << " ps = " << playback_sample << endl;
358 chaninfo->rbuf->get_read_vector (&(*chan)->rw_vector);
360 if (disk_samples_to_consume <= (samplecnt_t) chaninfo->rw_vector.len[0]) {
363 memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * disk_samples_to_consume);
368 const samplecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
370 if (disk_samples_to_consume <= total) {
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));
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));
393 if (scaling != 1.0f && speed != 0.0) {
394 apply_gain_to_buffer (disk_signal, disk_samples_to_consume, scaling);
397 chaninfo->rbuf->increment_read_ptr (disk_samples_to_consume);
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);
406 /* MIDI data handling */
409 if (/*!_session.declick_out_pending() && */ bufs.count().n_midi()) {
412 if (_no_disk_output) {
413 dst = &scratch_bufs.get_midi(0);
415 dst = &bufs.get_midi (0);
418 if ((ms & MonitoringDisk) && !still_locating) {
419 get_midi_playback (*dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume);
423 if (!still_locating) {
425 bool butler_required = false;
428 playback_sample -= disk_samples_to_consume;
430 playback_sample += disk_samples_to_consume;
433 if (_playlists[DataType::AUDIO]) {
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;
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(),
444 butler_required = true;
450 if (_playlists[DataType::MIDI]) {
451 /* MIDI butler needed part */
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));
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;
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.
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).
476 * The disk-stream is now behind..
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.
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.
487 * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
490 if (samples_read <= samples_written) {
491 if ((samples_written - samples_read) + disk_samples_to_consume < midi_readahead) {
492 butler_required = true;
495 butler_required = true;
500 _need_butler = butler_required;
503 // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
507 DiskReader::set_pending_overwrite (bool yn)
509 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
511 _pending_overwrite = yn;
513 overwrite_sample = playback_sample;
515 boost::shared_ptr<ChannelList> c = channels.reader ();
517 overwrite_offset = c->front()->rbuf->get_read_ptr();
522 DiskReader::overwrite_existing_buffers ()
526 boost::shared_ptr<ChannelList> c = channels.reader();
528 overwrite_queued = false;
530 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_sample));
536 const bool reversed = _session.transport_speed() < 0.0f;
538 /* assume all are the same size */
539 samplecnt_t size = c->front()->rbuf->bufsize();
541 boost::scoped_array<Sample> mixdown_buffer (new Sample[size]);
542 boost::scoped_array<float> gain_buffer (new float[size]);
544 /* reduce size so that we can fill the buffer correctly (ringbuffers
545 can only handle size-1, otherwise they appear to be empty)
552 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
554 start = overwrite_sample;
555 samplecnt_t cnt = size;
557 /* to fill the buffer without resetting the playback sample, we need to
558 do it one or two chunks (normally two).
560 |----------------------------------------------------------------------|
564 |<- second chunk->||<----------------- first chunk ------------------>|
568 samplecnt_t to_read = size - overwrite_offset;
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;
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;
594 if (_midi_buf && _playlists[DataType::MIDI]) {
596 /* Clear the playback buffer contents. This is safe as long as the butler
597 thread is suspended, which it should be.
600 _midi_buf->reset_tracker ();
602 g_atomic_int_set (&_samples_read_from_ringbuffer, 0);
603 g_atomic_int_set (&_samples_written_to_ringbuffer, 0);
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.
610 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_sample);
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
616 _pending_overwrite = false;
622 DiskReader::seek (samplepos_t sample, bool complete_refill)
626 ChannelList::iterator chan;
627 boost::shared_ptr<ChannelList> c = channels.reader();
629 //sample = std::max ((samplecnt_t)0, sample -_session.worst_output_latency ());
631 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
632 (*chan)->rbuf->reset ();
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
644 g_atomic_int_set(&_samples_read_from_ringbuffer, 0);
645 g_atomic_int_set(&_samples_written_to_ringbuffer, 0);
647 playback_sample = sample;
648 file_sample[DataType::AUDIO] = sample;
649 file_sample[DataType::MIDI] = sample;
651 if (complete_refill) {
652 /* call _do_refill() to refill the entire buffer, using
653 the largest reads possible.
655 while ((ret = do_refill_with_alloc (false)) > 0) ;
657 /* call _do_refill() to refill just one chunk, and then
660 ret = do_refill_with_alloc (true);
668 DiskReader::can_internal_playback_seek (samplecnt_t distance)
672 ChannelList::iterator chan;
673 boost::shared_ptr<ChannelList> c = channels.reader();
675 for (chan = c->begin(); chan != c->end(); ++chan) {
676 if ((*chan)->rbuf->read_space() < (size_t) distance) {
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);
686 return ((samples_written - samples_read) < distance);
690 DiskReader::internal_playback_seek (samplecnt_t distance)
692 ChannelList::iterator chan;
693 boost::shared_ptr<ChannelList> c = channels.reader();
695 for (chan = c->begin(); chan != c->end(); ++chan) {
696 (*chan)->rbuf->increment_read_ptr (::llabs(distance));
699 playback_sample += distance;
705 void swap_by_ptr (Sample *first, Sample *last)
707 while (first < last) {
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
718 * @param cnt Count of samples to read.
719 * @param reversed true if we are running backwards, otherwise false.
722 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
723 samplepos_t& start, samplecnt_t cnt,
724 int channel, bool reversed)
726 samplecnt_t this_read = 0;
728 samplepos_t loop_end = 0;
729 samplepos_t loop_start = 0;
730 samplecnt_t offset = 0;
733 if (!_playlists[DataType::AUDIO]) {
734 memset (buf, 0, sizeof (Sample) * cnt);
738 /* XXX we don't currently play loops in reverse. not sure why */
742 samplecnt_t loop_length = 0;
744 /* Make the use of a Location atomic for this read operation.
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
752 if ((loc = _loop_location) != 0) {
753 loop_start = loc->start();
754 loop_end = loc->end();
755 loop_length = loop_end - loop_start;
758 /* if we are looping, ensure that the first sample we read is at the correct
759 position within the loop.
762 if (loc && start >= loop_end) {
763 start = loop_start + ((start - loop_start) % loop_length);
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.
778 /* take any loop into account. we can't read past the end of the loop. */
780 if (loc && (loop_end - start < cnt)) {
781 this_read = loop_end - start;
788 if (this_read == 0) {
792 this_read = min(cnt,this_read);
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,
802 swap_by_ptr (buf, buf + this_read - 1);
806 /* if we read to the end of the loop, go back to the beginning */
823 DiskReader::_do_refill_with_alloc (bool partial_fill)
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).
832 boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
833 boost::scoped_array<float> gain_buf (new float[2*1048576]);
835 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0));
842 return refill_midi ();
846 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
848 int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
854 return refill_midi ();
858 /** Get some more data from disk and put it in our channels' bufs,
859 * if there is suitable space in them.
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.
868 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
870 /* do not read from disk while session is marked as Loading, to avoid
871 useless redundant I/O.
874 if (_session.loading()) {
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;
885 ChannelList::iterator i;
886 boost::shared_ptr<ChannelList> c = channels.reader();
893 assert(mixdown_buffer);
901 c->front()->rbuf->get_write_vector (&vector);
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 */
910 if (fill_level < total_space) {
911 total_space -= fill_level;
913 /* we can't do anything with it */
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.
921 at higher speeds, just do it because the sync between butler
922 and audio thread may not be good enough.
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.
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) {
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
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));
944 samplepos_t ffa = file_sample[DataType::AUDIO];
950 /* at start: nothing to do but fill with silence */
952 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
954 ChannelInfo* chan (*i);
955 chan->rbuf->get_write_vector (&vector);
956 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
958 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
960 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
965 if (ffa < total_space) {
967 /* too close to the start: read what we can,
968 and then zero fill the rest
971 zero_fill = total_space - ffa;
981 if (ffa == max_samplepos) {
983 /* at end: nothing to do but fill with silence */
985 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
987 ChannelInfo* chan (*i);
988 chan->rbuf->get_write_vector (&vector);
989 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
991 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
993 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
998 if (ffa > max_samplepos - total_space) {
1000 /* to close to the end: read what we can, and zero fill the rest */
1002 zero_fill = total_space - (max_samplepos - ffa);
1003 total_space = max_samplepos - ffa;
1010 samplepos_t file_sample_tmp = 0;
1012 /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
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;
1017 /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
1019 size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
1021 /* find nearest (lower) multiple of 16384 */
1023 byte_size_for_read = (byte_size_for_read / 16384) * 16384;
1025 /* now back to samples */
1027 samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
1029 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
1031 // uint64_t before = g_get_monotonic_time ();
1032 // uint64_t elapsed;
1034 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1036 ChannelInfo* chan (*i);
1039 samplecnt_t len1, len2;
1041 chan->rbuf->get_write_vector (&vector);
1043 if ((samplecnt_t) vector.len[0] > samples_to_read) {
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:
1048 .... => writable space
1049 ++++ => readable space
1050 ^^^^ => 1 x disk_read_chunk_samples that would be filled
1052 |......|+++++++++++++|...............................|
1057 So, just pretend that the buf1 part isn't there.
1067 file_sample_tmp = ffa;
1069 buf1 = vector.buf[0];
1070 len1 = vector.len[0];
1071 buf2 = vector.buf[1];
1072 len2 = vector.len[1];
1074 to_read = min (ts, len1);
1075 to_read = min (to_read, (samplecnt_t) samples_to_read);
1077 assert (to_read >= 0);
1081 if (audio_read (buf1, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1085 chan->rbuf->increment_write_ptr (to_read);
1089 to_read = min (ts, len2);
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.
1098 if (audio_read (buf2, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1103 chan->rbuf->increment_write_ptr (to_read);
1107 /* XXX: do something */
1112 // elapsed = g_get_monotonic_time () - before;
1113 // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1115 file_sample[DataType::AUDIO] = file_sample_tmp;
1116 assert (file_sample[DataType::AUDIO] >= 0);
1118 ret = ((total_space - samples_to_read) > _chunk_samples);
1120 c->front()->rbuf->get_write_vector (&vector);
1127 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > const & movements_samples, bool from_undo)
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.
1138 if (!_route || Config->get_automation_follows_regions () == false) {
1142 list< Evoral::RangeMove<double> > movements;
1144 for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
1145 i != movements_samples.end();
1148 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1151 /* move panner automation */
1152 boost::shared_ptr<Pannable> pannable = _route->pannable();
1153 Evoral::ControlSet::Controls& c (pannable->controls());
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);
1160 boost::shared_ptr<AutomationList> alist = ac->alist();
1161 if (!alist->size()) {
1164 XMLNode & before = alist->get_state ();
1165 bool const things_moved = alist->move_ranges (movements);
1167 _session.add_command (new MementoCommand<AutomationList> (
1168 *alist.get(), &before, &alist->get_state ()));
1171 /* move processor automation */
1172 _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples));
1176 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
1178 boost::shared_ptr<Processor> processor (p.lock ());
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));
1188 set<Evoral::Parameter> const a = processor->what_can_be_automated ();
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();
1195 XMLNode & before = al->get_state ();
1196 bool const things_moved = al->move_ranges (movements);
1198 _session.add_command (
1199 new MementoCommand<AutomationList> (
1200 *al.get(), &before, &al->get_state ()
1208 DiskReader::reset_tracker ()
1210 _midi_buf->reset_tracker ();
1212 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1215 mp->reset_note_trackers ();
1220 DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
1222 _midi_buf->resolve_tracker(buffer, time);
1224 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1227 mp->reset_note_trackers ();
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
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)
1238 samplepos_t nframes = end_sample - start_sample;
1240 if ((ms & MonitoringInput) == 0) {
1241 /* Route::process_output_buffers() clears the buffer as-needed */
1244 target = &scratch_bufs.get_midi (0);
1247 if (ms & MonitoringDisk) {
1248 /* disk data needed */
1250 Location* loc = _loop_location;
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()));
1257 //cerr << "======== PRE ========\n";
1258 //_midi_buf->dump (cerr);
1259 //cerr << "----------------\n";
1261 size_t events_read = 0;
1264 samplepos_t effective_start;
1266 Evoral::Range<samplepos_t> loop_range (loc->start(), loc->end() - 1);
1267 effective_start = loop_range.squish (start_sample);
1269 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1271 if (effective_start == loc->start()) {
1272 /* We need to turn off notes that may extend
1273 beyond the loop end.
1276 _midi_buf->resolve_tracker (*target, 0);
1279 /* for split-cycles we need to offset the events */
1281 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1283 /* end of loop is within the range we are reading, so
1284 split the read in two, and lie about the location
1288 samplecnt_t first, second;
1290 first = loc->end() - effective_start;
1291 second = nframes - first;
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));
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);
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);
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);
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;
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 ());
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()));
1329 g_atomic_int_add (&_samples_read_from_ringbuffer, nframes);
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;
1342 if (ms & MonitoringInput) {
1343 dst.merge_from (*target, nframes);
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];
1355 cerr << dec << endl;
1357 cerr << "----------------\n";
1361 cerr << "======== MIDI Disk Buffer ========\n";
1362 _midi_buf->dump (cerr);
1363 cerr << "----------------\n";
1367 /** @a start is set to the new sample position (TIME) read up to */
1369 DiskReader::midi_read (samplepos_t& start, samplecnt_t dur, bool reversed)
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);
1379 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS::midi_read @ %1 cnt %2\n", start, dur));
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;
1385 if (!reversed && loc) {
1386 get_location_times (loc, &loop_start, &loop_end, &loop_length);
1391 /* take any loop into account. we can't read past the end of the loop. */
1393 if (loc && !reversed) {
1396 loop_range = new Evoral::Range<samplepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
1399 /* if we are (seamlessly) looping, ensure that the first sample we read is at the correct
1400 position within the loop.
1403 effective_start = loop_range->squish (effective_start);
1405 if ((loop_end - effective_start) <= dur) {
1406 /* too close to end of loop to read "dur", so
1409 this_read = loop_end - effective_start;
1418 if (this_read == 0) {
1422 this_read = min (dur,this_read);
1424 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset));
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;
1433 g_atomic_int_add (&_samples_written_to_ringbuffer, this_read);
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.
1443 /* adjust passed-by-reference argument (note: this is
1444 monotonic and does not reflect looping.
1448 /* similarly adjust effective_start, but this may be
1449 readjusted for seamless looping as we continue around
1452 effective_start += this_read;
1462 DiskReader::refill_midi ()
1464 if (!_playlists[DataType::MIDI]) {
1468 const size_t write_space = _midi_buf->write_space();
1469 const bool reversed = _session.transport_speed() < 0.0f;
1471 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file sample = %2\n", write_space, file_sample[DataType::MIDI]));
1473 /* no space to write */
1474 if (write_space == 0) {
1482 /* at end: nothing to do */
1484 samplepos_t ffm = file_sample[DataType::MIDI];
1486 if (ffm == max_samplepos) {
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);
1494 if ((samples_read < samples_written) && (samples_written - samples_read) >= midi_readahead) {
1498 samplecnt_t to_read = midi_readahead - ((samplecnt_t)samples_written - (samplecnt_t)samples_read);
1500 to_read = min (to_read, (samplecnt_t) (max_samplepos - ffm));
1501 to_read = min (to_read, (samplecnt_t) write_space);
1503 if (midi_read (ffm, to_read, reversed)) {
1507 file_sample[DataType::MIDI] = ffm;
1513 DiskReader::set_no_disk_output (bool yn)
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
1522 _no_disk_output = yn;