*/
+#include <boost/smart_ptr/scoped_array.hpp>
+
#include "pbd/enumwriter.h"
#include "pbd/memento_command.h"
, overwrite_offset (0)
, _pending_overwrite (false)
, overwrite_queued (false)
+ , _declick_gain (0)
{
file_sample[DataType::AUDIO] = 0;
file_sample[DataType::MIDI] = 0;
_playlists[n]->release ();
}
}
+ delete _midi_buf;
+}
- {
- 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;
+ /* touch memory to lock it */
+ rbuf = new RingBufferNPT<Sample> (bufsize);
+ 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
}
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;
}
return 1.0;
}
- PBD::RingBufferNPT<Sample> * b = c->front()->buf;
+ PBD::RingBufferNPT<Sample>* b = c->front()->rbuf;
return (float) ((double) b->read_space() / (double) b->bufsize());
}
}
}
- if (c->empty()) {
- /* do nothing */
- return;
- }
-
if ((speed == 0.0) && (ms == MonitoringDisk)) {
/* no channels, or stopped. Don't accidentally pass any data
* from disk into our outputs (e.g. via interpolation)
return;
}
- if (speed != 1.0f && speed != -1.0f) {
- interpolation.set_speed (speed);
- midi_interpolation.set_speed (speed);
- disk_samples_to_consume = midi_interpolation.distance (nframes);
- if (speed < 0.0) {
- disk_samples_to_consume = -disk_samples_to_consume;
- }
- } else {
- disk_samples_to_consume = nframes;
- }
-
BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
const bool still_locating = _session.global_locate_pending();
+ if (c->empty()) {
+ /* do nothing with audio */
+ goto midi;
+ }
+
+ assert (speed == -1 || speed == 0 || speed == 1);
+
+ if (speed < 0) {
+ disk_samples_to_consume = -nframes;
+ } else if (speed > 0) {
+ disk_samples_to_consume = nframes;
+ } else {
+ disk_samples_to_consume = 0;
+ }
+
if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating || _no_disk_output) {
/* no need for actual disk data, just advance read pointer and return */
if (!still_locating || _no_disk_output) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->buf->increment_read_ptr (disk_samples_to_consume);
+ (*chan)->rbuf->increment_read_ptr (disk_samples_to_consume);
}
}
disk_signal = output.data ();
}
- if (start_sample < playback_sample) {
- cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << endl;
- abort ();
+ if (speed > 0) {
+ if (start_sample < playback_sample) {
+ cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << endl;
+ abort ();
+ }
+ } else if (speed < 0) {
+ if (playback_sample < start_sample) {
+ cerr << owner()->name() << " SS = " << start_sample << " PS = " << playback_sample << " REVERSE" << endl;
+ abort ();
+ }
}
- if (start_sample != playback_sample) {
+ if ((speed > 0) && (start_sample != playback_sample)) {
cerr << owner()->name() << " playback not aligned, jump ahead " << (start_sample - playback_sample) << endl;
if (can_internal_playback_seek (start_sample - playback_sample)) {
}
}
- chaninfo->buf->get_read_vector (&(*chan)->rw_vector);
+ chaninfo->rbuf->get_read_vector (&(*chan)->rw_vector);
if (disk_samples_to_consume <= (samplecnt_t) chaninfo->rw_vector.len[0]) {
- if (fabsf (speed) != 1.0f) {
- (void) interpolation.interpolate (
- n, disk_samples_to_consume,
- chaninfo->rw_vector.buf[0],
- disk_signal);
- } else if (speed != 0.0) {
+ if (speed != 0.0) {
memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * disk_samples_to_consume);
}
if (disk_samples_to_consume <= 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, disk_samples_to_consume - chaninfo->rw_vector.len[0],
- chaninfo->rw_vector.buf[1],
- disk_signal);
- } else if (speed != 0.0) {
- memcpy (disk_signal,
+ if (speed != 0.0) {
+ memcpy (disk_signal,
chaninfo->rw_vector.buf[0],
chaninfo->rw_vector.len[0] * sizeof (Sample));
- memcpy (disk_signal + chaninfo->rw_vector.len[0],
+ memcpy (disk_signal + chaninfo->rw_vector.len[0],
chaninfo->rw_vector.buf[1],
(disk_samples_to_consume - chaninfo->rw_vector.len[0]) * sizeof (Sample));
}
apply_gain_to_buffer (disk_signal, disk_samples_to_consume, scaling);
}
- chaninfo->buf->increment_read_ptr (disk_samples_to_consume);
-
- monitor_mix:
+ chaninfo->rbuf->increment_read_ptr (disk_samples_to_consume);
if (ms & MonitoringInput) {
/* mix the disk signal into the input signal (already in bufs) */
/* MIDI data handling */
midi:
- if (!_session.declick_out_pending() && bufs.count().n_midi()) {
+ if (/*!_session.declick_out_pending() && */ bufs.count().n_midi()) {
MidiBuffer* dst;
if (_no_disk_output) {
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()));
+ 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()->buf->write_space() >= _chunk_samples) {
- DEBUG_TRACE (DEBUG::Butler, string_compose ("%1: write space = %2 of %3\n", name(), c->front()->buf->write_space(),
+ 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;
}
boost::shared_ptr<ChannelList> c = channels.reader ();
if (!c->empty ()) {
- overwrite_offset = c->front()->buf->get_read_ptr();
+ overwrite_offset = c->front()->rbuf->get_read_ptr();
}
}
const bool reversed = _session.transport_speed() < 0.0f;
/* assume all are the same size */
- samplecnt_t size = c->front()->buf->bufsize();
+ samplecnt_t size = c->front()->rbuf->bufsize();
- std::auto_ptr<Sample> mixdown_buffer (new Sample[size]);
- std::auto_ptr<float> gain_buffer (new float[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)
samplecnt_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)) {
+ if (audio_read ((*chan)->rbuf->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 sample %3"),
id(), size, playback_sample) << endmsg;
goto midi;
cnt -= to_read;
- if (audio_read ((*chan)->buf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
+ if (audio_read ((*chan)->rbuf->buffer(), mixdown_buffer.get(), gain_buffer.get(), start, cnt, n, reversed)) {
error << string_compose(_("DiskReader %1: when refilling, cannot read %2 from playlist at sample %3"),
id(), size, playback_sample) << endmsg;
goto midi;
//sample = std::max ((samplecnt_t)0, sample -_session.worst_output_latency ());
for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
- (*chan)->buf->reset ();
+ (*chan)->rbuf->reset ();
}
if (g_atomic_int_get (&_samples_read_from_ringbuffer) == 0) {
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->read_space() < (size_t) distance) {
return false;
}
}
boost::shared_ptr<ChannelList> c = channels.reader();
for (chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->buf->increment_read_ptr (::llabs(distance));
+ (*chan)->rbuf->increment_read_ptr (::llabs(distance));
}
playback_sample += distance;
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;
*/
{
- std::auto_ptr<Sample> mix_buf (new Sample[2*1048576]);
- std::auto_ptr<float> gain_buf (new float[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_samples : 0));
vector.buf[1] = 0;
vector.len[1] = 0;
- c->front()->buf->get_write_vector (&vector);
+ c->front()->rbuf->get_write_vector (&vector);
if ((total_space = vector.len[0] + vector.len[1]) == 0) {
DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: no space to refill\n", name()));
work with.
*/
- if (_slaved && total_space < (samplecnt_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;
}
for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
ChannelInfo* chan (*i);
- chan->buf->get_write_vector (&vector);
+ chan->rbuf->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->increment_write_ptr (vector.len[0] + vector.len[1]);
}
return 0;
}
for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
ChannelInfo* chan (*i);
- chan->buf->get_write_vector (&vector);
+ chan->rbuf->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->increment_write_ptr (vector.len[0] + vector.len[1]);
}
return 0;
}
Sample* buf2;
samplecnt_t len1, len2;
- chan->buf->get_write_vector (&vector);
+ chan->rbuf->get_write_vector (&vector);
if ((samplecnt_t) vector.len[0] > samples_to_read) {
ret = -1;
goto out;
}
- chan->buf->increment_write_ptr (to_read);
+ chan->rbuf->increment_write_ptr (to_read);
ts -= to_read;
}
goto out;
}
- chan->buf->increment_write_ptr (to_read);
+ chan->rbuf->increment_write_ptr (to_read);
}
if (zero_fill) {
ret = ((total_space - samples_to_read) > _chunk_samples);
- c->front()->buf->get_write_vector (&vector);
+ c->front()->rbuf->get_write_vector (&vector);
out:
return ret;
if (ms & MonitoringDisk) {
/* disk data needed */
- Location* loc = loop_location;
+ Location* loc = _loop_location;
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
"%1 MDS pre-read read %8 offset = %9 @ %4..%5 from %2 write to %3, LOOPED ? %6 .. %7\n", _name,
samplepos_t loop_end = 0;
samplepos_t loop_start = 0;
samplecnt_t loop_length = 0;
- Location* loc = loop_location;
+ Location* loc = _loop_location;
samplepos_t effective_start = start;
Evoral::Range<samplepos_t>* loop_range (0);
projects / ardour.git / blobdiff