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)) {
349 str << owner()->name() << " playback @ " << start_sample << " not aligned with " << playback_sample << " jump ahead " << (start_sample - playback_sample) << endl;
352 if (can_internal_playback_seek (start_sample - playback_sample)) {
353 internal_playback_seek (start_sample - playback_sample);
355 cerr << owner()->name() << " playback not possible: ss = " << start_sample << " ps = " << playback_sample << endl;
360 chaninfo->rbuf->get_read_vector (&(*chan)->rw_vector);
362 if (disk_samples_to_consume <= (samplecnt_t) chaninfo->rw_vector.len[0]) {
365 memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * disk_samples_to_consume);
370 const samplecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
372 if (disk_samples_to_consume <= total) {
376 chaninfo->rw_vector.buf[0],
377 chaninfo->rw_vector.len[0] * sizeof (Sample));
378 memcpy (disk_signal + chaninfo->rw_vector.len[0],
379 chaninfo->rw_vector.buf[1],
380 (disk_samples_to_consume - chaninfo->rw_vector.len[0]) * sizeof (Sample));
385 cerr << _name << " Need " << disk_samples_to_consume << " total = " << total << endl;
386 cerr << "underrun for " << _name << endl;
387 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
388 DEBUG_THREAD_SELF, name(), total));
395 if (scaling != 1.0f && speed != 0.0) {
396 apply_gain_to_buffer (disk_signal, disk_samples_to_consume, scaling);
399 chaninfo->rbuf->increment_read_ptr (disk_samples_to_consume);
401 if (ms & MonitoringInput) {
402 /* mix the disk signal into the input signal (already in bufs) */
403 mix_buffers_no_gain (output.data(), disk_signal, disk_samples_to_consume);
408 /* MIDI data handling */
411 if (/*!_session.declick_out_pending() && */ bufs.count().n_midi()) {
414 if (_no_disk_output) {
415 dst = &scratch_bufs.get_midi(0);
417 dst = &bufs.get_midi (0);
420 if ((ms & MonitoringDisk) && !still_locating) {
421 get_midi_playback (*dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume);
425 if (!still_locating) {
427 bool butler_required = false;
430 playback_sample -= disk_samples_to_consume;
432 playback_sample += disk_samples_to_consume;
435 if (_playlists[DataType::AUDIO]) {
438 if (c->front()->rbuf->write_space() >= c->front()->rbuf->bufsize() / 2) {
439 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->rbuf->write_space(), c->front()->rbuf->bufsize()));
440 butler_required = true;
443 if ((samplecnt_t) c->front()->rbuf->write_space() >= _chunk_samples) {
444 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->rbuf->write_space(),
446 butler_required = true;
452 if (_playlists[DataType::MIDI]) {
453 /* MIDI butler needed part */
455 uint32_t samples_read = g_atomic_int_get(const_cast<gint*>(&_samples_read_from_ringbuffer));
456 uint32_t samples_written = g_atomic_int_get(const_cast<gint*>(&_samples_written_to_ringbuffer));
459 cerr << name() << " MDS written: " << samples_written << " - read: " << samples_read <<
460 " = " << samples_written - samples_read
461 << " + " << disk_samples_to_consume << " < " << midi_readahead << " = " << need_butler << ")" << endl;
464 /* samples_read will generally be less than samples_written, but
465 * immediately after an overwrite, we can end up having read some data
466 * before we've written any. we don't need to trip an assert() on this,
467 * but we do need to check so that the decision on whether or not we
468 * need the butler is done correctly.
473 * Doing heavy GUI operations[1] can stall also the butler.
474 * The RT-thread meanwhile will happily continue and
475 * ‘samples_read’ (from buffer to output) will become larger
476 * than ‘samples_written’ (from disk to buffer).
478 * The disk-stream is now behind..
480 * In those cases the butler needs to be summed to refill the buffer (done now)
481 * AND we need to skip (samples_read - samples_written). ie remove old events
482 * before playback_sample from the rinbuffer.
484 * [1] one way to do so is described at #6170.
485 * For me just popping up the context-menu on a MIDI-track header
486 * of a track with a large (think beethoven :) midi-region also did the
487 * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
489 * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
492 if (samples_read <= samples_written) {
493 if ((samples_written - samples_read) + disk_samples_to_consume < midi_readahead) {
494 butler_required = true;
497 butler_required = true;
502 _need_butler = butler_required;
505 // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler));
509 DiskReader::set_pending_overwrite (bool yn)
511 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
513 _pending_overwrite = yn;
515 overwrite_sample = playback_sample;
517 boost::shared_ptr<ChannelList> c = channels.reader ();
519 overwrite_offset = c->front()->rbuf->get_read_ptr();
524 DiskReader::overwrite_existing_buffers ()
528 boost::shared_ptr<ChannelList> c = channels.reader();
530 overwrite_queued = false;
532 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_sample));
538 const bool reversed = _session.transport_speed() < 0.0f;
540 /* assume all are the same size */
541 samplecnt_t size = c->front()->rbuf->bufsize();
543 boost::scoped_array<Sample> mixdown_buffer (new Sample[size]);
544 boost::scoped_array<float> gain_buffer (new float[size]);
546 /* reduce size so that we can fill the buffer correctly (ringbuffers
547 can only handle size-1, otherwise they appear to be empty)
554 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
556 start = overwrite_sample;
557 samplecnt_t cnt = size;
559 /* to fill the buffer without resetting the playback sample, we need to
560 do it one or two chunks (normally two).
562 |----------------------------------------------------------------------|
566 |<- second chunk->||<----------------- first chunk ------------------>|
570 samplecnt_t to_read = size - overwrite_offset;
572 if (audio_read ((*chan)->rbuf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) {
573 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"),
574 id(), size, playback_sample) << endmsg;
582 if (audio_read ((*chan)->rbuf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
583 error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"),
584 id(), size, playback_sample) << endmsg;
596 if (_midi_buf && _playlists[DataType::MIDI]) {
598 /* Clear the playback buffer contents. This is safe as long as the butler
599 thread is suspended, which it should be.
602 _midi_buf->reset_tracker ();
604 g_atomic_int_set (&_samples_read_from_ringbuffer, 0);
605 g_atomic_int_set (&_samples_written_to_ringbuffer, 0);
607 /* Resolve all currently active notes in the playlist. This is more
608 aggressive than it needs to be: ideally we would only resolve what is
609 absolutely necessary, but this seems difficult and/or impossible without
610 having the old data or knowing what change caused the overwrite.
612 midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_sample);
614 midi_read (overwrite_sample, _chunk_samples, false);
615 file_sample[DataType::MIDI] = overwrite_sample; // overwrite_sample was adjusted by ::midi_read() to the new position
618 _pending_overwrite = false;
624 DiskReader::seek (samplepos_t sample, bool complete_refill)
628 ChannelList::iterator chan;
629 boost::shared_ptr<ChannelList> c = channels.reader();
631 //sample = std::max ((samplecnt_t)0, sample -_session.worst_output_latency ());
633 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
634 (*chan)->rbuf->reset ();
637 if (g_atomic_int_get (&_samples_read_from_ringbuffer) == 0) {
638 /* we haven't read anything since the last seek,
639 so flush all note trackers to prevent
646 g_atomic_int_set(&_samples_read_from_ringbuffer, 0);
647 g_atomic_int_set(&_samples_written_to_ringbuffer, 0);
649 playback_sample = sample;
650 file_sample[DataType::AUDIO] = sample;
651 file_sample[DataType::MIDI] = sample;
653 if (complete_refill) {
654 /* call _do_refill() to refill the entire buffer, using
655 the largest reads possible.
657 while ((ret = do_refill_with_alloc (false)) > 0) ;
659 /* call _do_refill() to refill just one chunk, and then
662 ret = do_refill_with_alloc (true);
670 DiskReader::can_internal_playback_seek (samplecnt_t distance)
674 ChannelList::iterator chan;
675 boost::shared_ptr<ChannelList> c = channels.reader();
677 for (chan = c->begin(); chan != c->end(); ++chan) {
678 if ((*chan)->rbuf->read_space() < (size_t) distance) {
685 uint32_t samples_read = g_atomic_int_get(&_samples_read_from_ringbuffer);
686 uint32_t samples_written = g_atomic_int_get(&_samples_written_to_ringbuffer);
688 return ((samples_written - samples_read) < distance);
692 DiskReader::internal_playback_seek (samplecnt_t distance)
694 ChannelList::iterator chan;
695 boost::shared_ptr<ChannelList> c = channels.reader();
697 for (chan = c->begin(); chan != c->end(); ++chan) {
698 (*chan)->rbuf->increment_read_ptr (::llabs(distance));
701 playback_sample += distance;
707 void swap_by_ptr (Sample *first, Sample *last)
709 while (first < last) {
716 /** Read some data for 1 channel from our playlist into a buffer.
717 * @param buf Buffer to write to.
718 * @param start Session sample to start reading from; updated to where we end up
720 * @param cnt Count of samples to read.
721 * @param reversed true if we are running backwards, otherwise false.
724 DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
725 samplepos_t& start, samplecnt_t cnt,
726 int channel, bool reversed)
728 samplecnt_t this_read = 0;
730 samplepos_t loop_end = 0;
731 samplepos_t loop_start = 0;
732 samplecnt_t offset = 0;
735 if (!_playlists[DataType::AUDIO]) {
736 memset (buf, 0, sizeof (Sample) * cnt);
740 /* XXX we don't currently play loops in reverse. not sure why */
744 samplecnt_t loop_length = 0;
746 /* Make the use of a Location atomic for this read operation.
748 Note: Locations don't get deleted, so all we care about
749 when I say "atomic" is that we are always pointing to
750 the same one and using a start/length values obtained
754 if ((loc = _loop_location) != 0) {
755 loop_start = loc->start();
756 loop_end = loc->end();
757 loop_length = loop_end - loop_start;
760 /* if we are looping, ensure that the first sample we read is at the correct
761 position within the loop.
764 if (loc && start >= loop_end) {
765 start = loop_start + ((start - loop_start) % loop_length);
774 /* We need this while loop in case we hit a loop boundary, in which case our read from
775 the playlist must be split into more than one section.
780 /* take any loop into account. we can't read past the end of the loop. */
782 if (loc && (loop_end - start < cnt)) {
783 this_read = loop_end - start;
790 if (this_read == 0) {
794 this_read = min(cnt,this_read);
796 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
797 error << string_compose(_("DiskReader %1: cannot read %2 from playlist at sample %3"), id(), this_read,
804 swap_by_ptr (buf, buf + this_read - 1);
808 /* if we read to the end of the loop, go back to the beginning */
825 DiskReader::_do_refill_with_alloc (bool partial_fill)
827 /* We limit disk reads to at most 4MB chunks, which with floating point
828 samples would be 1M samples. But we might use 16 or 14 bit samples,
829 in which case 4MB is more samples than that. Therefore size this for
830 the smallest sample value .. 4MB = 2M samples (16 bit).
834 boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
835 boost::scoped_array<float> gain_buf (new float[2*1048576]);
837 int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0));
844 return refill_midi ();
848 DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
850 int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level);
856 return refill_midi ();
860 /** Get some more data from disk and put it in our channels' bufs,
861 * if there is suitable space in them.
863 * If fill_level is non-zero, then we will refill the buffer so that there is
864 * still at least fill_level samples of space left to be filled. This is used
865 * after locates so that we do not need to wait to fill the entire buffer.
870 DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level)
872 /* do not read from disk while session is marked as Loading, to avoid
873 useless redundant I/O.
876 if (_session.loading()) {
882 RingBufferNPT<Sample>::rw_vector vector;
883 bool const reversed = _session.transport_speed() < 0.0f;
884 samplecnt_t total_space;
885 samplecnt_t zero_fill;
887 ChannelList::iterator i;
888 boost::shared_ptr<ChannelList> c = channels.reader();
895 assert(mixdown_buffer);
903 c->front()->rbuf->get_write_vector (&vector);
905 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
906 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
907 /* nowhere to write to */
912 if (fill_level < total_space) {
913 total_space -= fill_level;
915 /* we can't do anything with it */
920 /* if we're running close to normal speed and there isn't enough
921 space to do disk_read_chunk_samples of I/O, then don't bother.
923 at higher speeds, just do it because the sync between butler
924 and audio thread may not be good enough.
926 Note: it is a design assumption that disk_read_chunk_samples is smaller
927 than the playback buffer size, so this check should never trip when
928 the playback buffer is empty.
931 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()));
932 if ((total_space < _chunk_samples) && fabs (_session.transport_speed()) < 2.0f) {
936 /* when slaved, don't try to get too close to the read pointer. this
937 leaves space for the buffer reversal to have something useful to
941 if (_slaved && total_space < (samplecnt_t) (c->front()->rbuf->bufsize() / 2)) {
942 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this));
946 samplepos_t ffa = file_sample[DataType::AUDIO];
952 /* at start: nothing to do but fill with silence */
954 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
956 ChannelInfo* chan (*i);
957 chan->rbuf->get_write_vector (&vector);
958 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
960 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
962 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
967 if (ffa < total_space) {
969 /* too close to the start: read what we can,
970 and then zero fill the rest
973 zero_fill = total_space - ffa;
983 if (ffa == max_samplepos) {
985 /* at end: nothing to do but fill with silence */
987 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
989 ChannelInfo* chan (*i);
990 chan->rbuf->get_write_vector (&vector);
991 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
993 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
995 chan->rbuf->increment_write_ptr (vector.len[0] + vector.len[1]);
1000 if (ffa > max_samplepos - total_space) {
1002 /* to close to the end: read what we can, and zero fill the rest */
1004 zero_fill = total_space - (max_samplepos - ffa);
1005 total_space = max_samplepos - ffa;
1012 samplepos_t file_sample_tmp = 0;
1014 /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */
1016 const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format());
1017 size_t total_bytes = total_space * bits_per_sample / 8;
1019 /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer
1021 size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes));
1023 /* find nearest (lower) multiple of 16384 */
1025 byte_size_for_read = (byte_size_for_read / 16384) * 16384;
1027 /* now back to samples */
1029 samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8);
1031 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space));
1033 // uint64_t before = g_get_monotonic_time ();
1034 // uint64_t elapsed;
1036 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1038 ChannelInfo* chan (*i);
1041 samplecnt_t len1, len2;
1043 chan->rbuf->get_write_vector (&vector);
1045 if ((samplecnt_t) vector.len[0] > samples_to_read) {
1047 /* we're not going to fill the first chunk, so certainly do not bother with the
1048 other part. it won't be connected with the part we do fill, as in:
1050 .... => writable space
1051 ++++ => readable space
1052 ^^^^ => 1 x disk_read_chunk_samples that would be filled
1054 |......|+++++++++++++|...............................|
1059 So, just pretend that the buf1 part isn't there.
1069 file_sample_tmp = ffa;
1071 buf1 = vector.buf[0];
1072 len1 = vector.len[0];
1073 buf2 = vector.buf[1];
1074 len2 = vector.len[1];
1076 to_read = min (ts, len1);
1077 to_read = min (to_read, (samplecnt_t) samples_to_read);
1079 assert (to_read >= 0);
1083 if (audio_read (buf1, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1087 chan->rbuf->increment_write_ptr (to_read);
1091 to_read = min (ts, len2);
1095 /* we read all of vector.len[0], but it wasn't the
1096 entire samples_to_read of data, so read some or
1097 all of vector.len[1] as well.
1100 if (audio_read (buf2, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) {
1105 chan->rbuf->increment_write_ptr (to_read);
1109 /* XXX: do something */
1114 // elapsed = g_get_monotonic_time () - before;
1115 // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
1117 file_sample[DataType::AUDIO] = file_sample_tmp;
1118 assert (file_sample[DataType::AUDIO] >= 0);
1120 ret = ((total_space - samples_to_read) > _chunk_samples);
1122 c->front()->rbuf->get_write_vector (&vector);
1129 DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > const & movements_samples, bool from_undo)
1131 /* If we're coming from an undo, it will have handled
1132 automation undo (it must, since automation-follows-regions
1133 can lose automation data). Hence we can do nothing here.
1140 if (!_route || Config->get_automation_follows_regions () == false) {
1144 list< Evoral::RangeMove<double> > movements;
1146 for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
1147 i != movements_samples.end();
1150 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1153 /* move panner automation */
1154 boost::shared_ptr<Pannable> pannable = _route->pannable();
1155 Evoral::ControlSet::Controls& c (pannable->controls());
1157 for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) {
1158 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl>(ci->second);
1162 boost::shared_ptr<AutomationList> alist = ac->alist();
1163 if (!alist->size()) {
1166 XMLNode & before = alist->get_state ();
1167 bool const things_moved = alist->move_ranges (movements);
1169 _session.add_command (new MementoCommand<AutomationList> (
1170 *alist.get(), &before, &alist->get_state ()));
1173 /* move processor automation */
1174 _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples));
1178 DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
1180 boost::shared_ptr<Processor> processor (p.lock ());
1185 list< Evoral::RangeMove<double> > movements;
1186 for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) {
1187 movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
1190 set<Evoral::Parameter> const a = processor->what_can_be_automated ();
1192 for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
1193 boost::shared_ptr<AutomationList> al = processor->automation_control(*i)->alist();
1197 XMLNode & before = al->get_state ();
1198 bool const things_moved = al->move_ranges (movements);
1200 _session.add_command (
1201 new MementoCommand<AutomationList> (
1202 *al.get(), &before, &al->get_state ()
1210 DiskReader::reset_tracker ()
1212 _midi_buf->reset_tracker ();
1214 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1217 mp->reset_note_trackers ();
1222 DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
1224 _midi_buf->resolve_tracker(buffer, time);
1226 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1229 mp->reset_note_trackers ();
1233 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1234 * so that an event at playback_sample has time = 0
1237 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)
1240 samplepos_t nframes = end_sample - start_sample;
1242 if ((ms & MonitoringInput) == 0) {
1243 /* Route::process_output_buffers() clears the buffer as-needed */
1246 target = &scratch_bufs.get_midi (0);
1249 if (ms & MonitoringDisk) {
1250 /* disk data needed */
1252 Location* loc = _loop_location;
1254 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1255 "%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name,
1256 _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), start_sample, end_sample,
1257 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes, Port::port_offset()));
1259 //cerr << "======== PRE ========\n";
1260 //_midi_buf->dump (cerr);
1261 //cerr << "----------------\n";
1263 size_t events_read = 0;
1266 samplepos_t effective_start;
1268 Evoral::Range<samplepos_t> loop_range (loc->start(), loc->end() - 1);
1269 effective_start = loop_range.squish (start_sample);
1271 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1273 if (effective_start == loc->start()) {
1274 /* We need to turn off notes that may extend
1275 beyond the loop end.
1278 _midi_buf->resolve_tracker (*target, 0);
1281 /* for split-cycles we need to offset the events */
1283 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1285 /* end of loop is within the range we are reading, so
1286 split the read in two, and lie about the location
1290 samplecnt_t first, second;
1292 first = loc->end() - effective_start;
1293 second = nframes - first;
1295 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n",
1296 effective_start, loc->end(), first, second));
1299 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1300 effective_start, first));
1301 events_read = _midi_buf->read (*target, effective_start, first);
1305 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1306 loc->start(), second));
1307 events_read += _midi_buf->read (*target, loc->start(), second);
1311 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1312 effective_start, nframes));
1313 events_read = _midi_buf->read (*target, effective_start, effective_start + nframes);
1316 const size_t n_skipped = _midi_buf->skip_to (start_sample);
1317 if (n_skipped > 0) {
1318 warning << string_compose(_("MidiDiskstream %1: skipped %2 events, possible underflow"), id(), n_skipped) << endmsg;
1320 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("playback buffer read, from %1 to %2 (%3)", start_sample, end_sample, nframes));
1321 events_read = _midi_buf->read (*target, start_sample, end_sample, Port::port_offset ());
1324 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1325 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1326 _name, events_read, playback_sample, playback_sample + nframes,
1327 _midi_buf->read_space(), _midi_buf->write_space(),
1328 _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr()));
1331 g_atomic_int_add (&_samples_read_from_ringbuffer, nframes);
1334 if (speed != 0.0 && fabsf (speed) != 1.0f) {
1335 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1336 MidiBuffer::TimeType *tme = i.timeptr();
1337 // XXX need to subtract port offsets before scaling
1338 // also we must only scale events read from disk
1339 // and not existing input data in the buffer.
1340 *tme = (*tme) * nframes / disk_samples_to_consume;
1344 if (ms & MonitoringInput) {
1345 dst.merge_from (*target, nframes);
1349 if (!target->empty ()) {
1350 cerr << "======== MIDI OUT ========\n";
1351 for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
1352 const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
1353 cerr << "MIDI EVENT (from disk) @ " << ev.time();
1354 for (size_t xx = 0; xx < ev.size(); ++xx) {
1355 cerr << ' ' << hex << (int) ev.buffer()[xx];
1357 cerr << dec << endl;
1359 cerr << "----------------\n";
1363 cerr << "======== MIDI Disk Buffer ========\n";
1364 _midi_buf->dump (cerr);
1365 cerr << "----------------\n";
1369 /** @a start is set to the new sample position (TIME) read up to */
1371 DiskReader::midi_read (samplepos_t& start, samplecnt_t dur, bool reversed)
1373 samplecnt_t this_read = 0;
1374 samplepos_t loop_end = 0;
1375 samplepos_t loop_start = 0;
1376 samplecnt_t loop_length = 0;
1377 Location* loc = _loop_location;
1378 samplepos_t effective_start = start;
1379 Evoral::Range<samplepos_t>* loop_range (0);
1381 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS::midi_read @ %1 cnt %2\n", start, dur));
1383 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
1384 MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0;
1385 sampleoffset_t loop_offset = 0;
1387 if (!reversed && loc) {
1388 get_location_times (loc, &loop_start, &loop_end, &loop_length);
1393 /* take any loop into account. we can't read past the end of the loop. */
1395 if (loc && !reversed) {
1398 loop_range = new Evoral::Range<samplepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
1401 /* if we are (seamlessly) looping, ensure that the first sample we read is at the correct
1402 position within the loop.
1405 effective_start = loop_range->squish (effective_start);
1407 if ((loop_end - effective_start) <= dur) {
1408 /* too close to end of loop to read "dur", so
1411 this_read = loop_end - effective_start;
1420 if (this_read == 0) {
1424 this_read = min (dur,this_read);
1426 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset));
1428 if (midi_playlist()->read (*_midi_buf, effective_start, this_read, loop_range, 0, filter) != this_read) {
1429 error << string_compose(
1430 _("MidiDiskstream %1: cannot read %2 from playlist at sample %3"),
1431 id(), this_read, start) << endmsg;
1435 g_atomic_int_add (&_samples_written_to_ringbuffer, this_read);
1439 // Swap note ons with note offs here. etc?
1440 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
1441 // CC values etc. hard.
1445 /* adjust passed-by-reference argument (note: this is
1446 monotonic and does not reflect looping.
1450 /* similarly adjust effective_start, but this may be
1451 readjusted for seamless looping as we continue around
1454 effective_start += this_read;
1464 DiskReader::refill_midi ()
1466 if (!_playlists[DataType::MIDI]) {
1470 const size_t write_space = _midi_buf->write_space();
1471 const bool reversed = _session.transport_speed() < 0.0f;
1473 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file sample = %2\n", write_space, file_sample[DataType::MIDI]));
1475 /* no space to write */
1476 if (write_space == 0) {
1484 /* at end: nothing to do */
1486 samplepos_t ffm = file_sample[DataType::MIDI];
1488 if (ffm == max_samplepos) {
1493 const uint32_t samples_read = g_atomic_int_get (&_samples_read_from_ringbuffer);
1494 const uint32_t samples_written = g_atomic_int_get (&_samples_written_to_ringbuffer);
1496 if ((samples_read < samples_written) && (samples_written - samples_read) >= midi_readahead) {
1500 samplecnt_t to_read = midi_readahead - ((samplecnt_t)samples_written - (samplecnt_t)samples_read);
1502 to_read = min (to_read, (samplecnt_t) (max_samplepos - ffm));
1503 to_read = min (to_read, (samplecnt_t) write_space);
1505 if (midi_read (ffm, to_read, reversed)) {
1509 file_sample[DataType::MIDI] = ffm;
1515 DiskReader::set_no_disk_output (bool yn)
1517 /* this MUST be called as part of the process call tree, before any
1518 disk readers are invoked. We use it when the session needs the
1519 transport (and thus effective read position for DiskReaders) to keep
1520 advancing as part of syncing up with a transport master, but we
1521 don't want any actual disk output yet because we are still not
1524 _no_disk_output = yn;