/*
- 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 <paul@linuxaudiosystems.com>
+ * Copyright (C) 2017-2019 Robin Gareus <robin@gareus.org>
+ *
+ * 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 <boost/smart_ptr/scoped_array.hpp>
#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"
#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<void> 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<ChannelList> writer (channels);
- boost::shared_ptr<ChannelList> 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<Sample> (bufsize);
+ /* touch memory to lock it */
+ memset (rbuf->buffer(), 0, sizeof (Sample) * rbuf->bufsize());
+}
- c->clear();
+int
+DiskReader::add_channel_to (boost::shared_ptr<ChannelList> 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
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];
}
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;
}
bool
DiskReader::set_name (string const & str)
{
- string my_name = X_("reader:");
+ string my_name = X_("player:");
my_name += str;
if (_name != my_name) {
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;
}
void
DiskReader::realtime_handle_transport_stopped ()
{
- realtime_speed_change ();
}
void
return 1.0;
}
- PBD::RingBufferNPT<Sample> * b = c->front()->buf;
+ PBD::PlaybackBuffer<Sample>* b = c->front()->rbuf;
return (float) ((double) b->read_space() / (double) b->bufsize());
}
}
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<ChannelList> c = channels.reader();
ChannelList::iterator chan;
- frameoffset_t playback_distance;
+ sampleoffset_t disk_samples_to_consume;
MonitorState ms = _route->monitoring_state ();
if (_active) {
}
}
- _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 {
gain_t scaling;
if (n_chans > n_buffers) {
- scaling = ((float) n_buffers)/n_chans;
+ scaling = ((float) n_buffers) / n_chans;
} else {
scaling = 1.0;
}
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));
- disk_signal += chaninfo->rw_vector.len[0];
- memcpy (disk_signal,
- 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<samplepos_t> 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;
}
}
}
if (_playlists[DataType::MIDI]) {
/* MIDI butler needed part */
- uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
- uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
+ uint32_t samples_read = g_atomic_int_get(const_cast<gint*>(&_samples_read_from_ringbuffer));
+ uint32_t samples_written = g_atomic_int_get(const_cast<gint*>(&_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
*
* 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.
* 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));
+ // 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<ChannelList> 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<ChannelList> 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<ChannelList> 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<Sample> mixdown_buffer (new Sample[size]);
- std::auto_ptr<float> gain_buffer (new float[size]);
+ boost::scoped_array<Sample> sum_buffer (new Sample[size]);
+ boost::scoped_array<Sample> mixdown_buffer (new Sample[size]);
+ boost::scoped_array<float> 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:
_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<ChannelList> 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
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
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 */
boost::shared_ptr<ChannelList> 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<ChannelList> 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
/** 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<Sample>*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;
}
if (!reversed) {
- framecnt_t loop_length = 0;
+ samplecnt_t loop_length = 0;
/* Make the use of a Location atomic for this read operation.
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.
*/
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 {
}
}
+ if (rb->write (sum_buffer, this_read) != this_read) {
+ cerr << owner()->name() << " Ringbuffer Write overrun" << endl;
+ }
+
cnt -= this_read;
- offset += this_read;
}
return 0;
*/
{
- std::auto_ptr<Sample> mix_buf (new Sample[2*1048576]);
- std::auto_ptr<float> gain_buf (new float[2*1048576]);
+ boost::scoped_array<Sample> sum_buf (new Sample[2*1048576]);
+ boost::scoped_array<Sample> mix_buf (new Sample[2*1048576]);
+ boost::scoped_array<float> 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;
}
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;
*/
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.
}
int32_t ret = 0;
- framecnt_t to_read;
- RingBufferNPT<Sample>::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<ChannelList> c = channels.reader();
- framecnt_t ts;
if (c->empty()) {
return 0;
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;
}
/* 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;
}
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 */
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 << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
+ // 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<framepos_t> > const & movements_frames, bool from_undo)
+DiskReader::playlist_ranges_moved (list< Evoral::RangeMove<samplepos_t> > 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;
}
list< Evoral::RangeMove<double> > movements;
- for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin();
- i != movements_frames.end();
+ for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin();
+ i != movements_samples.end();
++i) {
movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
}
}
/* 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<Processor> p, list< Evoral::RangeMove<framepos_t> > const & movements_frames)
+DiskReader::move_processor_automation (boost::weak_ptr<Processor> p, list< Evoral::RangeMove<samplepos_t> > const & movements_samples)
{
boost::shared_ptr<Processor> processor (p.lock ());
if (!processor) {
}
list< Evoral::RangeMove<double> > movements;
- for (list< Evoral::RangeMove<framepos_t> >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) {
+ for (list< Evoral::RangeMove<samplepos_t> >::const_iterator i = movements_samples.begin(); i != movements_samples.end(); ++i) {
movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
}
}
}
-boost::shared_ptr<MidiBuffer>
-DiskReader::get_gui_feed_buffer () const
-{
- boost::shared_ptr<MidiBuffer> 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<MidiPlaylist> mp (midi_playlist());
}
void
-DiskReader::resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time)
+DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
{
- _midi_buf->resolve_tracker(buffer, time);
+ if (_midi_buf) {
+ _midi_buf->resolve_tracker(buffer, time);
+ }
boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
* 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";
size_t events_read = 0;
if (loc) {
- framepos_t effective_start;
+ samplepos_t effective_start;
- Evoral::Range<framepos_t> loop_range (loc->start(), loc->end() - 1);
- effective_start = loop_range.squish (playback_sample);
+ Evoral::Range<samplepos_t> 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
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<MidiBuffer::TimeType> 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<framepos_t>* 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<samplepos_t>* loop_range (0);
-// MidiTrack* mt = dynamic_cast<MidiTrack*>(_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<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_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);
if (loc && !reversed) {
if (!loop_range) {
- loop_range = new Evoral::Range<framepos_t> (loop_start, loop_end-1); // inclusive semantics require -1
+ loop_range = new Evoral::Range<samplepos_t> (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.
*/
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) {
}
dur -= this_read;
- //offset += this_read;
}
return 0;
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) {
/* 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;
+ }
+}
projects / ardour.git / blobdiff