mirror of
https://github.com/Ardour/ardour.git
synced 2026-01-11 07:56:27 +01:00
922ad14217
AudioPlaylist::read first clears the buffer passed to it, in order to sum all layered regions into the buffer. This cleared data in the ringbuffer that is concurrently being used for playback.
1984 lines
58 KiB
C++
1984 lines
58 KiB
C++
/*
|
|
* 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/memento_command.h"
|
|
#include "pbd/playback_buffer.h"
|
|
|
|
#include "temporal/range.h"
|
|
|
|
#include "ardour/amp.h"
|
|
#include "ardour/audio_buffer.h"
|
|
#include "ardour/audioengine.h"
|
|
#include "ardour/audioplaylist.h"
|
|
#include "ardour/butler.h"
|
|
#include "ardour/debug.h"
|
|
#include "ardour/disk_reader.h"
|
|
#include "ardour/midi_playlist.h"
|
|
#include "ardour/midi_ring_buffer.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::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;
|
|
std::atomic<int> DiskReader::_no_disk_output (0);
|
|
DiskReader::Declicker DiskReader::loop_declick_in;
|
|
DiskReader::Declicker DiskReader::loop_declick_out;
|
|
samplecnt_t DiskReader::loop_fade_length (0);
|
|
|
|
DiskReader::DiskReader (Session& s, Track& t, string const& str, Temporal::TimeDomainProvider const & tdp, DiskIOProcessor::Flag f)
|
|
: DiskIOProcessor (s, t, X_("player:") + str, f, tdp)
|
|
, overwrite_sample (0)
|
|
, run_must_resolve (false)
|
|
, _declick_amp (s.nominal_sample_rate ())
|
|
, _declick_offs (0)
|
|
, _declick_enabled (false)
|
|
, last_refill_loop_start (0)
|
|
, _midi_catchup (false)
|
|
, _need_midi_catchup (false)
|
|
{
|
|
file_sample[DataType::AUDIO] = 0;
|
|
file_sample[DataType::MIDI] = 0;
|
|
_pending_overwrite.store (OverwriteReason (0));
|
|
}
|
|
|
|
DiskReader::~DiskReader ()
|
|
{
|
|
DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskReader %1 @ %2 deleted\n", _name, this));
|
|
}
|
|
|
|
std::string
|
|
DiskReader::display_name () const
|
|
{
|
|
return std::string (_("Player"));
|
|
}
|
|
|
|
void
|
|
DiskReader::ReaderChannelInfo::resize (samplecnt_t bufsize)
|
|
{
|
|
delete rbuf;
|
|
rbuf = 0;
|
|
|
|
rbuf = new PlaybackBuffer<Sample> (bufsize);
|
|
/* touch memory to lock it */
|
|
memset (rbuf->buffer (), 0, sizeof (Sample) * rbuf->bufsize ());
|
|
initialized = false;
|
|
}
|
|
|
|
void
|
|
DiskReader::ReaderChannelInfo::resize_preloop (samplecnt_t bufsize)
|
|
{
|
|
if (bufsize == 0) {
|
|
return;
|
|
}
|
|
|
|
if (bufsize > pre_loop_buffer_size) {
|
|
delete[] pre_loop_buffer;
|
|
pre_loop_buffer = new Sample[bufsize];
|
|
pre_loop_buffer_size = bufsize;
|
|
}
|
|
}
|
|
|
|
int
|
|
DiskReader::add_channel_to (std::shared_ptr<ChannelList> c, uint32_t how_many)
|
|
{
|
|
while (how_many--) {
|
|
c->push_back (new ReaderChannelInfo (_session.butler ()->audio_playback_buffer_size (), loop_fade_length));
|
|
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 ()));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
DiskReader::allocate_working_buffers ()
|
|
{
|
|
/* with varifill buffer refilling, we compute the read size in bytes (to optimize
|
|
for disk i/o bandwidth) and then convert back into samples. These 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];
|
|
}
|
|
|
|
void
|
|
DiskReader::free_working_buffers ()
|
|
{
|
|
delete[] _sum_buffer;
|
|
delete[] _mixdown_buffer;
|
|
delete[] _gain_buffer;
|
|
_sum_buffer = 0;
|
|
_mixdown_buffer = 0;
|
|
_gain_buffer = 0;
|
|
}
|
|
|
|
samplecnt_t
|
|
DiskReader::default_chunk_samples ()
|
|
{
|
|
return 65536;
|
|
}
|
|
|
|
bool
|
|
DiskReader::set_name (string const& str)
|
|
{
|
|
string my_name = X_("player:");
|
|
my_name += str;
|
|
|
|
if (_name != my_name) {
|
|
SessionObject::set_name (my_name);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
XMLNode&
|
|
DiskReader::state () const
|
|
{
|
|
XMLNode& node (DiskIOProcessor::state ());
|
|
node.set_property (X_("type"), X_("diskreader"));
|
|
return node;
|
|
}
|
|
|
|
int
|
|
DiskReader::set_state (const XMLNode& node, int version)
|
|
{
|
|
if (DiskIOProcessor::set_state (node, version)) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
DiskReader::realtime_handle_transport_stopped ()
|
|
{
|
|
if (_session.exporting () && !_session.realtime_export ()) {
|
|
_declick_amp.set_gain (0);
|
|
}
|
|
/* can't do the resolve here because we don't have a place to put the
|
|
* note resolving data. Defer to
|
|
* MidiTrack::realtime_handle_transport_stopped() which will call
|
|
* ::resolve_tracker() and put the output in its _immediate_events store.
|
|
*/
|
|
}
|
|
|
|
void
|
|
DiskReader::realtime_locate (bool for_loop_end)
|
|
{
|
|
if (!for_loop_end) {
|
|
MidiTrack* mt = dynamic_cast<MidiTrack*> (&_track);
|
|
_tracker.resolve_notes (mt->immediate_events (), 0);
|
|
}
|
|
}
|
|
|
|
float
|
|
DiskReader::buffer_load () const
|
|
{
|
|
/* Note: for MIDI it's not trivial to differentiate the following two cases:
|
|
*
|
|
* 1. The playback buffer is empty because the system has run out of time to fill it.
|
|
* 2. The playback buffer is empty because there is no more data on the playlist.
|
|
*
|
|
* If we use a simple buffer load computation, we will report that the MIDI diskstream
|
|
* cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
|
|
* are so low compared to audio, just use the audio value here.
|
|
*/
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
if (c->empty ()) {
|
|
/* no channels, so no buffers, so completely full and ready to playback, sir! */
|
|
return 1.0;
|
|
}
|
|
|
|
PBD::PlaybackBuffer<Sample>* b = c->front ()->rbuf;
|
|
return (float)((double)b->read_space () / (double)b->bufsize ());
|
|
}
|
|
|
|
void
|
|
DiskReader::adjust_buffering ()
|
|
{
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
for (auto const& chan : *c) {
|
|
chan->resize (_session.butler ()->audio_playback_buffer_size ());
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::playlist_modified ()
|
|
{
|
|
_session.request_overwrite_buffer (_track.shared_ptr (), PlaylistModified);
|
|
}
|
|
|
|
int
|
|
DiskReader::use_playlist (DataType dt, std::shared_ptr<Playlist> playlist)
|
|
{
|
|
bool prior_playlist = false;
|
|
|
|
if (_playlists[dt]) {
|
|
prior_playlist = true;
|
|
}
|
|
|
|
if (DiskIOProcessor::use_playlist (dt, playlist)) {
|
|
return -1;
|
|
}
|
|
|
|
/* don't do this if we've already asked for it *or* if we are setting up
|
|
* the diskstream for the very first time - the input changed handling will
|
|
* take care of the buffer refill. */
|
|
|
|
if (!(_pending_overwrite.load () & PlaylistChanged) || prior_playlist) {
|
|
_session.request_overwrite_buffer (_track.shared_ptr (), PlaylistChanged);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
DiskReader::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool result_required)
|
|
{
|
|
uint32_t n;
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
ChannelList::const_iterator chan;
|
|
sampleoffset_t disk_samples_to_consume;
|
|
MonitorState ms = _track.monitoring_state ();
|
|
const bool midi_only = (c->empty () || !_playlists[DataType::AUDIO]);
|
|
bool no_disk_output = _no_disk_output.load () != 0;
|
|
|
|
if (!check_active ()) {
|
|
return;
|
|
}
|
|
|
|
const gain_t target_gain = ((speed == 0.0) || ((ms & MonitoringDisk) == 0)) ? 0.0 : 1.0;
|
|
bool declick_out = (_declick_amp.gain () != target_gain) && target_gain == 0.0;
|
|
|
|
if (declick_out && _declick_amp.gain () == GAIN_COEFF_UNITY) {
|
|
/* beginning a de-click, set de-click reason */
|
|
if (speed == 0) {
|
|
_declick_enabled = _session.cfg ()->get_use_transport_fades ();
|
|
} else {
|
|
_declick_enabled = _session.cfg ()->get_use_monitor_fades ();
|
|
}
|
|
} else if (_declick_amp.gain () == GAIN_COEFF_ZERO && speed == 0) {
|
|
/* fade in */
|
|
_declick_enabled = _session.cfg ()->get_use_transport_fades ();
|
|
}
|
|
|
|
if (!_declick_enabled || (_session.exporting () && !_session.realtime_export ())) {
|
|
/* no transport fades or exporting - no declick out logic */
|
|
|
|
if (!midi_only) {
|
|
_declick_amp.set_gain (target_gain);
|
|
declick_out = false;
|
|
}
|
|
|
|
} else {
|
|
/* using transport fades and not exporting - declick login in effect */
|
|
|
|
if (ms == MonitoringDisk) {
|
|
/* Only monitoring from disk, so if we've finished a
|
|
* declick (for stop/locate), do not accidentally pass
|
|
* any data from disk to our outputs.
|
|
*/
|
|
|
|
if ((target_gain == 0.0) && (_declick_amp.gain () == target_gain)) {
|
|
/* we were heading for zero (declick out for
|
|
* stop), and we've reached there. Done. */
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count ()));
|
|
const bool still_locating = _session.global_locate_pending ();
|
|
|
|
assert (speed == -1 || speed == 0 || speed == 1);
|
|
|
|
if (speed == 0) {
|
|
disk_samples_to_consume = 0;
|
|
} else {
|
|
disk_samples_to_consume = nframes;
|
|
}
|
|
|
|
if (midi_only) {
|
|
/* do nothing with audio */
|
|
goto midi;
|
|
}
|
|
|
|
if (declick_out) {
|
|
/* fade-out */
|
|
|
|
// 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());
|
|
|
|
ms = MonitorState (ms | MonitoringDisk);
|
|
assert (result_required);
|
|
result_required = true;
|
|
disk_samples_to_consume = 0; // non-committing read
|
|
} 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 */
|
|
|
|
if (!still_locating || no_disk_output) {
|
|
for (auto const& chan : *c) {
|
|
assert (chan->rbuf);
|
|
chan->rbuf->increment_read_ptr (disk_samples_to_consume);
|
|
}
|
|
}
|
|
|
|
/* if monitoring disk but locating put silence in the buffers */
|
|
|
|
if ((no_disk_output || still_locating) && (ms == MonitoringDisk)) {
|
|
bufs.silence (nframes, 0);
|
|
}
|
|
|
|
} else {
|
|
/* we need audio data from disk */
|
|
|
|
size_t n_buffers = bufs.count ().n_audio ();
|
|
size_t n_chans = c->size ();
|
|
gain_t scaling;
|
|
|
|
if (n_chans > n_buffers) {
|
|
scaling = ((float)n_buffers) / n_chans;
|
|
} else {
|
|
scaling = 1.0;
|
|
}
|
|
|
|
const float initial_declick_gain = _declick_amp.gain ();
|
|
const sampleoffset_t declick_offs = _declick_offs;
|
|
|
|
for (n = 0, chan = c->begin (); chan != c->end (); ++chan, ++n) {
|
|
ReaderChannelInfo* chaninfo = dynamic_cast<ReaderChannelInfo*> (*chan);
|
|
AudioBuffer& output (bufs.get_audio (n % n_buffers));
|
|
|
|
AudioBuffer& disk_buf ((ms & MonitoringInput) ? scratch_bufs.get_audio (n) : output);
|
|
|
|
if (start_sample != playback_sample && target_gain != 0) {
|
|
samplepos_t ss = start_sample;
|
|
Location* loc = _loop_location;
|
|
if (loc) {
|
|
Temporal::Range loop_range (loc->start (), loc->end ());
|
|
ss = loop_range.squish (timepos_t (playback_sample)).samples ();
|
|
playback_sample = ss;
|
|
}
|
|
if (ss != playback_sample) {
|
|
if (can_internal_playback_seek (ss - playback_sample)) {
|
|
internal_playback_seek (ss - playback_sample);
|
|
} else {
|
|
disk_samples_to_consume = 0; /* will force an underrun below */
|
|
}
|
|
}
|
|
}
|
|
|
|
/* reset _declick_amp to the correct gain before processing this channel. */
|
|
_declick_amp.set_gain (initial_declick_gain);
|
|
|
|
if (!declick_out) {
|
|
const samplecnt_t available = chaninfo->rbuf->read (disk_buf.data (), disk_samples_to_consume);
|
|
|
|
if (available == 0 && !chaninfo->initialized) {
|
|
disk_buf.silence (disk_samples_to_consume);
|
|
} else if (disk_samples_to_consume > available) {
|
|
cerr << "underrun for " << _name << " Available samples: " << available << " required: " << disk_samples_to_consume << endl;
|
|
DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3 vs %4\n", DEBUG_THREAD_SELF, name (), available, disk_samples_to_consume));
|
|
Underrun ();
|
|
return;
|
|
}
|
|
|
|
} else if (_declick_amp.gain () != target_gain) {
|
|
assert (target_gain == 0);
|
|
|
|
/* note that this is a non-committing read: it
|
|
* retrieves data from the ringbuffer but does not
|
|
* advance the read pointer. As a result,
|
|
* subsequent calls (as we declick) need to
|
|
* pass in an offset describing where to read
|
|
* from. We maintain _declick_offs across calls
|
|
* to ::run()
|
|
*/
|
|
|
|
const samplecnt_t total = chaninfo->rbuf->read (disk_buf.data (), nframes, false, declick_offs);
|
|
|
|
if (n == 0) {
|
|
_declick_offs += total;
|
|
}
|
|
}
|
|
|
|
_declick_amp.apply_gain (disk_buf, nframes, target_gain);
|
|
|
|
/* _declick_amp is now left with the correct gain after processing nframes */
|
|
|
|
Amp::apply_simple_gain (disk_buf, nframes, scaling);
|
|
|
|
if (ms & MonitoringInput) {
|
|
/* mix the disk signal into the input signal (already in bufs) */
|
|
mix_buffers_no_gain (output.data (), disk_buf.data (), nframes);
|
|
}
|
|
}
|
|
}
|
|
|
|
midi:
|
|
|
|
/* MIDI data handling */
|
|
|
|
const bool no_playlist_modification_pending = !(pending_overwrite () & PlaylistModified);
|
|
|
|
if (bufs.count ().n_midi ()) {
|
|
MidiBuffer& dst (bufs.get_midi (0));
|
|
|
|
if (run_must_resolve) {
|
|
resolve_tracker (dst, 0);
|
|
run_must_resolve = false;
|
|
}
|
|
|
|
if (!no_disk_output && !declick_in_progress () && (ms & MonitoringDisk) && !still_locating && no_playlist_modification_pending && speed) {
|
|
get_midi_playback (dst, start_sample, end_sample, ms, scratch_bufs, speed, disk_samples_to_consume);
|
|
}
|
|
}
|
|
|
|
/* decide if we need the butler */
|
|
|
|
if (!still_locating && no_playlist_modification_pending) {
|
|
bool butler_required = false;
|
|
|
|
if (speed < 0.0) {
|
|
playback_sample -= disk_samples_to_consume;
|
|
} else {
|
|
playback_sample += disk_samples_to_consume;
|
|
}
|
|
|
|
Location* loc = _loop_location;
|
|
if (loc) {
|
|
Temporal::Range loop_range (loc->start (), loc->end ());
|
|
playback_sample = loop_range.squish (timepos_t (playback_sample)).samples ();
|
|
}
|
|
|
|
if (_playlists[DataType::AUDIO]) {
|
|
if (!c->empty ()) {
|
|
if (_slaved) {
|
|
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 ((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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* All of MIDI is in RAM, no need to call the butler unless we
|
|
* have to overwrite buffers because of a playlist change.
|
|
*/
|
|
|
|
_need_butler = butler_required;
|
|
}
|
|
|
|
if (_need_butler) {
|
|
DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 reader run, needs butler = %2\n", name (), _need_butler));
|
|
}
|
|
}
|
|
|
|
bool
|
|
DiskReader::declick_in_progress () const
|
|
{
|
|
if (!_declick_enabled || (_session.exporting () && !_session.realtime_export ())) {
|
|
return false;
|
|
}
|
|
return _declick_amp.gain () != 0; // declick-out
|
|
}
|
|
|
|
void
|
|
DiskReader::configuration_changed ()
|
|
{
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
if (!c->empty ()) {
|
|
ReaderChannelInfo* chaninfo = dynamic_cast<ReaderChannelInfo*> (c->front ());
|
|
if (!chaninfo->initialized) {
|
|
seek (_session.transport_sample (), true);
|
|
return;
|
|
}
|
|
}
|
|
_session.request_overwrite_buffer (_track.shared_ptr (), LoopDisabled);
|
|
}
|
|
|
|
bool
|
|
DiskReader::pending_overwrite () const
|
|
{
|
|
return _pending_overwrite.load () != 0;
|
|
}
|
|
|
|
void
|
|
DiskReader::set_pending_overwrite (OverwriteReason why)
|
|
{
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
/* called from audio thread, so we can use the read ptr and playback sample as we wish */
|
|
|
|
if (!c->empty ()) {
|
|
if (c->size () > 1) {
|
|
/* Align newly added buffers.
|
|
*
|
|
* overwrite_sample and file_sample[] are are maintained
|
|
* per DiskReader, not per channel.
|
|
* ::refill_audio() and ::overwrite_existing_audio() expect
|
|
* that read-pointers and fill_level of all buffers are in sync.
|
|
*/
|
|
ChannelList::const_iterator chan = c->begin ();
|
|
for (++chan; chan != c->end (); ++chan) {
|
|
ReaderChannelInfo* chaninfo = dynamic_cast<ReaderChannelInfo*> (*chan);
|
|
if (!chaninfo->initialized) {
|
|
(*chan)->rbuf->align_to (*(c->front ()->rbuf));
|
|
}
|
|
}
|
|
}
|
|
|
|
const samplecnt_t reserved_size = c->front ()->rbuf->reserved_size ();
|
|
const samplecnt_t bufsize = c->front ()->rbuf->bufsize ();
|
|
|
|
overwrite_offset = c->front ()->rbuf->read_ptr ();
|
|
overwrite_sample = playback_sample - reserved_size;
|
|
|
|
if (overwrite_offset > reserved_size) {
|
|
/*
|
|
* |----------------------------------------------------------------------|
|
|
* ^ ^
|
|
* RRRRRRRRRRRRRRRRoverwrite_offset (old read_ptr)
|
|
* |<- second ->|<------------------ first chunk ------------------------>|
|
|
*
|
|
* Fill the the end of the buffer ("first chunk"), above
|
|
*/
|
|
|
|
overwrite_offset -= reserved_size;
|
|
|
|
} else {
|
|
/*
|
|
* |----------------------------------------------------------------------|
|
|
* RRRRRRRRE^ RRRRRRRRR
|
|
* overwrite_offset (old read_ptr)
|
|
* |< second chunk >|<first>|
|
|
*
|
|
* Fill the end of the buffer ("R1R1R1" aka "first" above)
|
|
*/
|
|
|
|
overwrite_offset = bufsize - (reserved_size - overwrite_offset);
|
|
}
|
|
}
|
|
|
|
if (why & (LoopChanged | PlaylistModified | PlaylistChanged)) {
|
|
run_must_resolve = true;
|
|
}
|
|
|
|
while (true) {
|
|
OverwriteReason current = OverwriteReason (_pending_overwrite.load ());
|
|
OverwriteReason next = OverwriteReason (current | why);
|
|
if (_pending_overwrite.compare_exchange_strong (current, next)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
DiskReader::overwrite_existing_audio ()
|
|
{
|
|
/* This is a tricky and/or clever little method. Let's try to describe
|
|
* precisely what it does.
|
|
*
|
|
* Our goal is to completely overwrite the playback buffers for each
|
|
* audio channel with new data. The wrinkle is that we want to preserve
|
|
* the EXACT mapping between a given timeline position and buffer
|
|
* offset that existed when we requested an overwrite. That is, if the
|
|
* Nth position in the buffer contained the sample corresponding to
|
|
* timeline position T, then once this is complete that condition
|
|
* should still hold. The actual value of the sample (and even whether it
|
|
* corresponds to any actual material on disk - it may just be silence)
|
|
* may change, but this buffer_offset<->timeline_position mapping must
|
|
* remain constant.
|
|
*
|
|
* Why do this? There are many reasons. A trivial example is that the
|
|
* region gain level for one region has been changed, and the user
|
|
* should be able to hear the result.
|
|
*
|
|
* In ::set_pending_overwrite() (above) we stored a sample and a buffer
|
|
* offset. These corresponded to the next sample to be played and the
|
|
* buffer position holding that sample. We were able to determine this
|
|
* pair atomically because ::set_pending_overwrite() is called from
|
|
* within process context, and thus neither playback_sample nor the
|
|
* buffer read ptr can change while it runs. We computed the earliest
|
|
* sample/timeline position in the buffer (at the start of the reserved
|
|
* zone, if any) and its corresponding buffer offset.
|
|
*
|
|
* Here, we will refill the buffer, starting with the sample and buffer
|
|
* offset computed by ::set_pending_overwrite(). Typically this will
|
|
* take two reads from the playlist, because our read will be "split"
|
|
* by the end of the buffer (i.e. we fill from some mid-buffer point to
|
|
* the end, then fill from the start to the mid-buffer point, as is
|
|
* common with ring buffers).
|
|
*
|
|
* Note that the process thread may indeed access the buffer while we
|
|
* are doing this. There is a strong likelihood of colliding read/write
|
|
* between this thread (the butler) and a process thread. But we don't
|
|
* care: we know that the samples being read/written will correspond to
|
|
* the same timeline position, and that the user has just done
|
|
* something forcing us to update the value(s). Given that a Sample is
|
|
* currently (and likely forever) a floating point value, and that on
|
|
* many/most architectures, a store for a floating point value is
|
|
* non-atomic, there is some chance of the process read reading a
|
|
* sample value while it is being written. This could theoretically
|
|
* cause a brief glitch, but no more or less than any other
|
|
* "discontinuity" in the sample's value will.
|
|
*
|
|
* It goes without saying that this relies on being serialized within
|
|
* the butler thread with respect any other buffer write operation
|
|
* (e.g. via ::refill()). It should also be noted that it has no effect
|
|
* at all on the write-related members of the playback buffer - we
|
|
* simply replace the contents of the buffer.
|
|
*/
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
if (c->empty ()) {
|
|
return true;
|
|
}
|
|
|
|
const bool reversed = !_session.transport_will_roll_forwards ();
|
|
|
|
sampleoffset_t chunk1_offset;
|
|
size_t chunk1_cnt;
|
|
size_t chunk2_cnt;
|
|
|
|
const size_t to_overwrite = c->front ()->rbuf->overwritable_at (overwrite_offset);
|
|
|
|
chunk1_offset = overwrite_offset;
|
|
chunk1_cnt = min (c->front ()->rbuf->bufsize () - (size_t)overwrite_offset, to_overwrite);
|
|
|
|
/* note: because we are overwriting buffer contents but not moving the
|
|
* write/read pointers, we actually want to fill all the way to the
|
|
* write pointer (the value returned by PlaybackBuffer::overwritable_at().
|
|
*
|
|
* This differs from what happens during ::refill_audio() where we are
|
|
* careful not to allow the read pointer to catch the write pointer
|
|
* (that indicates an empty buffer)
|
|
*/
|
|
|
|
if (chunk1_cnt == to_overwrite) {
|
|
chunk2_cnt = 0;
|
|
} else {
|
|
chunk2_cnt = to_overwrite - chunk1_cnt;
|
|
}
|
|
|
|
boost::scoped_array<Sample> sum_buffer (new Sample[to_overwrite]);
|
|
boost::scoped_array<Sample> mixdown_buffer (new Sample[to_overwrite]);
|
|
boost::scoped_array<float> gain_buffer (new float[to_overwrite]);
|
|
uint32_t n = 0;
|
|
bool ret = true;
|
|
samplepos_t start;
|
|
|
|
for (auto const& chan : *c) {
|
|
Sample* buf = chan->rbuf->buffer ();
|
|
ReaderChannelInfo* rci = dynamic_cast<ReaderChannelInfo*> (chan);
|
|
|
|
/* Note that @p start is passed by reference and will be
|
|
* updated by the ::audio_read() call
|
|
*/
|
|
|
|
start = overwrite_sample;
|
|
|
|
if (chunk1_cnt) {
|
|
if (audio_read (sum_buffer.get (), mixdown_buffer.get (), gain_buffer.get (), start, chunk1_cnt, rci, n, reversed) != (samplecnt_t)chunk1_cnt) {
|
|
error << string_compose (_("DiskReader %1: when overwriting(1), cannot read %2 from playlist at sample %3"), id (), chunk1_cnt, overwrite_sample) << endmsg;
|
|
ret = false;
|
|
++n;
|
|
continue;
|
|
}
|
|
memcpy (buf + chunk1_offset, sum_buffer.get (), sizeof (float) * chunk1_cnt);
|
|
}
|
|
|
|
if (chunk2_cnt) {
|
|
if (audio_read (sum_buffer.get (), mixdown_buffer.get (), gain_buffer.get (), start, chunk2_cnt, rci, n, reversed) != (samplecnt_t)chunk2_cnt) {
|
|
error << string_compose (_("DiskReader %1: when overwriting(2), cannot read %2 from playlist at sample %3"), id (), chunk2_cnt, overwrite_sample) << endmsg;
|
|
ret = false;
|
|
}
|
|
memcpy (buf, sum_buffer.get (), sizeof (float) * chunk2_cnt);
|
|
}
|
|
|
|
if (!rci->initialized) {
|
|
DEBUG_TRACE (DEBUG::DiskIO, string_compose ("Init ReaderChannel '%1' overwriting at: %2, avail: %3\n", name (), overwrite_sample, chan->rbuf->read_space ()));
|
|
if (chan->rbuf->read_space () > 0) {
|
|
rci->initialized = true;
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
|
|
file_sample[DataType::AUDIO] = start;
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool
|
|
DiskReader::overwrite_existing_midi ()
|
|
{
|
|
RTMidiBuffer* mbuf = rt_midibuffer ();
|
|
|
|
if (mbuf) {
|
|
MidiTrack* mt = dynamic_cast<MidiTrack*> (&_track);
|
|
MidiChannelFilter* filter = mt ? &mt->playback_filter () : 0;
|
|
|
|
#ifdef PROFILE_MIDI_IO
|
|
PBD::Timing minsert;
|
|
minsert.start ();
|
|
#endif
|
|
|
|
midi_playlist ()->render (filter);
|
|
assert (midi_playlist ()->rendered ());
|
|
|
|
#ifdef PROFILE_MIDI_IO
|
|
minsert.update ();
|
|
cerr << "Reading " << name () << " took " << minsert.elapsed () << " microseconds, final size = " << midi_playlist ()->rendered ()->size () << endl;
|
|
#endif
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
DiskReader::overwrite_existing_buffers ()
|
|
{
|
|
/* called from butler thread */
|
|
|
|
DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 overwriting existing buffers at %2 (because %3%4%5\n", owner ()->name (), overwrite_sample, std::hex, _pending_overwrite.load (), std::dec));
|
|
|
|
bool ret = true;
|
|
|
|
if (_pending_overwrite.load () & (PlaylistModified | LoopDisabled | LoopChanged | PlaylistChanged)) {
|
|
if (_playlists[DataType::AUDIO] && !overwrite_existing_audio ()) {
|
|
ret = false;
|
|
}
|
|
}
|
|
|
|
if (_pending_overwrite.load () & (PlaylistModified | PlaylistChanged)) {
|
|
if (_playlists[DataType::MIDI] && !overwrite_existing_midi ()) {
|
|
ret = false;
|
|
}
|
|
}
|
|
|
|
_pending_overwrite.store (OverwriteReason (0));
|
|
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
DiskReader::seek (samplepos_t sample, bool complete_refill)
|
|
{
|
|
/* called via non_realtime_locate() from butler thread */
|
|
|
|
int ret = -1;
|
|
|
|
const bool read_reversed = !_session.transport_will_roll_forwards ();
|
|
const bool read_loop = (bool)_loop_location;
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
if (c->empty ()) {
|
|
return 0;
|
|
}
|
|
|
|
/* There are two possible shortcuts we can take that will completely
|
|
* skip reading from disk. However, they are invalid if we need to read
|
|
* data in the opposite direction than we did last time, or if our need
|
|
* for looped data has changed since the last read. Both of these change
|
|
* the semantics of a read from disk, even if the position we are
|
|
* reading from is the same.
|
|
*/
|
|
|
|
if ((_last_read_reversed.value_or (read_reversed) == read_reversed) && (_last_read_loop.value_or (read_loop) == read_loop)) {
|
|
if (sample == playback_sample && !complete_refill) {
|
|
return 0;
|
|
}
|
|
|
|
if ((size_t)abs (sample - playback_sample) < (c->front ()->rbuf->reserved_size () / 6)) {
|
|
/* we're close enough. Note: this is a heuristic */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
_pending_overwrite.store (OverwriteReason (0));
|
|
|
|
DEBUG_TRACE (DEBUG::DiskIO, string_compose ("DiskReader::seek %1 %2 -> %3 refill=%4\n", owner ()->name ().c_str (), playback_sample, sample, complete_refill));
|
|
|
|
const samplecnt_t distance = sample - playback_sample;
|
|
if (!complete_refill && can_internal_playback_seek (distance)) {
|
|
internal_playback_seek (distance);
|
|
return 0;
|
|
}
|
|
|
|
for (auto const& chan : *c) {
|
|
chan->rbuf->reset ();
|
|
assert (chan->rbuf->reserved_size () == 0);
|
|
}
|
|
|
|
/* move the intended read target, so that after the refill is done,
|
|
* the intended read target is "reservation" from the start of the
|
|
* playback buffer. Then increment the read ptr, so that we can
|
|
* potentially do an internal seek backwards of up "reservation"
|
|
* samples.
|
|
*/
|
|
|
|
const samplecnt_t rsize = (samplecnt_t)c->front ()->rbuf->reservation_size ();
|
|
samplecnt_t shift = (sample > rsize ? rsize : sample);
|
|
|
|
if (read_reversed) {
|
|
/* reading in reverse, so start at a later sample, and read
|
|
* "backwards" from there. */
|
|
shift = -shift;
|
|
}
|
|
|
|
/* start the read at an earlier position (or later if reversed) */
|
|
|
|
sample -= shift;
|
|
|
|
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
|
|
* the largest reads possible. */
|
|
while ((ret = do_refill_with_alloc (false, read_reversed)) > 0)
|
|
;
|
|
} else {
|
|
/* call _do_refill() to refill just one chunk, and then return. */
|
|
ret = do_refill_with_alloc (true, read_reversed);
|
|
}
|
|
|
|
if (shift) {
|
|
/* now tell everyone where we really are, leaving the
|
|
* "reserved" data represented by "shift" available in the
|
|
* buffer for backwards-internal-seek
|
|
*/
|
|
|
|
playback_sample += shift;
|
|
|
|
/* we always move the read-ptr forwards, since even when in
|
|
* reverse, the data is placed in the buffer in normal read
|
|
* (increment) order.
|
|
*/
|
|
|
|
shift = abs (shift);
|
|
|
|
for (auto const& chan : *c) {
|
|
chan->rbuf->increment_read_ptr (shift);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool
|
|
DiskReader::can_internal_playback_seek (sampleoffset_t distance)
|
|
{
|
|
/* 1. Audio */
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
for (auto const& chan : *c) {
|
|
if (!chan->rbuf->can_seek (distance)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* 2. MIDI can always seek any distance */
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
DiskReader::internal_playback_seek (sampleoffset_t distance)
|
|
{
|
|
if (distance == 0) {
|
|
return;
|
|
}
|
|
|
|
sampleoffset_t off = distance;
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
for (auto const& chan : *c) {
|
|
if (distance < 0) {
|
|
off = 0 - (sampleoffset_t)chan->rbuf->decrement_read_ptr (::llabs (distance));
|
|
} else {
|
|
off = chan->rbuf->increment_read_ptr (distance);
|
|
}
|
|
}
|
|
|
|
playback_sample += off;
|
|
}
|
|
|
|
static void
|
|
swap_by_ptr (Sample* first, Sample* last)
|
|
{
|
|
while (first < last) {
|
|
Sample tmp = *first;
|
|
*first++ = *last;
|
|
*last-- = tmp;
|
|
}
|
|
}
|
|
|
|
/** Read some data for 1 channel from our playlist into a buffer.
|
|
*
|
|
* @param sum_buf sample-containing buffer to write to. Must be contiguous.
|
|
* @param mixdown_buffer sample-containing buffer that will be used to mix layers
|
|
* @param gain_buffer ptr to a buffer used to hold any necessary gain (automation) data
|
|
* @param start Session sample to start reading from; updated to where we end up
|
|
* after the read. Global timeline position.
|
|
* @param cnt Count of samples to read.
|
|
* @param rci ptr to ReaderChannelInfo for the channel we're reading
|
|
* @param channel the number of the channel we're reading (0..N)
|
|
* @param reversed true if we are running backwards, otherwise false.
|
|
*/
|
|
|
|
samplecnt_t
|
|
DiskReader::audio_read (Sample* sum_buffer,
|
|
Sample* mixdown_buffer,
|
|
float* gain_buffer,
|
|
samplepos_t& start,
|
|
samplecnt_t cnt,
|
|
ReaderChannelInfo* rci,
|
|
int channel,
|
|
bool reversed)
|
|
{
|
|
samplecnt_t this_read = 0;
|
|
bool reloop = false;
|
|
samplepos_t loop_end = 0;
|
|
samplepos_t loop_start = 0;
|
|
Location* loc = 0;
|
|
const samplecnt_t rcnt = cnt;
|
|
|
|
/* XXX we don't currently play loops in reverse. not sure why */
|
|
|
|
if (!reversed) {
|
|
/* Make the use of a Location atomic for this read operation.
|
|
|
|
Note: Locations don't get deleted, so all we care about
|
|
when I say "atomic" is that we are always pointing to
|
|
the same one and using a start/length values obtained
|
|
just once.
|
|
*/
|
|
|
|
if ((loc = _loop_location) != 0) {
|
|
loop_start = loc->start_sample ();
|
|
loop_end = loc->end_sample ();
|
|
|
|
const Temporal::Range loop_range (loc->start (), loc->end ());
|
|
start = loop_range.squish (timepos_t (start)).samples ();
|
|
}
|
|
|
|
} else {
|
|
start -= cnt;
|
|
start = max (samplepos_t (0), start);
|
|
}
|
|
|
|
/* We need this while loop in case we hit a loop boundary, in which case our read from
|
|
* the playlist must be split into more than one section. */
|
|
|
|
while (cnt) {
|
|
/* take any loop into account. we can't read past the end of the loop. */
|
|
|
|
if (loc && (loop_end - start < cnt)) {
|
|
this_read = loop_end - start;
|
|
reloop = true;
|
|
} else {
|
|
reloop = false;
|
|
this_read = cnt;
|
|
}
|
|
|
|
if (this_read == 0) {
|
|
break;
|
|
}
|
|
|
|
this_read = min (cnt, this_read);
|
|
|
|
/* note that the mixdown and gain buffers are purely for the
|
|
* internal use of the playlist, and cannot be considered
|
|
* useful after the return from AudioPlayback::read()
|
|
*/
|
|
|
|
if (audio_playlist ()->read (sum_buffer, mixdown_buffer, gain_buffer, timepos_t (start), timecnt_t::from_samples (this_read), channel) != this_read) {
|
|
error << string_compose (_("DiskReader %1: cannot read %2 from playlist at sample %3"), id (), this_read, start) << endmsg;
|
|
return 0;
|
|
}
|
|
|
|
if (loc) {
|
|
/* Looping: do something (maybe) about the loop boundaries */
|
|
|
|
switch (Config->get_loop_fade_choice ()) {
|
|
case NoLoopFade:
|
|
break;
|
|
case BothLoopFade:
|
|
loop_declick_in.run (sum_buffer, start, start + this_read);
|
|
loop_declick_out.run (sum_buffer, start, start + this_read);
|
|
break;
|
|
case EndLoopFade:
|
|
loop_declick_out.run (sum_buffer, start, start + this_read);
|
|
break;
|
|
case XFadeLoop:
|
|
if (last_refill_loop_start != loop_start || rci->pre_loop_buffer == 0) {
|
|
setup_preloop_buffer ();
|
|
last_refill_loop_start = loop_start;
|
|
}
|
|
maybe_xfade_loop (sum_buffer, start, start + this_read, rci);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (reversed) {
|
|
swap_by_ptr (sum_buffer, sum_buffer + this_read - 1);
|
|
|
|
} else {
|
|
/* if we read to the end of the loop, go back to the beginning */
|
|
|
|
if (reloop) {
|
|
start = loop_start;
|
|
} else {
|
|
start += this_read;
|
|
}
|
|
}
|
|
|
|
cnt -= this_read;
|
|
sum_buffer += this_read;
|
|
}
|
|
|
|
_last_read_reversed = reversed;
|
|
_last_read_loop = (bool)loc;
|
|
|
|
return rcnt;
|
|
}
|
|
|
|
int
|
|
DiskReader::do_refill ()
|
|
{
|
|
const bool reversed = !_session.transport_will_roll_forwards ();
|
|
return refill (_sum_buffer, _mixdown_buffer, _gain_buffer, 0, reversed);
|
|
}
|
|
|
|
int
|
|
DiskReader::do_refill_with_alloc (bool partial_fill, bool reversed)
|
|
{
|
|
/* We limit disk reads to at most 4MB chunks, which with floating point
|
|
* samples would be 1M samples. But we might use 16 or 14 bit samples,
|
|
* in which case 4MB is more samples than that. Therefore size this for
|
|
* the smallest sample value .. 4MB = 2M samples (16 bit).
|
|
*/
|
|
|
|
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]);
|
|
|
|
return refill_audio (sum_buf.get (), mix_buf.get (), gain_buf.get (), (partial_fill ? _chunk_samples : 0), reversed);
|
|
}
|
|
|
|
int
|
|
DiskReader::refill (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level, bool reversed)
|
|
{
|
|
/* NOTE: Audio refill MUST come first so that in contexts where ONLY it
|
|
* is called, _last_read_reversed is set correctly.
|
|
*/
|
|
|
|
if (refill_audio (sum_buffer, mixdown_buffer, gain_buffer, fill_level, reversed)) {
|
|
return -1;
|
|
}
|
|
|
|
if (rt_midibuffer () && (reversed != rt_midibuffer ()->reversed ())) {
|
|
rt_midibuffer ()->reverse ();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** Get some more data from disk and put it in our channels' bufs,
|
|
* if there is suitable space in them.
|
|
*
|
|
* If fill_level is non-zero, then we will refill the buffer so that there is
|
|
* still at least fill_level samples of space left to be filled. This is used
|
|
* after locates so that we do not need to wait to fill the entire buffer.
|
|
*
|
|
*/
|
|
|
|
int
|
|
DiskReader::refill_audio (Sample* sum_buffer, Sample* mixdown_buffer, float* gain_buffer, samplecnt_t fill_level, bool reversed)
|
|
{
|
|
/* do not read from disk while session is marked as Loading, to avoid
|
|
useless redundant I/O.
|
|
*/
|
|
|
|
if (_session.loading ()) {
|
|
return 0;
|
|
}
|
|
|
|
int32_t ret = 0;
|
|
samplecnt_t zero_fill;
|
|
uint32_t chan_n;
|
|
ChannelList::const_iterator i;
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
_last_read_reversed = reversed;
|
|
|
|
if (c->empty ()) {
|
|
return 0;
|
|
}
|
|
|
|
assert (mixdown_buffer);
|
|
assert (gain_buffer);
|
|
|
|
samplecnt_t total_space = c->front ()->rbuf->write_space ();
|
|
|
|
if (total_space == 0) {
|
|
DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name ()));
|
|
/* nowhere to write to */
|
|
return 0;
|
|
}
|
|
|
|
if (fill_level) {
|
|
if (fill_level < total_space) {
|
|
total_space -= fill_level;
|
|
} else {
|
|
/* we can't do anything with it */
|
|
fill_level = 0;
|
|
}
|
|
}
|
|
|
|
/* if we're running close to normal speed and there isn't enough
|
|
* 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_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_samples, _session.transport_speed ()));
|
|
if ((total_space < _chunk_samples) && fabs (_session.transport_speed ()) < 2.0f) {
|
|
return 0;
|
|
}
|
|
|
|
/* when slaved, don't try to get too close to the read pointer. this
|
|
* leaves space for the buffer reversal to have something useful to
|
|
* work with.
|
|
*/
|
|
|
|
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;
|
|
}
|
|
|
|
samplepos_t fsa = file_sample[DataType::AUDIO];
|
|
|
|
if (reversed) {
|
|
if (fsa == 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->rbuf->write_zero (chan->rbuf->write_space ());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (fsa < total_space) {
|
|
/* too close to the start: read what we can, and then zero fill the rest */
|
|
zero_fill = total_space - fsa;
|
|
total_space = fsa;
|
|
} else {
|
|
zero_fill = 0;
|
|
}
|
|
|
|
} else {
|
|
if (fsa == 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->rbuf->write_zero (chan->rbuf->write_space ());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (fsa > max_samplepos - total_space) {
|
|
/* to close to the end: read what we can, and zero fill the rest */
|
|
zero_fill = total_space - (max_samplepos - fsa);
|
|
total_space = max_samplepos - fsa;
|
|
|
|
} else {
|
|
zero_fill = 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 */
|
|
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 */
|
|
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));
|
|
|
|
samplepos_t file_sample_tmp = fsa;
|
|
|
|
#if 0
|
|
int64_t before = g_get_monotonic_time ();
|
|
int64_t elapsed;
|
|
#endif
|
|
|
|
for (chan_n = 0, i = c->begin (); i != c->end (); ++i, ++chan_n) {
|
|
ChannelInfo* chan (*i);
|
|
|
|
/* we want all channels to read from the same position, but
|
|
* audio_read() will increment its position argument. So
|
|
* reinitialize this for every channel.
|
|
*/
|
|
|
|
file_sample_tmp = fsa;
|
|
samplecnt_t ts = total_space;
|
|
|
|
const guint wr_space = chan->rbuf->write_space ();
|
|
|
|
samplecnt_t to_read = min (ts, (samplecnt_t)wr_space);
|
|
to_read = min (to_read, samples_to_read);
|
|
assert (to_read >= 0);
|
|
|
|
if (to_read) {
|
|
ReaderChannelInfo* rci = dynamic_cast<ReaderChannelInfo*> (chan);
|
|
|
|
if (!_playlists[DataType::AUDIO]) {
|
|
chan->rbuf->write_zero (to_read);
|
|
|
|
} else {
|
|
samplecnt_t nread, nwritten;
|
|
if ((nread = audio_read (sum_buffer, mixdown_buffer, gain_buffer, file_sample_tmp, to_read, rci, chan_n, reversed)) != to_read) {
|
|
error << string_compose (_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3 (rv: %4)"), name (), to_read, fsa, nread) << endmsg;
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
if ((nwritten = chan->rbuf->write (sum_buffer, nread)) != nread) {
|
|
error << string_compose (_("DiskReader %1: when refilling, cannot write %2 into buffer (wrote %3, space %4)"), name (), nread, nwritten, wr_space) << endmsg;
|
|
ret = -1;
|
|
}
|
|
}
|
|
if (!rci->initialized) {
|
|
DEBUG_TRACE (DEBUG::DiskIO, string_compose (" -- Init ReaderChannel '%1' read: %2 samples, at: %4, avail: %5\n", name (), to_read, file_sample_tmp, rci->rbuf->read_space ()));
|
|
rci->initialized = true;
|
|
}
|
|
}
|
|
|
|
if (zero_fill) {
|
|
/* not sure if action is needed,
|
|
* we'll later hit the "to close to the end" case
|
|
*/
|
|
//chan->rbuf->write_zero (zero_fill);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
elapsed = g_get_monotonic_time () - before;
|
|
cerr << '\t' << name() << ": bandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n";
|
|
#endif
|
|
|
|
file_sample[DataType::AUDIO] = file_sample_tmp;
|
|
assert (file_sample[DataType::AUDIO] >= 0);
|
|
|
|
ret = ((total_space - samples_to_read) > _chunk_samples);
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
DiskReader::playlist_ranges_moved (list<Temporal::RangeMove> const& movements, 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.
|
|
*
|
|
* Likewise when shifting regions (insert/remove time)
|
|
* automation is taken care of separately (busses with
|
|
* automation have no disk-reader).
|
|
*/
|
|
|
|
if (from_undo_or_shift) {
|
|
return;
|
|
}
|
|
|
|
if (Config->get_automation_follows_regions () == false) {
|
|
return;
|
|
}
|
|
|
|
/* move panner automation */
|
|
std::shared_ptr<Pannable> pannable = _track.pannable ();
|
|
Evoral::ControlSet::Controls& c (pannable->controls ());
|
|
|
|
for (Evoral::ControlSet::Controls::iterator ci = c.begin (); ci != c.end (); ++ci) {
|
|
std::shared_ptr<AutomationControl> ac = std::dynamic_pointer_cast<AutomationControl> (ci->second);
|
|
if (!ac) {
|
|
continue;
|
|
}
|
|
std::shared_ptr<AutomationList> alist = ac->alist ();
|
|
if (!alist->size ()) {
|
|
continue;
|
|
}
|
|
XMLNode& before = alist->get_state ();
|
|
bool const things_moved = alist->move_ranges (movements);
|
|
if (things_moved) {
|
|
_session.add_command (new MementoCommand<AutomationList> (
|
|
*alist.get (), &before, &alist->get_state ()));
|
|
}
|
|
}
|
|
/* move processor automation */
|
|
_track.foreach_processor (boost::bind (&DiskReader::move_processor_automation, this, _1, movements));
|
|
}
|
|
|
|
void
|
|
DiskReader::move_processor_automation (std::weak_ptr<Processor> p, list<Temporal::RangeMove> const& movements)
|
|
{
|
|
std::shared_ptr<Processor> processor (p.lock ());
|
|
if (!processor) {
|
|
return;
|
|
}
|
|
|
|
set<Evoral::Parameter> const a = processor->what_can_be_automated ();
|
|
|
|
for (set<Evoral::Parameter>::const_iterator i = a.begin (); i != a.end (); ++i) {
|
|
std::shared_ptr<AutomationList> al = processor->automation_control (*i)->alist ();
|
|
if (!al->size ()) {
|
|
continue;
|
|
}
|
|
XMLNode& before = al->get_state ();
|
|
bool const things_moved = al->move_ranges (movements);
|
|
if (things_moved) {
|
|
_session.add_command (
|
|
new MementoCommand<AutomationList> (
|
|
*al.get (), &before, &al->get_state ()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::reset_tracker ()
|
|
{
|
|
_tracker.reset ();
|
|
}
|
|
|
|
void
|
|
DiskReader::resolve_tracker (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time)
|
|
{
|
|
_tracker.resolve_notes (buffer, time);
|
|
}
|
|
|
|
/** Writes playback events from playback_sample for nframes to dst, translating time stamps
|
|
* so that an event at playback_sample has time = 0
|
|
*/
|
|
void
|
|
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)
|
|
{
|
|
RTMidiBuffer* rtmb = rt_midibuffer ();
|
|
|
|
if (!rtmb || (rtmb->size () == 0)) {
|
|
/* no data to read, so do nothing */
|
|
return;
|
|
}
|
|
|
|
MidiBuffer* target;
|
|
|
|
if (ms & MonitoringInput) {
|
|
/* data from disk needs to be *merged* not written into the
|
|
* dst, because it may contain input data that we want to
|
|
* monitor. Since RTMidiBuffer currently (Oct 2019) has no
|
|
* suitable method, put the disk data into a scratch buffer and
|
|
* then merge later.
|
|
*/
|
|
|
|
target = &scratch_bufs.get_midi (0);
|
|
} else {
|
|
/* No need to preserve the contents of the input buffer. But
|
|
* Route::process_output_buffers() clears the buffer as-needed
|
|
* so know we do not need to clear it.
|
|
*/
|
|
target = &dst;
|
|
}
|
|
|
|
if (_no_disk_output.load ()) {
|
|
return;
|
|
}
|
|
|
|
const samplecnt_t nframes = abs (end_sample - start_sample);
|
|
|
|
if (ms & MonitoringDisk) {
|
|
/* disk data needed */
|
|
|
|
Location* loc = _loop_location;
|
|
|
|
if (loc) {
|
|
/* squish() operates in the location's time-domain. When the location was created
|
|
* using music-time, and later converted to audio-time, it can happen that the
|
|
* corresponding super-clock is "between samples". e.g loop-end is at sample 1000.12.
|
|
* if start_sample = 1000; squish() does nothing because 1000 < 1000.12.
|
|
* This is solved by creating the range using (rounded) sample-times.
|
|
*/
|
|
const Temporal::Range loop_range (loc->start ().samples (), loc->end ().samples ());
|
|
samplepos_t effective_start = start_sample;
|
|
samplecnt_t cnt = nframes;
|
|
sampleoffset_t offset = 0;
|
|
const samplepos_t loop_end = loc->end_sample ();
|
|
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("LOOP read, loop is %1..%2 range is %3..%4 nf %5\n", loc->start (), loc->end (), start_sample, end_sample, nframes));
|
|
|
|
do {
|
|
samplepos_t effective_end;
|
|
|
|
effective_start = loop_range.squish (timepos_t (effective_start)).samples ();
|
|
effective_end = min (effective_start + cnt, loop_end);
|
|
assert (effective_end > effective_start);
|
|
|
|
|
|
if (_midi_catchup && _need_midi_catchup) {
|
|
MidiStateTracker mst;
|
|
rtmb->track (mst, effective_start, effective_end);
|
|
mst.flush (dst, 0, false);
|
|
_need_midi_catchup = false;
|
|
}
|
|
|
|
const samplecnt_t this_read = effective_end - effective_start;
|
|
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("playback buffer LOOP read, from %1 to %2 (%3)\n", effective_start, effective_end, this_read));
|
|
|
|
#ifndef NDEBUG
|
|
size_t events_read =
|
|
#endif
|
|
rtmb->read (*target, effective_start, effective_end, _tracker, offset);
|
|
|
|
cnt -= this_read;
|
|
effective_start += this_read;
|
|
offset += this_read;
|
|
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("%1 MDS events LOOP read %2 cnt now %3\n", _name, events_read, cnt));
|
|
|
|
if (cnt) {
|
|
/* We re going to have to read across the loop end. Resolve any notes the extend across the loop end.
|
|
* Time is relative to start_sample.
|
|
*/
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("read crosses loop end, resolve @ %1\n", effective_end - start_sample));
|
|
_tracker.resolve_notes (*target, effective_end - start_sample);
|
|
}
|
|
|
|
} while (cnt);
|
|
|
|
} else {
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("playback buffer read, from %1 to %2 (%3)\n", start_sample, end_sample, nframes));
|
|
if (_midi_catchup && _need_midi_catchup) {
|
|
MidiStateTracker mst;
|
|
rtmb->track (mst, start_sample, end_sample);
|
|
mst.flush (dst, 0, false);
|
|
_need_midi_catchup = false;
|
|
}
|
|
DEBUG_RESULT (size_t, events_read, rtmb->read (*target, start_sample, end_sample, _tracker));
|
|
DEBUG_TRACE (DEBUG::MidiDiskIO, string_compose ("%1 MDS events read %2 range %3 .. %4\n", _name, events_read, playback_sample, playback_sample + nframes));
|
|
}
|
|
}
|
|
|
|
if (ms & MonitoringInput) {
|
|
/* merges data from disk (in "target", which is a scratch
|
|
* buffer in this case) into the actual destination buffer
|
|
* (which holds existing input data).
|
|
*/
|
|
dst.merge_from (*target, nframes);
|
|
}
|
|
|
|
#if 0
|
|
if (!target->empty ()) {
|
|
cerr << "======== MIDI OUT ========\n";
|
|
for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
|
|
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";
|
|
}
|
|
#endif
|
|
}
|
|
void
|
|
DiskReader::inc_no_disk_output ()
|
|
{
|
|
_no_disk_output.fetch_add (1);
|
|
}
|
|
|
|
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 = _no_disk_output.load ();
|
|
if (v > 0) {
|
|
if (_no_disk_output.compare_exchange_strong (v, v - 1)) {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
/* min gain difference for de-click and loop-fadess
|
|
* (-60dB difference to target)
|
|
*/
|
|
#define GAIN_COEFF_DELTA (1e-5)
|
|
|
|
DiskReader::DeclickAmp::DeclickAmp (samplecnt_t sample_rate)
|
|
{
|
|
_a = 800.f / (gain_t)sample_rate; // ~ 1/50Hz to fade by 40dB
|
|
_l = -log1p (_a);
|
|
_g = 0;
|
|
}
|
|
|
|
void
|
|
DiskReader::DeclickAmp::apply_gain (AudioBuffer& buf, samplecnt_t n_samples, const float target, sampleoffset_t buffer_offset)
|
|
{
|
|
if (n_samples == 0) {
|
|
return;
|
|
}
|
|
float g = _g;
|
|
|
|
if (g == target) {
|
|
assert (buffer_offset == 0);
|
|
Amp::apply_simple_gain (buf, n_samples, target, 0);
|
|
return;
|
|
}
|
|
|
|
const float a = _a;
|
|
Sample* const buffer = buf.data ();
|
|
|
|
const int max_nproc = 4;
|
|
uint32_t remain = n_samples;
|
|
uint32_t offset = buffer_offset;
|
|
|
|
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) {
|
|
_g = target;
|
|
} else {
|
|
_g = g;
|
|
}
|
|
}
|
|
|
|
DiskReader::Declicker::Declicker ()
|
|
: fade_start (0)
|
|
, fade_end (0)
|
|
, fade_length (0)
|
|
, vec (0)
|
|
{
|
|
}
|
|
|
|
DiskReader::Declicker::~Declicker ()
|
|
{
|
|
delete[] vec;
|
|
}
|
|
|
|
void
|
|
DiskReader::Declicker::alloc (samplecnt_t sr, bool fadein, bool linear)
|
|
{
|
|
delete[] vec;
|
|
vec = new Sample[loop_fade_length];
|
|
|
|
if (linear) {
|
|
if (fadein) {
|
|
for (samplecnt_t n = 0; n < loop_fade_length; ++n) {
|
|
vec[n] = n / (float)loop_fade_length;
|
|
}
|
|
} else {
|
|
for (samplecnt_t n = 0; n < loop_fade_length; ++n) {
|
|
vec[n] = 1.f - n / (float)loop_fade_length;
|
|
}
|
|
}
|
|
fade_length = loop_fade_length - 1;
|
|
return;
|
|
}
|
|
|
|
/* Exponential fade */
|
|
|
|
const float a = 390.f / sr; // ~ 1/100Hz for 40dB
|
|
|
|
/* build a psuedo-exponential (linear-volume) shape for the fade */
|
|
|
|
samplecnt_t n;
|
|
|
|
if (fadein) {
|
|
gain_t g = 0.0;
|
|
for (n = 0; (n < loop_fade_length) && ((1.f - g) > GAIN_COEFF_DELTA); ++n) {
|
|
vec[n] = g;
|
|
g += a * (1.0 - g);
|
|
}
|
|
} else {
|
|
gain_t g = 1.0;
|
|
for (n = 0; (n < loop_fade_length) && (g > GAIN_COEFF_DELTA); ++n) {
|
|
vec[n] = g;
|
|
g += a * -g;
|
|
}
|
|
}
|
|
|
|
assert (n > 0 && n <= loop_fade_length);
|
|
|
|
fade_length = n - 1;
|
|
|
|
/* Fill remaining fader-buffer with the target value.
|
|
*
|
|
* This is needed for loop x-fade. Due to float precision near 1.0, fade-in length
|
|
* is can be one or two samples shorter than fade-out length (depending on sample-rate).
|
|
* Summing the fade-in and fade-out curve over the complete fade-range (fade-out,
|
|
* as done by DiskReader::maybe_xfade_loop) must yield 1.0 +/- GAIN_COEFF_DELTA.
|
|
*/
|
|
for (; n < loop_fade_length; ++n) {
|
|
vec[n] = fadein ? 1.f : 0.f;
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::Declicker::reset (samplepos_t loop_start, samplepos_t loop_end, bool fadein, samplecnt_t sr)
|
|
{
|
|
if (loop_start == loop_end) {
|
|
fade_start = 0;
|
|
fade_end = 0;
|
|
return;
|
|
}
|
|
|
|
/* adjust the position of the fade (this is absolute (global) timeline units) */
|
|
|
|
if (fadein) {
|
|
fade_start = loop_start;
|
|
fade_end = loop_start + fade_length;
|
|
} else {
|
|
fade_start = loop_end - fade_length;
|
|
fade_end = loop_end;
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::Declicker::run (Sample* buf, samplepos_t read_start, samplepos_t read_end)
|
|
{
|
|
samplecnt_t n = 0; /* how many samples to process */
|
|
sampleoffset_t bo = 0; /* offset into buffer */
|
|
sampleoffset_t vo = 0; /* offset into gain vector */
|
|
|
|
if (fade_start == fade_end) {
|
|
return;
|
|
}
|
|
|
|
/* Determine how the read range overlaps with the fade range, so we can determine
|
|
* which part of the fade gain vector to apply to which part of the buffer.
|
|
*
|
|
* see also DiskReader::maybe_xfade_loop()
|
|
*/
|
|
|
|
switch (Temporal::coverage_exclusive_ends (fade_start, fade_end, read_start, read_end)) {
|
|
case Temporal::OverlapInternal:
|
|
/* note: start and end points cannot coincide (see evoral/Range.h)
|
|
*
|
|
* read range is entirely within fade range
|
|
*/
|
|
bo = 0;
|
|
vo = read_start - fade_start;
|
|
n = read_end - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapExternal:
|
|
/* read range extends on either side of fade range
|
|
*
|
|
* External allows coincidental start & end points, so check for that
|
|
*/
|
|
if (fade_start == read_start && fade_end == read_end) {
|
|
/* fade entire read ... this is SO unlikely ! */
|
|
bo = 0;
|
|
vo = 0;
|
|
n = fade_end - fade_start;
|
|
} else {
|
|
bo = fade_start - read_start;
|
|
vo = 0;
|
|
n = fade_end - fade_start;
|
|
}
|
|
break;
|
|
|
|
case Temporal::OverlapStart:
|
|
/* read range starts before and ends within fade or at same end as fade */
|
|
n = fade_end - read_start;
|
|
vo = 0;
|
|
bo = fade_start - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapEnd:
|
|
/* read range starts within fade range, but possibly at it's end, so check */
|
|
if (read_start == fade_end) {
|
|
/* nothing to do */
|
|
return;
|
|
}
|
|
bo = 0;
|
|
vo = read_start - fade_start;
|
|
n = fade_end - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapNone:
|
|
/* no overlap ... nothing to do */
|
|
return;
|
|
}
|
|
|
|
Sample* b = &buf[bo];
|
|
gain_t* g = &vec[vo];
|
|
|
|
for (sampleoffset_t i = 0; i < n; ++i) {
|
|
b[i] *= g[i];
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::maybe_xfade_loop (Sample* buf, samplepos_t read_start, samplepos_t read_end, ReaderChannelInfo* chan)
|
|
{
|
|
samplecnt_t n = 0; /* how many samples to process */
|
|
sampleoffset_t bo = 0; /* offset into buffer */
|
|
sampleoffset_t vo = 0; /* offset into gain vector */
|
|
|
|
const samplepos_t fade_start = loop_declick_out.fade_start;
|
|
const samplepos_t fade_end = loop_declick_out.fade_end;
|
|
|
|
if (fade_start == fade_end) {
|
|
return;
|
|
}
|
|
|
|
/* Determine how the read range overlaps with the fade range, so we can determine
|
|
* which part of the fade gain vector to apply to which part of the buffer.
|
|
*
|
|
* see also DiskReader::Declicker::run()
|
|
*/
|
|
|
|
switch (Temporal::coverage_exclusive_ends (fade_start, fade_end, read_start, read_end)) {
|
|
case Temporal::OverlapInternal:
|
|
/* note: start and end points cannot coincide (see evoral/Range.h)
|
|
*
|
|
* read range is entirely within fade range
|
|
*/
|
|
bo = 0;
|
|
vo = read_start - fade_start;
|
|
n = read_end - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapExternal:
|
|
/* read range extends on either side of fade range
|
|
*
|
|
* External allows coincidental start & end points, so check for that
|
|
*/
|
|
if (fade_start == read_start && fade_end == read_end) {
|
|
/* fade entire read ... this is SO unlikely ! */
|
|
bo = 0;
|
|
vo = 0;
|
|
n = fade_end - fade_start;
|
|
} else {
|
|
bo = fade_start - read_start;
|
|
vo = 0;
|
|
n = fade_end - fade_start;
|
|
}
|
|
break;
|
|
|
|
case Temporal::OverlapStart:
|
|
/* read range starts before and ends within fade or at same end as fade */
|
|
n = read_end - fade_start;
|
|
vo = 0;
|
|
bo = fade_start - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapEnd:
|
|
/* read range starts within fade range, but possibly at it's end, so check */
|
|
if (read_start == fade_end) {
|
|
/* nothing to do */
|
|
return;
|
|
}
|
|
bo = 0;
|
|
vo = read_start - fade_start;
|
|
n = fade_end - read_start;
|
|
break;
|
|
|
|
case Temporal::OverlapNone:
|
|
/* no overlap ... nothing to do */
|
|
return;
|
|
}
|
|
|
|
Sample* b = &buf[bo]; /* data to be faded out */
|
|
Sample* sbuf = &chan->pre_loop_buffer[vo]; /* pre-loop (maybe silence) to be faded in */
|
|
gain_t* og = &loop_declick_out.vec[vo]; /* fade out gain vector */
|
|
gain_t* ig = &loop_declick_in.vec[vo]; /* fade in gain vector */
|
|
|
|
for (sampleoffset_t i = 0; i < n; ++i) {
|
|
b[i] = (b[i] * og[i]) + (sbuf[i] * ig[i]);
|
|
}
|
|
}
|
|
|
|
RTMidiBuffer*
|
|
DiskReader::rt_midibuffer ()
|
|
{
|
|
std::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
|
|
|
|
if (!pl) {
|
|
return 0;
|
|
}
|
|
|
|
std::shared_ptr<MidiPlaylist> mpl = std::dynamic_pointer_cast<MidiPlaylist> (pl);
|
|
|
|
if (!mpl) {
|
|
/* error, but whatever ... */
|
|
return 0;
|
|
}
|
|
|
|
return mpl->rendered ();
|
|
}
|
|
|
|
void
|
|
DiskReader::alloc_loop_declick (samplecnt_t sr)
|
|
{
|
|
loop_fade_length = lrintf (ceil (-log (GAIN_COEFF_DELTA / 2.) / (390. / sr)));
|
|
loop_declick_in.alloc (sr, true, Config->get_loop_fade_choice () == XFadeLoop);
|
|
loop_declick_out.alloc (sr, false, Config->get_loop_fade_choice () == XFadeLoop);
|
|
}
|
|
|
|
#undef GAIN_COEFF_DELTA
|
|
|
|
void
|
|
DiskReader::reset_loop_declick (Location* loc, samplecnt_t sr)
|
|
{
|
|
if (loc) {
|
|
loop_declick_in.reset (loc->start_sample (), loc->end_sample (), true, sr);
|
|
loop_declick_out.reset (loc->start_sample (), loc->end_sample (), false, sr);
|
|
} else {
|
|
loop_declick_in.reset (0, 0, true, sr);
|
|
loop_declick_out.reset (0, 0, false, sr);
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::set_loop (Location* loc)
|
|
{
|
|
Processor::set_loop (loc);
|
|
|
|
if (!loc) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::setup_preloop_buffer ()
|
|
{
|
|
if (!_loop_location) {
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<ChannelList const> c = channels.reader ();
|
|
|
|
if (c->empty () || !_playlists[DataType::AUDIO]) {
|
|
return;
|
|
}
|
|
|
|
Location* loc = _loop_location;
|
|
boost::scoped_array<Sample> mix_buf (new Sample[loop_fade_length]);
|
|
boost::scoped_array<Sample> gain_buf (new Sample[loop_fade_length]);
|
|
const timepos_t read_start = timepos_t (loc->start_sample () - loop_declick_out.fade_length);
|
|
const timecnt_t read_cnt = timecnt_t (loop_declick_out.fade_length);
|
|
|
|
uint32_t channel = 0;
|
|
|
|
for (auto const& chan : *c) {
|
|
ReaderChannelInfo* rci = dynamic_cast<ReaderChannelInfo*> (chan);
|
|
|
|
rci->resize_preloop (loop_fade_length);
|
|
|
|
if (loc->start () > loop_fade_length) {
|
|
audio_playlist ()->read (rci->pre_loop_buffer, mix_buf.get (), gain_buf.get (), read_start, read_cnt, channel);
|
|
} else {
|
|
memset (rci->pre_loop_buffer, 0, sizeof (Sample) * loop_fade_length);
|
|
}
|
|
++channel;
|
|
}
|
|
}
|
|
|
|
void
|
|
DiskReader::set_need_midi_catchup (bool yn)
|
|
{
|
|
_need_midi_catchup = yn;
|
|
}
|