X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fdisk_reader.cc;h=76afb6b00f852ff59aeabfb44c0b904b39194c6f;hb=0f6ad823de05ce236f1dca2fc79865b03a0d5d55;hp=1dee19522ca2d025f1022958e3703732819a9c84;hpb=f76c05851f4ab973cc258d595c26f738243f3eb9;p=ardour.git diff --git a/libs/ardour/disk_reader.cc b/libs/ardour/disk_reader.cc index 1dee19522c..76afb6b00f 100644 --- a/libs/ardour/disk_reader.cc +++ b/libs/ardour/disk_reader.cc @@ -1,26 +1,29 @@ /* - Copyright (C) 2009-2016 Paul Davis - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Copyright (C) 2017-2018 Paul Davis + * Copyright (C) 2017-2019 Robin Gareus + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ -*/ +#include #include "pbd/enumwriter.h" -#include "pbd/i18n.h" #include "pbd/memento_command.h" +#include "pbd/playback_buffer.h" +#include "ardour/amp.h" #include "ardour/audioengine.h" #include "ardour/audioplaylist.h" #include "ardour/audio_buffer.h" @@ -29,57 +32,65 @@ #include "ardour/disk_reader.h" #include "ardour/midi_ring_buffer.h" #include "ardour/midi_playlist.h" +#include "ardour/midi_track.h" #include "ardour/pannable.h" #include "ardour/playlist.h" #include "ardour/playlist_factory.h" #include "ardour/session.h" #include "ardour/session_playlists.h" +#include "pbd/i18n.h" + using namespace ARDOUR; using namespace PBD; using namespace std; -ARDOUR::framecnt_t DiskReader::_chunk_frames = default_chunk_frames (); +ARDOUR::samplecnt_t DiskReader::_chunk_samples = default_chunk_samples (); PBD::Signal0 DiskReader::Underrun; +Sample* DiskReader::_sum_buffer = 0; Sample* DiskReader::_mixdown_buffer = 0; gain_t* DiskReader::_gain_buffer = 0; -framecnt_t DiskReader::midi_readahead = 4096; +samplecnt_t DiskReader::midi_readahead = 4096; +gint DiskReader::_no_disk_output (0); DiskReader::DiskReader (Session& s, string const & str, DiskIOProcessor::Flag f) : DiskIOProcessor (s, str, f) - , _roll_delay (0) - , overwrite_frame (0) - , overwrite_offset (0) - , _pending_overwrite (false) - , overwrite_queued (false) - , _gui_feed_buffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)) + , overwrite_sample (0) + , overwrite_queued (false) + , _declick_amp (s.nominal_sample_rate ()) + , _declick_offs (0) { + file_sample[DataType::AUDIO] = 0; + file_sample[DataType::MIDI] = 0; + g_atomic_int_set (&_pending_overwrite, 0); } DiskReader::~DiskReader () { DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskReader %1 @ %2 deleted\n", _name, this)); +} - for (uint32_t n = 0; n < DataType::num_types; ++n) { - if (_playlists[n]) { - _playlists[n]->release (); - } - } - - { - RCUWriter writer (channels); - boost::shared_ptr c = writer.get_copy(); - - for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - delete *chan; - } +void +DiskReader::ReaderChannelInfo::resize (samplecnt_t bufsize) +{ + delete rbuf; + rbuf = new PlaybackBuffer (bufsize); + /* touch memory to lock it */ + memset (rbuf->buffer(), 0, sizeof (Sample) * rbuf->bufsize()); +} - c->clear(); +int +DiskReader::add_channel_to (boost::shared_ptr c, uint32_t how_many) +{ + while (how_many--) { + c->push_back (new ReaderChannelInfo (_session.butler()->audio_diskstream_playback_buffer_size())); + DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: new reader channel, write space = %2 read = %3\n", + name(), + c->back()->rbuf->write_space(), + c->back()->rbuf->read_space())); } - channels.flush (); - - delete _midi_buf; + return 0; } void @@ -90,6 +101,7 @@ DiskReader::allocate_working_buffers() need to reflect the maximum size we could use, which is 4MB reads, or 2M samples using 16 bit samples. */ + _sum_buffer = new Sample[2*1048576]; _mixdown_buffer = new Sample[2*1048576]; _gain_buffer = new gain_t[2*1048576]; } @@ -97,14 +109,16 @@ DiskReader::allocate_working_buffers() void DiskReader::free_working_buffers() { + delete [] _sum_buffer; delete [] _mixdown_buffer; delete [] _gain_buffer; - _mixdown_buffer = 0; - _gain_buffer = 0; + _sum_buffer = 0; + _mixdown_buffer = 0; + _gain_buffer = 0; } -framecnt_t -DiskReader::default_chunk_frames() +samplecnt_t +DiskReader::default_chunk_samples() { return 65536; } @@ -112,7 +126,7 @@ DiskReader::default_chunk_frames() bool DiskReader::set_name (string const & str) { - string my_name = X_("playback:"); + string my_name = X_("player:"); my_name += str; if (_name != my_name) { @@ -122,16 +136,10 @@ DiskReader::set_name (string const & str) return true; } -void -DiskReader::set_roll_delay (ARDOUR::framecnt_t nframes) -{ - _roll_delay = nframes; -} - XMLNode& -DiskReader::state (bool full) +DiskReader::state () { - XMLNode& node (DiskIOProcessor::state (full)); + XMLNode& node (DiskIOProcessor::state ()); node.set_property(X_("type"), X_("diskreader")); return node; } @@ -149,7 +157,6 @@ DiskReader::set_state (const XMLNode& node, int version) void DiskReader::realtime_handle_transport_stopped () { - realtime_speed_change (); } void @@ -177,7 +184,7 @@ DiskReader::buffer_load () const return 1.0; } - PBD::RingBufferNPT * b = c->front()->buf; + PBD::PlaybackBuffer* b = c->front()->rbuf; return (float) ((double) b->read_space() / (double) b->bufsize()); } @@ -233,13 +240,13 @@ DiskReader::use_playlist (DataType dt, boost::shared_ptr playlist) } void -DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, +DiskReader::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool result_required) { uint32_t n; boost::shared_ptr c = channels.reader(); ChannelList::iterator chan; - frameoffset_t playback_distance; + sampleoffset_t disk_samples_to_consume; MonitorState ms = _route->monitoring_state (); if (_active) { @@ -255,42 +262,63 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, } } - _need_butler = false; + const bool declick_out = _session.declick_in_progress(); + const gain_t target_gain = (declick_out || (speed == 0.0) || ((ms & MonitoringDisk) == 0)) ? 0.0 : 1.0; + + if (!_session.cfg ()->get_use_transport_fades ()) { + _declick_amp.set_gain (target_gain); + } - if (speed == 0.0 && (ms == MonitoringDisk)) { - /* stopped. Don't accidentally pass any data from disk - * into our outputs (e.g. via interpolation) + if (declick_out && (ms == MonitoringDisk) && _declick_amp.gain () == target_gain) { + /* no channels, or stopped. Don't accidentally pass any data + * from disk into our outputs (e.g. via interpolation) */ - bufs.silence (nframes, 0); return; } - if (speed != 1.0f && speed != -1.0f) { - interpolation.set_speed (speed); - midi_interpolation.set_speed (speed); - playback_distance = midi_interpolation.distance (nframes); - if (speed < 0.0) { - playback_distance = -playback_distance; - } + BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count())); + const bool still_locating = _session.global_locate_pending() || pending_overwrite (); + + assert (speed == -1 || speed == 0 || speed == 1); + + if (speed == 0) { + disk_samples_to_consume = 0; } else { - playback_distance = nframes; + disk_samples_to_consume = nframes; } - BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count())); - const bool still_locating = _session.locate_pending(); + if (c->empty()) { + /* do nothing with audio */ + goto midi; + } - if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating) { + if (_declick_amp.gain () != target_gain && target_gain == 0) { + /* fade-out */ +#if 0 + printf ("DR fade-out speed=%.1f gain=%.3f off=%ld start=%ld playpos=%ld (%s)\n", + speed, _declick_amp.gain (), _declick_offs, start_sample, playback_sample, owner()->name().c_str()); +#endif + ms = MonitorState (ms | MonitoringDisk); + assert (result_required); + result_required = true; + } else { + _declick_offs = 0; + } + + if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating || _no_disk_output) { /* no need for actual disk data, just advance read pointer and return */ - for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->buf->increment_read_ptr (playback_distance); + if (!still_locating || _no_disk_output) { + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { + (*chan)->rbuf->increment_read_ptr (disk_samples_to_consume); + } } - /* if monitoring disk but locating, put silence in the buffers */ + /* if monitoring disk but locating put silence in the buffers */ - if (still_locating && (ms == MonitoringDisk)) { - bufs.silence (playback_distance, 0); + if ((_no_disk_output || still_locating) && (ms == MonitoringDisk)) { + bufs.silence (nframes, 0); } } else { @@ -302,7 +330,7 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, gain_t scaling; if (n_chans > n_buffers) { - scaling = ((float) n_buffers)/n_chans; + scaling = ((float) n_buffers) / n_chans; } else { scaling = 1.0; } @@ -310,110 +338,90 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { ChannelInfo* chaninfo (*chan); - AudioBuffer& output (bufs.get_audio (n%n_buffers)); - Sample* disk_signal = 0; /* assignment not really needed but it keeps the compiler quiet and helps track bugs */ + AudioBuffer& output (bufs.get_audio (n % n_buffers)); - if (ms & MonitoringInput) { - /* put disk stream in scratch buffer, blend at end */ - disk_signal = scratch_bufs.get_audio(n).data (); - } else { - /* no input stream needed, just overwrite buffers */ - disk_signal = output.data (); - } - - chaninfo->buf->get_read_vector (&(*chan)->rw_vector); - - if (playback_distance <= (framecnt_t) chaninfo->rw_vector.len[0]) { - - if (fabsf (speed) != 1.0f) { - (void) interpolation.interpolate ( - n, nframes, - chaninfo->rw_vector.buf[0], - disk_signal); - } else if (speed != 0.0) { - memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * playback_distance); - } - - } else { - - const framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1]; - - if (playback_distance <= total) { - - /* We have enough samples, but not in one lump. - */ - - if (fabsf (speed) != 1.0f) { - interpolation.interpolate (n, chaninfo->rw_vector.len[0], - chaninfo->rw_vector.buf[0], - disk_signal); - disk_signal += chaninfo->rw_vector.len[0]; - interpolation.interpolate (n, playback_distance - chaninfo->rw_vector.len[0], - chaninfo->rw_vector.buf[1], - disk_signal); - } else if (speed != 0.0) { - memcpy (disk_signal, - chaninfo->rw_vector.buf[0], - chaninfo->rw_vector.len[0] * sizeof (Sample)); - memcpy (disk_signal + chaninfo->rw_vector.len[0], - chaninfo->rw_vector.buf[1], - (playback_distance - chaninfo->rw_vector.len[0]) * sizeof (Sample)); - } + AudioBuffer& disk_buf ((ms & MonitoringInput) ? scratch_bufs.get_audio(n) : output); + if (start_sample != playback_sample && target_gain != 0) { + if (can_internal_playback_seek (start_sample - playback_sample)) { + internal_playback_seek (start_sample - playback_sample); } else { + disk_samples_to_consume = 0; /* will force an underrun below */ + } + } - cerr << _name << " Need " << playback_distance << " total = " << total << endl; + if (!declick_out) { + const samplecnt_t total = chaninfo->rbuf->read (disk_buf.data(), disk_samples_to_consume); + if (disk_samples_to_consume > total) { + cerr << _name << " Need " << total << " have only " << disk_samples_to_consume << endl; cerr << "underrun for " << _name << endl; DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n", DEBUG_THREAD_SELF, name(), total)); Underrun (); return; - } + } else if (_declick_amp.gain () != target_gain) { + assert (target_gain == 0); + const samplecnt_t total = chaninfo->rbuf->read (disk_buf.data(), nframes, false, _declick_offs); + _declick_offs += total; } - if (scaling != 1.0f && speed != 0.0) { - apply_gain_to_buffer (disk_signal, nframes, scaling); - } + _declick_amp.apply_gain (disk_buf, nframes, target_gain); - chaninfo->buf->increment_read_ptr (playback_distance); + Amp::apply_simple_gain (disk_buf, nframes, scaling); - if ((speed != 0.0) && (ms & MonitoringInput)) { + if (ms & MonitoringInput) { /* mix the disk signal into the input signal (already in bufs) */ - mix_buffers_no_gain (output.data(), disk_signal, speed == 0.0 ? nframes : playback_distance); + mix_buffers_no_gain (output.data(), disk_buf.data(), nframes); } } } /* MIDI data handling */ - if (!_session.declick_out_pending()) { - if (ms & MonitoringDisk && !still_locating) { - get_midi_playback (bufs.get_midi (0), playback_distance, ms, scratch_bufs, speed, playback_distance); + midi: + if (!declick_in_progress() && bufs.count().n_midi() && _midi_buf) { + MidiBuffer* dst; + + if (_no_disk_output) { + dst = &scratch_bufs.get_midi(0); + } else { + dst = &bufs.get_midi (0); + } + + if ((ms & MonitoringDisk) && !still_locating) { + get_midi_playback (*dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume); } } if (!still_locating) { + bool butler_required = false; + if (speed < 0.0) { - playback_sample -= playback_distance; + playback_sample -= disk_samples_to_consume; } else { - playback_sample += playback_distance; + playback_sample += disk_samples_to_consume; + } + + Location* loc = _loop_location; + if (loc) { + Evoral::Range loop_range (loc->start(), loc->end() - 1); + playback_sample = loop_range.squish (playback_sample); } if (_playlists[DataType::AUDIO]) { if (!c->empty()) { if (_slaved) { - if (c->front()->buf->write_space() >= c->front()->buf->bufsize() / 2) { - DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->buf->write_space(), - c->front()->buf->bufsize())); - _need_butler = true; + if (c->front()->rbuf->write_space() >= c->front()->rbuf->bufsize() / 2) { + DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: slaved, write space = %2 of %3\n", name(), c->front()->rbuf->write_space(), c->front()->rbuf->bufsize())); + butler_required = true; } } else { - if ((framecnt_t) c->front()->buf->write_space() >= _chunk_frames) { - DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->buf->write_space(), - _chunk_frames)); - _need_butler = true; + if ((samplecnt_t) c->front()->rbuf->write_space() >= _chunk_samples) { + DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->rbuf->write_space(), + _chunk_samples)); + butler_required = true; } } } @@ -422,16 +430,16 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, if (_playlists[DataType::MIDI]) { /* MIDI butler needed part */ - uint32_t frames_read = g_atomic_int_get(const_cast(&_frames_read_from_ringbuffer)); - uint32_t frames_written = g_atomic_int_get(const_cast(&_frames_written_to_ringbuffer)); + uint32_t samples_read = g_atomic_int_get(const_cast(&_samples_read_from_ringbuffer)); + uint32_t samples_written = g_atomic_int_get(const_cast(&_samples_written_to_ringbuffer)); /* - cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read << - " = " << frames_written - frames_read - << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl; + cerr << name() << " MDS written: " << samples_written << " - read: " << samples_read << + " = " << samples_written - samples_read + << " + " << disk_samples_to_consume << " < " << midi_readahead << " = " << need_butler << ")" << endl; */ - /* frames_read will generally be less than frames_written, but + /* samples_read will generally be less than samples_written, but * immediately after an overwrite, we can end up having read some data * before we've written any. we don't need to trip an assert() on this, * but we do need to check so that the decision on whether or not we @@ -442,13 +450,13 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, * * Doing heavy GUI operations[1] can stall also the butler. * The RT-thread meanwhile will happily continue and - * ‘frames_read’ (from buffer to output) will become larger - * than ‘frames_written’ (from disk to buffer). + * ‘samples_read’ (from buffer to output) will become larger + * than ‘samples_written’ (from disk to buffer). * * The disk-stream is now behind.. * * In those cases the butler needs to be summed to refill the buffer (done now) - * AND we need to skip (frames_read - frames_written). ie remove old events + * AND we need to skip (samples_read - samples_written). ie remove old events * before playback_sample from the rinbuffer. * * [1] one way to do so is described at #6170. @@ -459,104 +467,88 @@ DiskReader::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow * and can stall */ - if (frames_read <= frames_written) { - if ((frames_written - frames_read) + playback_distance < midi_readahead) { - _need_butler = true; + if (samples_read <= samples_written) { + if ((samples_written - samples_read) + disk_samples_to_consume < midi_readahead) { + butler_required = true; } } else { - _need_butler = true; + butler_required = true; } } + + _need_butler = butler_required; } // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name(), _need_butler)); } +bool +DiskReader::declick_in_progress () const +{ + return _declick_amp.gain() != 0; // declick-out +} + +bool +DiskReader::pending_overwrite () const { + return g_atomic_int_get (&_pending_overwrite) != 0; +} + void -DiskReader::set_pending_overwrite (bool yn) +DiskReader::set_pending_overwrite () { /* called from audio thread, so we can use the read ptr and playback sample as we wish */ - _pending_overwrite = yn; - - overwrite_frame = playback_sample; + assert (!pending_overwrite ()); + overwrite_sample = playback_sample; boost::shared_ptr c = channels.reader (); - if (!c->empty ()) { - overwrite_offset = c->front()->buf->get_read_ptr(); + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { + (*chan)->rbuf->read_flush (); } + g_atomic_int_set (&_pending_overwrite, 1); } -int +bool DiskReader::overwrite_existing_buffers () { - int ret = -1; - - boost::shared_ptr c = channels.reader(); - + /* called from butler thread */ + assert (pending_overwrite ()); overwrite_queued = false; - DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_frame)); + DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2\n", overwrite_sample)); + boost::shared_ptr c = channels.reader(); if (!c->empty ()) { - /* AUDIO */ const bool reversed = _session.transport_speed() < 0.0f; /* assume all are the same size */ - framecnt_t size = c->front()->buf->bufsize(); + samplecnt_t size = c->front()->rbuf->write_space (); + assert (size > 0); - std::auto_ptr mixdown_buffer (new Sample[size]); - std::auto_ptr gain_buffer (new float[size]); + boost::scoped_array sum_buffer (new Sample[size]); + boost::scoped_array mixdown_buffer (new Sample[size]); + boost::scoped_array gain_buffer (new float[size]); /* reduce size so that we can fill the buffer correctly (ringbuffers - can only handle size-1, otherwise they appear to be empty) - */ + * can only handle size-1, otherwise they appear to be empty) + */ size--; uint32_t n=0; - framepos_t start; for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) { - start = overwrite_frame; - framecnt_t cnt = size; - - /* to fill the buffer without resetting the playback sample, we need to - do it one or two chunks (normally two). + samplepos_t start = overwrite_sample; + samplecnt_t to_read = size; - |----------------------------------------------------------------------| - - ^ - overwrite_offset - |<- second chunk->||<----------------- first chunk ------------------>| - - */ - - framecnt_t to_read = size - overwrite_offset; - - if (audio_read ((*chan)->buf->buffer() + overwrite_offset, mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) { - error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"), - id(), size, playback_sample) << endmsg; + if (audio_read ((*chan)->rbuf, sum_buffer.get(), mixdown_buffer.get(), gain_buffer.get(), start, to_read, n, reversed)) { + error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"), id(), size, overwrite_sample) << endmsg; goto midi; } - - if (cnt > to_read) { - - cnt -= to_read; - - if (audio_read ((*chan)->buf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) { - error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at frame %3"), - id(), size, playback_sample) << endmsg; - goto midi; - } - } } - - ret = 0; - } midi: @@ -569,39 +561,62 @@ DiskReader::overwrite_existing_buffers () _midi_buf->reset (); _midi_buf->reset_tracker (); - g_atomic_int_set (&_frames_read_from_ringbuffer, 0); - g_atomic_int_set (&_frames_written_to_ringbuffer, 0); + g_atomic_int_set (&_samples_read_from_ringbuffer, 0); + g_atomic_int_set (&_samples_written_to_ringbuffer, 0); /* Resolve all currently active notes in the playlist. This is more aggressive than it needs to be: ideally we would only resolve what is absolutely necessary, but this seems difficult and/or impossible without having the old data or knowing what change caused the overwrite. */ - midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_frame); + midi_playlist()->resolve_note_trackers (*_midi_buf, overwrite_sample); - midi_read (overwrite_frame, _chunk_frames, false); - - file_frame = overwrite_frame; // it was adjusted by ::midi_read() + midi_read (overwrite_sample, _chunk_samples, false); + file_sample[DataType::MIDI] = overwrite_sample; // overwrite_sample was adjusted by ::midi_read() to the new position } - _pending_overwrite = false; + g_atomic_int_set (&_pending_overwrite, 0); - return ret; + return true; } int -DiskReader::seek (framepos_t frame, bool complete_refill) +DiskReader::seek (samplepos_t sample, bool complete_refill) { + /* called via non_realtime_locate() from butler thread */ + uint32_t n; int ret = -1; ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); +#ifndef NDEBUG + if (_declick_amp.gain() != 0) { + /* this should not happen. new transport should postponse seeking + * until de-click is complete */ + printf ("LOCATE WITHOUT DECLICK (gain=%f) at %ld seek-to %ld\n", _declick_amp.gain (), playback_sample, sample); + //return -1; + } + if (sample == playback_sample && !complete_refill) { + return 0; // XXX double-check this + } +#endif + + g_atomic_int_set (&_pending_overwrite, 0); + + DEBUG_TRACE (DEBUG::DiskIO, string_compose ("DiskReader::seek %s %ld -> %ld refill=%d\n", owner()->name().c_str(), playback_sample, sample, complete_refill)); + + const samplecnt_t distance = sample - playback_sample; + if (can_internal_playback_seek (distance)) { + internal_playback_seek (distance); + return 0; + } + for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { - (*chan)->buf->reset (); + (*chan)->rbuf->reset (); } - if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) { + if (g_atomic_int_get (&_samples_read_from_ringbuffer) == 0) { /* we haven't read anything since the last seek, so flush all note trackers to prevent wierdness @@ -609,12 +624,15 @@ DiskReader::seek (framepos_t frame, bool complete_refill) reset_tracker (); } - _midi_buf->reset(); - g_atomic_int_set(&_frames_read_from_ringbuffer, 0); - g_atomic_int_set(&_frames_written_to_ringbuffer, 0); + if (_midi_buf) { + _midi_buf->reset(); + } + g_atomic_int_set(&_samples_read_from_ringbuffer, 0); + g_atomic_int_set(&_samples_written_to_ringbuffer, 0); - playback_sample = frame; - file_frame = frame; + playback_sample = sample; + file_sample[DataType::AUDIO] = sample; + file_sample[DataType::MIDI] = sample; if (complete_refill) { /* call _do_refill() to refill the entire buffer, using @@ -628,12 +646,11 @@ DiskReader::seek (framepos_t frame, bool complete_refill) ret = do_refill_with_alloc (true); } - return ret; } -int -DiskReader::can_internal_playback_seek (framecnt_t distance) +bool +DiskReader::can_internal_playback_seek (sampleoffset_t distance) { /* 1. Audio */ @@ -641,32 +658,43 @@ DiskReader::can_internal_playback_seek (framecnt_t distance) boost::shared_ptr c = channels.reader(); for (chan = c->begin(); chan != c->end(); ++chan) { - if ((*chan)->buf->read_space() < (size_t) distance) { + if (!(*chan)->rbuf->can_seek (distance)) { return false; } } + if (distance < 0) { + return true; // XXX TODO un-seek MIDI + } + /* 2. MIDI */ - uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer); - uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer); + uint32_t samples_read = g_atomic_int_get(&_samples_read_from_ringbuffer); + uint32_t samples_written = g_atomic_int_get(&_samples_written_to_ringbuffer); - return ((frames_written - frames_read) < distance); + return ((samples_written - samples_read) < distance); } -int -DiskReader::internal_playback_seek (framecnt_t distance) +void +DiskReader::internal_playback_seek (sampleoffset_t distance) { + if (distance == 0) { + return; + } + + sampleoffset_t off = distance; + ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); - for (chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->buf->increment_read_ptr (::llabs(distance)); + if (distance < 0) { + off = 0 - (sampleoffset_t) (*chan)->rbuf->decrement_read_ptr (::llabs (distance)); + } else { + off = (*chan)->rbuf->increment_read_ptr (distance); + } } - playback_sample += distance; - - return 0; + playback_sample += off; } static @@ -681,25 +709,27 @@ void swap_by_ptr (Sample *first, Sample *last) /** Read some data for 1 channel from our playlist into a buffer. * @param buf Buffer to write to. - * @param start Session frame to start reading from; updated to where we end up + * @param start Session sample to start reading from; updated to where we end up * after the read. * @param cnt Count of samples to read. * @param reversed true if we are running backwards, otherwise false. */ int -DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, - framepos_t& start, framecnt_t cnt, +DiskReader::audio_read (PBD::PlaybackBuffer*rb, + Sample* sum_buffer, + Sample* mixdown_buffer, + float* gain_buffer, + samplepos_t& start, samplecnt_t cnt, int channel, bool reversed) { - framecnt_t this_read = 0; + samplecnt_t this_read = 0; bool reloop = false; - framepos_t loop_end = 0; - framepos_t loop_start = 0; - framecnt_t offset = 0; + samplepos_t loop_end = 0; + samplepos_t loop_start = 0; Location *loc = 0; if (!_playlists[DataType::AUDIO]) { - memset (buf, 0, sizeof (Sample) * cnt); + rb->write_zero (cnt); return 0; } @@ -707,7 +737,7 @@ DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, if (!reversed) { - framecnt_t loop_length = 0; + samplecnt_t loop_length = 0; /* Make the use of a Location atomic for this read operation. @@ -717,13 +747,13 @@ DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, just once. */ - if ((loc = loop_location) != 0) { + if ((loc = _loop_location) != 0) { loop_start = loc->start(); loop_end = loc->end(); loop_length = loop_end - loop_start; } - /* if we are looping, ensure that the first frame we read is at the correct + /* if we are looping, ensure that the first sample we read is at the correct position within the loop. */ @@ -757,17 +787,16 @@ DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, break; } - this_read = min(cnt,this_read); + this_read = min (cnt, this_read); - if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) { - error << string_compose(_("DiskReader %1: cannot read %2 from playlist at frame %3"), id(), this_read, - start) << endmsg; + if (audio_playlist()->read (sum_buffer, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) { + error << string_compose(_("DiskReader %1: cannot read %2 from playlist at sample %3"), id(), this_read, start) << endmsg; return -1; } if (reversed) { - swap_by_ptr (buf, buf + this_read - 1); + swap_by_ptr (sum_buffer, sum_buffer + this_read - 1); } else { @@ -780,8 +809,11 @@ DiskReader::audio_read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, } } + if (rb->write (sum_buffer, this_read) != this_read) { + cerr << owner()->name() << " Ringbuffer Write overrun" << endl; + } + cnt -= this_read; - offset += this_read; } return 0; @@ -797,10 +829,11 @@ DiskReader::_do_refill_with_alloc (bool partial_fill) */ { - std::auto_ptr mix_buf (new Sample[2*1048576]); - std::auto_ptr gain_buf (new float[2*1048576]); + boost::scoped_array sum_buf (new Sample[2*1048576]); + boost::scoped_array mix_buf (new Sample[2*1048576]); + boost::scoped_array gain_buf (new float[2*1048576]); - int ret = refill_audio (mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_frames : 0)); + int ret = refill_audio (sum_buf.get(), mix_buf.get(), gain_buf.get(), (partial_fill ? _chunk_samples : 0)); if (ret) { return ret; @@ -811,9 +844,9 @@ DiskReader::_do_refill_with_alloc (bool partial_fill) } int -DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level) +DiskReader::refill (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level) { - int ret = refill_audio (mixdown_buffer, gain_buffer, fill_level); + int ret = refill_audio (sum_buffer, mixdown_buffer, gain_buffer, fill_level); if (ret) { return ret; @@ -833,7 +866,7 @@ DiskReader::refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_ */ int -DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level) +DiskReader::refill_audio (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level) { /* do not read from disk while session is marked as Loading, to avoid useless redundant I/O. @@ -844,15 +877,11 @@ DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t } int32_t ret = 0; - framecnt_t to_read; - RingBufferNPT::rw_vector vector; bool const reversed = _session.transport_speed() < 0.0f; - framecnt_t total_space; - framecnt_t zero_fill; + samplecnt_t zero_fill; uint32_t chan_n; ChannelList::iterator i; boost::shared_ptr c = channels.reader(); - framecnt_t ts; if (c->empty()) { return 0; @@ -861,14 +890,9 @@ DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t assert(mixdown_buffer); assert(gain_buffer); - vector.buf[0] = 0; - vector.len[0] = 0; - vector.buf[1] = 0; - vector.len[1] = 0; - - c->front()->buf->get_write_vector (&vector); + samplecnt_t total_space = c->front()->rbuf->write_space(); - if ((total_space = vector.len[0] + vector.len[1]) == 0) { + if (total_space == 0) { DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name())); /* nowhere to write to */ return 0; @@ -884,18 +908,18 @@ DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t } /* if we're running close to normal speed and there isn't enough - space to do disk_read_chunk_frames of I/O, then don't bother. + space to do disk_read_chunk_samples of I/O, then don't bother. at higher speeds, just do it because the sync between butler and audio thread may not be good enough. - Note: it is a design assumption that disk_read_chunk_frames is smaller + Note: it is a design assumption that disk_read_chunk_samples is smaller than the playback buffer size, so this check should never trip when the playback buffer is empty. */ - DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: space to refill %2 vs. chunk %3 (speed = %4)\n", name(), total_space, _chunk_frames, _session.transport_speed())); - if ((total_space < _chunk_frames) && fabs (_session.transport_speed()) < 2.0f) { + 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())); + if ((total_space < _chunk_samples) && fabs (_session.transport_speed()) < 2.0f) { return 0; } @@ -904,84 +928,58 @@ DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t work with. */ - if (_slaved && total_space < (framecnt_t) (c->front()->buf->bufsize() / 2)) { + if (_slaved && total_space < (samplecnt_t) (c->front()->rbuf->bufsize() / 2)) { DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: not enough to refill while slaved\n", this)); return 0; } - if (reversed) { + samplepos_t ffa = file_sample[DataType::AUDIO]; - if (file_frame == 0) { + if (reversed) { + if (ffa == 0) { /* at start: nothing to do but fill with silence */ - for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { - ChannelInfo* chan (*i); - chan->buf->get_write_vector (&vector); - memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]); - if (vector.len[1]) { - memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]); - } - chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]); + chan->rbuf->write_zero (chan->rbuf->write_space ()); } return 0; } - if (file_frame < total_space) { - - /* too close to the start: read what we can, - and then zero fill the rest - */ - - zero_fill = total_space - file_frame; - total_space = file_frame; - + if (ffa < total_space) { + /* too close to the start: read what we can, and then zero fill the rest */ + zero_fill = total_space - ffa; + total_space = ffa; } else { - zero_fill = 0; } } else { - if (file_frame == max_framepos) { - + if (ffa == max_samplepos) { /* at end: nothing to do but fill with silence */ - for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { - ChannelInfo* chan (*i); - chan->buf->get_write_vector (&vector); - memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]); - if (vector.len[1]) { - memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]); - } - chan->buf->increment_write_ptr (vector.len[0] + vector.len[1]); + chan->rbuf->write_zero (chan->rbuf->write_space ()); } return 0; } - if (file_frame > max_framepos - total_space) { - + if (ffa > max_samplepos - total_space) { /* to close to the end: read what we can, and zero fill the rest */ - - zero_fill = total_space - (max_framepos - file_frame); - total_space = max_framepos - file_frame; + zero_fill = total_space - (max_samplepos - ffa); + total_space = max_samplepos - ffa; } else { zero_fill = 0; } } - framepos_t file_frame_tmp = 0; - /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */ - const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format()); size_t total_bytes = total_space * bits_per_sample / 8; - /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer - */ + /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer */ size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes)); /* find nearest (lower) multiple of 16384 */ @@ -989,116 +987,64 @@ DiskReader::refill_audio (Sample* mixdown_buffer, float* gain_buffer, framecnt_t byte_size_for_read = (byte_size_for_read / 16384) * 16384; /* now back to samples */ - - framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8); + samplecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8); DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: will refill %2 channels with %3 samples\n", name(), c->size(), total_space)); - // uint64_t before = g_get_monotonic_time (); - // uint64_t elapsed; + samplepos_t file_sample_tmp = ffa; for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { - ChannelInfo* chan (*i); - Sample* buf1; - Sample* buf2; - framecnt_t len1, len2; - - chan->buf->get_write_vector (&vector); - - if ((framecnt_t) vector.len[0] > samples_to_read) { - - /* we're not going to fill the first chunk, so certainly do not bother with the - other part. it won't be connected with the part we do fill, as in: - - .... => writable space - ++++ => readable space - ^^^^ => 1 x disk_read_chunk_frames that would be filled - - |......|+++++++++++++|...............................| - buf1 buf0 - ^^^^^^^^^^^^^^^ - - - So, just pretend that the buf1 part isn't there. - - */ - - vector.buf[1] = 0; - vector.len[1] = 0; - - } - - ts = total_space; - file_frame_tmp = file_frame; - - buf1 = vector.buf[0]; - len1 = vector.len[0]; - buf2 = vector.buf[1]; - len2 = vector.len[1]; - - to_read = min (ts, len1); - to_read = min (to_read, (framecnt_t) samples_to_read); + file_sample_tmp = ffa; + samplecnt_t ts = total_space; + samplecnt_t to_read = min (ts, (samplecnt_t) chan->rbuf->write_space ()); + to_read = min (to_read, samples_to_read); assert (to_read >= 0); - if (to_read) { - - if (audio_read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { - ret = -1; - goto out; - } - - chan->buf->increment_write_ptr (to_read); - ts -= to_read; - } - - to_read = min (ts, len2); + // cerr << owner()->name() << " to-read: " << to_read << endl; if (to_read) { - - /* we read all of vector.len[0], but it wasn't the - entire samples_to_read of data, so read some or - all of vector.len[1] as well. - */ - - if (audio_read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { + if (audio_read (chan->rbuf, sum_buffer, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, chan_n, reversed)) { + error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"), id(), to_read, ffa) << endmsg; ret = -1; goto out; } - - chan->buf->increment_write_ptr (to_read); } if (zero_fill) { - /* XXX: do something */ + /* not sure if action is needed, + * we'll later hit the "to close to the end" case + */ + //chan->rbuf->write_zero (zero_fill); } - } // elapsed = g_get_monotonic_time () - before; // cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n"; - file_frame = file_frame_tmp; - assert (file_frame >= 0); + file_sample[DataType::AUDIO] = file_sample_tmp; + assert (file_sample[DataType::AUDIO] >= 0); - ret = ((total_space - samples_to_read) > _chunk_frames); - - c->front()->buf->get_write_vector (&vector); + ret = ((total_space - samples_to_read) > _chunk_samples); out: return ret; } void -DiskReader::playlist_ranges_moved (list< Evoral::RangeMove > const & movements_frames, bool from_undo) +DiskReader::playlist_ranges_moved (list< Evoral::RangeMove > const & movements_samples, bool from_undo_or_shift) { /* If we're coming from an undo, it will have handled - automation undo (it must, since automation-follows-regions - can lose automation data). Hence we can do nothing here. - */ + * automation undo (it must, since automation-follows-regions + * can lose automation data). Hence we can do nothing here. + * + * Likewise when shifting regions (insert/remove time) + * automation is taken care of separately (busses with + * automation have no disk-reader). + */ - if (from_undo) { + if (from_undo_or_shift) { return; } @@ -1108,8 +1054,8 @@ DiskReader::playlist_ranges_moved (list< Evoral::RangeMove > const & list< Evoral::RangeMove > movements; - for (list< Evoral::RangeMove >::const_iterator i = movements_frames.begin(); - i != movements_frames.end(); + for (list< Evoral::RangeMove >::const_iterator i = movements_samples.begin(); + i != movements_samples.end(); ++i) { movements.push_back(Evoral::RangeMove(i->from, i->length, i->to)); @@ -1136,11 +1082,11 @@ DiskReader::playlist_ranges_moved (list< Evoral::RangeMove > const & } } /* move processor automation */ - _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_frames)); + _route->foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements_samples)); } void -DiskReader::move_processor_automation (boost::weak_ptr p, list< Evoral::RangeMove > const & movements_frames) +DiskReader::move_processor_automation (boost::weak_ptr p, list< Evoral::RangeMove > const & movements_samples) { boost::shared_ptr processor (p.lock ()); if (!processor) { @@ -1148,7 +1094,7 @@ DiskReader::move_processor_automation (boost::weak_ptr p, list< Evora } list< Evoral::RangeMove > movements; - for (list< Evoral::RangeMove >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) { + for (list< Evoral::RangeMove >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) { movements.push_back(Evoral::RangeMove(i->from, i->length, i->to)); } @@ -1171,20 +1117,12 @@ DiskReader::move_processor_automation (boost::weak_ptr p, list< Evora } } -boost::shared_ptr -DiskReader::get_gui_feed_buffer () const -{ - boost::shared_ptr b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI))); - - Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex); - b->copy (_gui_feed_buffer); - return b; -} - void DiskReader::reset_tracker () { - _midi_buf->reset_tracker (); + if (_midi_buf) { + _midi_buf->reset_tracker (); + } boost::shared_ptr mp (midi_playlist()); @@ -1194,9 +1132,11 @@ DiskReader::reset_tracker () } void -DiskReader::resolve_tracker (Evoral::EventSink& buffer, framepos_t time) +DiskReader::resolve_tracker (Evoral::EventSink& buffer, samplepos_t time) { - _midi_buf->resolve_tracker(buffer, time); + if (_midi_buf) { + _midi_buf->resolve_tracker(buffer, time); + } boost::shared_ptr mp (midi_playlist()); @@ -1209,25 +1149,28 @@ DiskReader::resolve_tracker (Evoral::EventSink& buffer, framepos_t t * so that an event at playback_sample has time = 0 */ void -DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState ms, BufferSet& scratch_bufs, double speed, framecnt_t playback_distance) +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) { MidiBuffer* target; + samplepos_t nframes = ::llabs (end_sample - start_sample); + + assert (_midi_buf); if ((ms & MonitoringInput) == 0) { - dst.clear(); + /* Route::process_output_buffers() clears the buffer as-needed */ target = &dst; } else { target = &scratch_bufs.get_midi (0); } if (ms & MonitoringDisk) { - /* no disk data needed */ + /* disk data needed */ - Location* loc = loop_location; + Location* loc = _loop_location; - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ( + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ( "%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name, - _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), playback_sample, playback_sample + nframes, + _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr(), start_sample, end_sample, (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes, Port::port_offset())); //cerr << "======== PRE ========\n"; @@ -1237,12 +1180,12 @@ DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState size_t events_read = 0; if (loc) { - framepos_t effective_start; + samplepos_t effective_start; - Evoral::Range loop_range (loc->start(), loc->end() - 1); - effective_start = loop_range.squish (playback_sample); + Evoral::Range loop_range (loc->start(), loc->end() - 1); + effective_start = loop_range.squish (start_sample); - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start)); + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("looped, effective start adjusted to %1\n", effective_start)); if (effective_start == loc->start()) { /* We need to turn off notes that may extend @@ -1261,84 +1204,93 @@ DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState for the 2nd read */ - framecnt_t first, second; + samplecnt_t first, second; first = loc->end() - effective_start; second = nframes - first; - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n", + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read for eff %1 end %2: %3 and %4, cycle offset %5\n", effective_start, loc->end(), first, second)); if (first) { - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n", + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #1, from %1 for %2\n", effective_start, first)); events_read = _midi_buf->read (*target, effective_start, first); } if (second) { - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n", + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #2, from %1 for %2\n", loc->start(), second)); events_read += _midi_buf->read (*target, loc->start(), second); } } else { - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n", + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("loop read #3, adjusted start as %1 for %2\n", effective_start, nframes)); events_read = _midi_buf->read (*target, effective_start, effective_start + nframes); } } else { - const size_t n_skipped = _midi_buf->skip_to (playback_sample); + const size_t n_skipped = _midi_buf->skip_to (start_sample); if (n_skipped > 0) { warning << string_compose(_("MidiDiskstream %1: skipped %2 events, possible underflow"), id(), n_skipped) << endmsg; } - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("playback buffer read, from %1 to %2 (%3)", playback_sample, playback_sample + nframes, nframes)); - events_read = _midi_buf->read (*target, playback_sample, playback_sample + nframes); + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("playback buffer read, from %1 to %2 (%3)", start_sample, end_sample, nframes)); + events_read = _midi_buf->read (*target, start_sample, end_sample, Port::port_offset ()); } - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ( + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ( "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n", _name, events_read, playback_sample, playback_sample + nframes, _midi_buf->read_space(), _midi_buf->write_space(), _midi_buf->get_read_ptr(), _midi_buf->get_write_ptr())); } - g_atomic_int_add (&_frames_read_from_ringbuffer, nframes); + g_atomic_int_add (&_samples_read_from_ringbuffer, nframes); - /* vari-speed */ + if (!_no_disk_output && (ms & MonitoringInput)) { + dst.merge_from (*target, nframes); + } - if (speed != 0.0 && fabsf (speed) != 1.0f) { +#if 0 + if (!target->empty ()) { + cerr << "======== MIDI OUT ========\n"; for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) { - MidiBuffer::TimeType *tme = i.timeptr(); - *tme = (*tme) * nframes / playback_distance; + const Evoral::Event ev (*i, false); + cerr << "MIDI EVENT (from disk) @ " << ev.time(); + for (size_t xx = 0; xx < ev.size(); ++xx) { + cerr << ' ' << hex << (int) ev.buffer()[xx]; + } + cerr << dec << endl; } + cerr << "----------------\n"; } - - if (ms & MonitoringInput) { - dst.merge_from (*target, nframes); - } - - //cerr << "======== POST ========\n"; - //_midi_buf->dump (cerr); - //cerr << "----------------\n"; +#endif +#if 0 + cerr << "======== MIDI Disk Buffer ========\n"; + _midi_buf->dump (cerr); + cerr << "----------------\n"; +#endif } -/** @a start is set to the new frame position (TIME) read up to */ +/** @a start is set to the new sample position (TIME) read up to */ int -DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed) +DiskReader::midi_read (samplepos_t& start, samplecnt_t dur, bool reversed) { - framecnt_t this_read = 0; - framepos_t loop_end = 0; - framepos_t loop_start = 0; - framecnt_t loop_length = 0; - Location* loc = loop_location; - framepos_t effective_start = start; - Evoral::Range* loop_range (0); + samplecnt_t this_read = 0; + samplepos_t loop_end = 0; + samplepos_t loop_start = 0; + samplecnt_t loop_length = 0; + Location* loc = _loop_location; + samplepos_t effective_start = start; + Evoral::Range* loop_range (0); -// MidiTrack* mt = dynamic_cast(_track); -// MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0; - MidiChannelFilter* filter = 0; + assert(_midi_buf); - frameoffset_t loop_offset = 0; + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("MDS::midi_read @ %1 cnt %2\n", start, dur)); + + boost::shared_ptr mt = boost::dynamic_pointer_cast(_route); + MidiChannelFilter* filter = mt ? &mt->playback_filter() : 0; + sampleoffset_t loop_offset = 0; if (!reversed && loc) { get_location_times (loc, &loop_start, &loop_end, &loop_length); @@ -1351,10 +1303,10 @@ DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed) if (loc && !reversed) { if (!loop_range) { - loop_range = new Evoral::Range (loop_start, loop_end-1); // inclusive semantics require -1 + loop_range = new Evoral::Range (loop_start, loop_end-1); // inclusive semantics require -1 } - /* if we are (seamlessly) looping, ensure that the first frame we read is at the correct + /* if we are (seamlessly) looping, ensure that the first sample we read is at the correct position within the loop. */ @@ -1379,16 +1331,16 @@ DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed) this_read = min (dur,this_read); - DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset)); + DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("MDS ::read at %1 for %2 loffset %3\n", effective_start, this_read, loop_offset)); if (midi_playlist()->read (*_midi_buf, effective_start, this_read, loop_range, 0, filter) != this_read) { error << string_compose( - _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"), + _("MidiDiskstream %1: cannot read %2 from playlist at sample %3"), id(), this_read, start) << endmsg; return -1; } - g_atomic_int_add (&_frames_written_to_ringbuffer, this_read); + g_atomic_int_add (&_samples_written_to_ringbuffer, this_read); if (reversed) { @@ -1411,7 +1363,6 @@ DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed) } dur -= this_read; - //offset += this_read; } return 0; @@ -1420,14 +1371,14 @@ DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed) int DiskReader::refill_midi () { - if (!_playlists[DataType::MIDI]) { + if (!_playlists[DataType::MIDI] || !_midi_buf) { return 0; } - size_t write_space = _midi_buf->write_space(); + const size_t write_space = _midi_buf->write_space(); const bool reversed = _session.transport_speed() < 0.0f; - DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file frame = %2\n", write_space, file_frame)); + DEBUG_TRACE (DEBUG::DiskIO, string_compose ("MIDI refill, write space = %1 file sample = %2\n", write_space, file_sample[DataType::MIDI])); /* no space to write */ if (write_space == 0) { @@ -1440,26 +1391,102 @@ DiskReader::refill_midi () /* at end: nothing to do */ - if (file_frame == max_framepos) { + samplepos_t ffm = file_sample[DataType::MIDI]; + + if (ffm == max_samplepos) { return 0; } int ret = 0; - const uint32_t frames_read = g_atomic_int_get (&_frames_read_from_ringbuffer); - const uint32_t frames_written = g_atomic_int_get (&_frames_written_to_ringbuffer); + const uint32_t samples_read = g_atomic_int_get (&_samples_read_from_ringbuffer); + const uint32_t samples_written = g_atomic_int_get (&_samples_written_to_ringbuffer); - if ((frames_read < frames_written) && (frames_written - frames_read) >= midi_readahead) { + if ((samples_read < samples_written) && (samples_written - samples_read) >= midi_readahead) { return 0; } - framecnt_t to_read = midi_readahead - ((framecnt_t)frames_written - (framecnt_t)frames_read); + samplecnt_t to_read = midi_readahead - ((samplecnt_t)samples_written - (samplecnt_t)samples_read); - to_read = min (to_read, (framecnt_t) (max_framepos - file_frame)); - to_read = min (to_read, (framecnt_t) write_space); + to_read = min (to_read, (samplecnt_t) (max_samplepos - ffm)); + to_read = min (to_read, (samplecnt_t) write_space); - if (midi_read (file_frame, to_read, reversed)) { + if (midi_read (ffm, to_read, reversed)) { ret = -1; } + file_sample[DataType::MIDI] = ffm; + return ret; } + +void +DiskReader::dec_no_disk_output () +{ + /* this is called unconditionally when things happen that ought to end + a period of "no disk output". It's OK for that to happen when there + was no corresponding call to ::inc_no_disk_output(), but we must + stop the value from becoming negative. + */ + + do { + gint v = g_atomic_int_get (&_no_disk_output); + if (v > 0) { + if (g_atomic_int_compare_and_exchange (&_no_disk_output, v, v - 1)) { + break; + } + } else { + break; + } + } while (true); +} + +DiskReader::DeclickAmp::DeclickAmp (samplecnt_t sample_rate) +{ + _a = 4550.f / (gain_t)sample_rate; + _l = -log1p (_a); + _g = 0; +} + +void +DiskReader::DeclickAmp::apply_gain (AudioBuffer& buf, samplecnt_t n_samples, const float target) +{ + if (n_samples == 0) { + return; + } + float g = _g; + + if (g == target) { + Amp::apply_simple_gain (buf, n_samples, target, 0); + return; + } + + const float a = _a; + Sample* const buffer = buf.data (); + + const int max_nproc = 16; + uint32_t remain = n_samples; + uint32_t offset = 0; + while (remain > 0) { + uint32_t n_proc = remain > max_nproc ? max_nproc : remain; + for (uint32_t i = 0; i < n_proc; ++i) { + buffer[offset + i] *= g; + } +#if 1 + g += a * (target - g); +#else /* accurate exponential fade */ + if (n_proc == max_nproc) { + g += a * (target - g); + } else { + g = target - (target - g) * expf (_l * n_proc / max_nproc); + } +#endif + remain -= n_proc; + offset += n_proc; + } + + if (fabsf (g - target) < /* GAIN_COEFF_DELTA */ 1e-5) { + _g = target; + } else { + _g = g; + } +}