/*
- Copyright (C) 2000-2006 Paul Davis
+ Copyright (C) 2000-2006 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
#include <sys/stat.h>
#include <sys/mman.h>
-#include <pbd/error.h>
+#include "pbd/error.h"
#include <glibmm/thread.h>
-#include <pbd/xml++.h>
-#include <pbd/memento_command.h>
-#include <pbd/enumwriter.h>
-#include <pbd/stacktrace.h>
-
-#include <ardour/ardour.h>
-#include <ardour/audioengine.h>
-#include <ardour/analyser.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/utils.h>
-#include <ardour/configuration.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/send.h>
-#include <ardour/region_factory.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/playlist_factory.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/audioregion.h>
-#include <ardour/audio_port.h>
-#include <ardour/source_factory.h>
-#include <ardour/audio_buffer.h>
+#include "pbd/xml++.h"
+#include "pbd/memento_command.h"
+#include "pbd/enumwriter.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/analyser.h"
+#include "ardour/ardour.h"
+#include "ardour/audio_buffer.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/audio_port.h"
+#include "ardour/audioengine.h"
+#include "ardour/audiofilesource.h"
+
+#include "ardour/audioplaylist.h"
+#include "ardour/audioregion.h"
+#include "ardour/butler.h"
+#include "ardour/configuration.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/debug.h"
+#include "ardour/io.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/region_factory.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/source_factory.h"
+#include "ardour/utils.h"
+#include "ardour/session_playlists.h"
#include "i18n.h"
#include <locale.h>
in_set_state = false;
}
-
+
AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
: Diskstream(sess, node)
, deprecated_io_node(NULL)
in_set_state = true;
init (Recordable);
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
in_set_state = false;
throw failed_constructor();
}
AudioDiskstream::~AudioDiskstream ()
{
- notify_callbacks ();
+ DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
{
RCUWriter<ChannelList> writer (channels);
boost::shared_ptr<ChannelList> c = writer.get_copy();
-
+
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
delete *chan;
}
{
RCUWriter<ChannelList> writer (channels);
boost::shared_ptr<ChannelList> c = writer.get_copy();
-
+
_n_channels.set(DataType::AUDIO, c->size());
-
- if (_io->n_inputs().n_audio() > _n_channels.n_audio()) {
- add_channel_to (c, _io->n_inputs().n_audio() - _n_channels.n_audio());
- } else if (_io->n_inputs().n_audio() < _n_channels.n_audio()) {
- remove_channel_from (c, _n_channels.n_audio() - _io->n_inputs().n_audio());
+
+ if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
+ add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
+ } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
+ remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
}
}
-
+
get_input_sources ();
set_capture_offset ();
-
+
if (first_input_change) {
set_align_style (_persistent_alignment_style);
first_input_change = false;
} else {
set_align_style_from_io ();
}
-
+
input_change_pending = NoChange;
/* implicit unlock */
}
-
+
/* reset capture files */
reset_write_sources (false);
uint32_t n;
ChannelList::iterator chan;
- uint32_t ni = _io->n_inputs().n_audio();
+ uint32_t ni = _io->n_ports().n_audio();
vector<string> connections;
for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
-
+
connections.clear ();
- if (_io->input(n)->get_connections (connections) == 0) {
-
+ if (_io->nth (n)->get_connections (connections) == 0) {
+
if ((*chan)->source) {
// _source->disable_metering ();
}
-
+
(*chan)->source = 0;
-
+
} else {
(*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
}
}
-}
+}
int
AudioDiskstream::find_and_use_playlist (const string& name)
{
boost::shared_ptr<AudioPlaylist> playlist;
-
- if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
+
+ if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
}
{
string newname;
boost::shared_ptr<AudioPlaylist> playlist;
-
+
if (!in_set_state && destructive()) {
return 0;
}
}
if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
-
+
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
- } else {
+ } else {
return -1;
}
}
boost::shared_ptr<AudioPlaylist> playlist;
newname = Playlist::bump_name (_playlist->name(), _session);
-
+
if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
- } else {
+ } else {
return -1;
}
}
{
SourceList srcs;
boost::shared_ptr<ChannelList> c = channels.reader();
-
+
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
srcs.push_back ((*chan)->write_source);
}
/* a single full-sized region */
boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
- _playlist->add_region (region, srcs.front()->natural_position());
+ _playlist->add_region (region, srcs.front()->natural_position());
}
void
{
/* this is called from the XML-based constructor or ::set_destructive. when called,
we already have a playlist and a region, but we need to
- set up our sources for write. we use the sources associated
+ set up our sources for write. we use the sources associated
with the (presumed single, full-extent) region.
*/
}
void
-AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
{
- int possibly_recording;
- int rolling;
- int change;
- const int transport_rolling = 0x4;
- const int track_rec_enabled = 0x2;
- const int global_rec_enabled = 0x1;
-
- /* merge together the 3 factors that affect record status, and compute
- what has changed.
- */
-
- rolling = _session.transport_speed() != 0.0f;
- possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
- change = possibly_recording ^ last_possibly_recording;
-
- if (possibly_recording == last_possibly_recording) {
- return;
- }
-
- /* change state */
-
- /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
-
- if (((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record)) ||
- ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
-
- /* starting to record: compute first+last frames */
-
- first_recordable_frame = transport_frame + _capture_offset;
- last_recordable_frame = max_frames;
- capture_start_frame = transport_frame;
-
- if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
-
- /* was stopped, now rolling (and recording) */
-
- if (_alignment_style == ExistingMaterial) {
- first_recordable_frame += _session.worst_output_latency();
- } else {
- first_recordable_frame += _roll_delay;
- }
-
- } else {
-
- /* was rolling, but record state changed */
-
- if (_alignment_style == ExistingMaterial) {
-
- if (!Config->get_punch_in()) {
-
- /* manual punch in happens at the correct transport frame
- because the user hit a button. but to get alignment correct
- we have to back up the position of the new region to the
- appropriate spot given the roll delay.
- */
-
- capture_start_frame -= _roll_delay;
-
- /* XXX paul notes (august 2005): i don't know why
- this is needed.
- */
-
- first_recordable_frame += _capture_offset;
-
- } else {
-
- /* autopunch toggles recording at the precise
- transport frame, and then the DS waits
- to start recording for a time that depends
- on the output latency.
- */
-
- first_recordable_frame += _session.worst_output_latency();
- }
+ if (recordable() && destructive()) {
+ boost::shared_ptr<ChannelList> c = channels.reader();
+ for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- } else {
+ RingBufferNPT<CaptureTransition>::rw_vector transvec;
+ (*chan)->capture_transition_buf->get_write_vector(&transvec);
- if (Config->get_punch_in()) {
- first_recordable_frame += _roll_delay;
- } else {
- capture_start_frame -= _roll_delay;
- }
+ if (transvec.len[0] > 0) {
+ transvec.buf[0]->type = CaptureStart;
+ transvec.buf[0]->capture_val = capture_start_frame;
+ (*chan)->capture_transition_buf->increment_write_ptr(1);
+ }
+ else {
+ // bad!
+ fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
+ << endmsg;
}
-
- }
-
- if (recordable() && destructive()) {
- boost::shared_ptr<ChannelList> c = channels.reader();
- for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
- RingBufferNPT<CaptureTransition>::rw_vector transvec;
- (*chan)->capture_transition_buf->get_write_vector(&transvec);
-
- if (transvec.len[0] > 0) {
- transvec.buf[0]->type = CaptureStart;
- transvec.buf[0]->capture_val = capture_start_frame;
- (*chan)->capture_transition_buf->increment_write_ptr(1);
- }
- else {
- // bad!
- fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
- << endmsg;
- }
- }
- }
-
- } else if (!record_enabled() || !can_record) {
-
- /* stop recording */
-
- last_recordable_frame = transport_frame + _capture_offset;
-
- if (_alignment_style == ExistingMaterial) {
- last_recordable_frame += _session.worst_output_latency();
- } else {
- last_recordable_frame += _roll_delay;
}
}
-
- last_possibly_recording = possibly_recording;
}
int
-AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
+AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
{
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
// If we can't take the state lock return.
if (!state_lock.trylock()) {
return 1;
- }
+ }
commit_should_unlock = true;
adjust_capture_position = 0;
(*chan)->current_playback_buffer = 0;
}
- if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
- OverlapType ot;
-
+ if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
// Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
if (last_recordable_frame < first_recordable_frame) {
- last_recordable_frame = max_frames;
+ last_recordable_frame = max_frames;
}
- ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+ OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
- switch (ot) {
- case OverlapNone:
- rec_nframes = 0;
- break;
-
- case OverlapInternal:
- /* ---------- recrange
- |---| transrange
- */
- rec_nframes = nframes;
- rec_offset = 0;
- break;
-
- case OverlapStart:
- /* |--------| recrange
- -----| transrange
- */
- rec_nframes = transport_frame + nframes - first_recordable_frame;
- if (rec_nframes) {
- rec_offset = first_recordable_frame - transport_frame;
- }
- break;
-
- case OverlapEnd:
- /* |--------| recrange
- |-------- transrange
- */
- rec_nframes = last_recordable_frame - transport_frame;
- rec_offset = 0;
- break;
-
- case OverlapExternal:
- /* |--------| recrange
- -------------- transrange
- */
- rec_nframes = last_recordable_frame - first_recordable_frame;
- rec_offset = first_recordable_frame - transport_frame;
- break;
- }
+ calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
if (rec_nframes && !was_recording) {
capture_captured = 0;
if (nominally_recording || rec_nframes) {
- uint32_t limit = _io->n_inputs ().n_audio();
+ uint32_t limit = _io->n_ports ().n_audio();
/* one or more ports could already have been removed from _io, but our
channel setup hasn't yet been updated. prevent us from trying to
*/
for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
-
+
ChannelInfo* chaninfo (*chan);
chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
if (rec_nframes <= chaninfo->capture_vector.len[0]) {
-
+
chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
- /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
- rec_offset
+ /* note: grab the entire port buffer, but only copy what we were supposed to
+ for recording, and use rec_offset
*/
- AudioPort* const ap = _io->audio_input(n);
+ AudioPort* const ap = _io->audio (n);
assert(ap);
- assert(rec_nframes <= ap->get_audio_buffer( nframes, offset ).capacity());
- memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer( nframes, offset ).data(rec_nframes, offset + rec_offset), sizeof (Sample) * rec_nframes);
+ assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
+ memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (rec_nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
+
} else {
goto out;
}
- AudioPort* const ap = _io->audio_input(n);
+ AudioPort* const ap = _io->audio (n);
assert(ap);
- Sample* buf = ap->get_audio_buffer( nframes, offset ).data(nframes, offset);
+ Sample* buf = ap->get_audio_buffer(nframes).data();
nframes_t first = chaninfo->capture_vector.len[0];
memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
-
+
chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
}
}
}
}
-
+
if (rec_nframes) {
-
+
/* data will be written to disk */
if (rec_nframes == nframes && rec_offset == 0) {
} else {
necessary_samples = nframes;
}
-
+
for (chan = c->begin(); chan != c->end(); ++chan) {
(*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
}
- n = 0;
+ n = 0;
for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
-
+
ChannelInfo* chaninfo (*chan);
if (necessary_samples <= chaninfo->playback_vector.len[0]) {
} else {
nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
-
+
if (necessary_samples > total) {
+ cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
cerr << "underrun for " << _name << endl;
DiskUnderrun ();
goto out;
-
+
} else {
-
- memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
- chaninfo->playback_vector.len[0] * sizeof (Sample));
- memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
- (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
-
+
+ memcpy ((char *) chaninfo->playback_wrap_buffer,
+ chaninfo->playback_vector.buf[0],
+ chaninfo->playback_vector.len[0] * sizeof (Sample));
+ memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
+ chaninfo->playback_vector.buf[1],
+ (necessary_samples - chaninfo->playback_vector.len[0])
+ * sizeof (Sample));
+
chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
}
}
- }
+ }
if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
process_varispeed_playback(nframes, c);
playback_distance = nframes;
}
- phi = target_phi;
+ _speed = _target_speed;
}
/* we're exiting with failure, so ::commit will not
be called. unlock the state lock.
*/
-
+
commit_should_unlock = false;
state_lock.unlock();
- }
+ }
return ret;
}
AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
{
ChannelList::iterator chan;
-
- // the idea behind phase is that when the speed is not 1.0, we have to
- // interpolate between samples and then we have to store where we thought we were.
- // rather than being at sample N or N+1, we were at N+0.8792922
- // so the "phase" element, if you want to think about this way,
- // varies from 0 to 1, representing the "offset" between samples
- uint64_t phase = last_phase;
-
- // acceleration
- int64_t phi_delta;
-
- // index in the input buffers
- nframes_t i = 0;
-
- // Linearly interpolate into the speed buffer
- // using 40.24 fixed point math
- //
- // Fixed point is just an integer with an implied scaling factor.
- // In 40.24 the scaling factor is 2^24 = 16777216,
- // so a value of 10*2^24 (in integer space) is equivalent to 10.0.
- //
- // The advantage is that addition and modulus [like x = (x + y) % 2^40]
- // have no rounding errors and no drift, and just require a single integer add.
- // (swh)
-
- const int64_t fractional_part_mask = 0xFFFFFF;
- const Sample binary_scaling_factor = 16777216.0f;
- // phi = fixed point speed
- if (phi != target_phi) {
- phi_delta = ((int64_t)(target_phi - phi)) / nframes;
- } else {
- phi_delta = 0;
- }
+ interpolation.set_speed (_target_speed);
- for (chan = c->begin(); chan != c->end(); ++chan) {
-
- Sample fractional_phase_part;
+ int channel = 0;
+ for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
ChannelInfo* chaninfo (*chan);
- i = 0;
- phase = last_phase;
+ playback_distance = interpolation.interpolate (
+ channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
- for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
- i = phase >> 24;
- fractional_phase_part = (phase & fractional_part_mask) / binary_scaling_factor;
- chaninfo->speed_buffer[outsample] =
- chaninfo->current_playback_buffer[i] * (1.0f - fractional_phase_part) +
- chaninfo->current_playback_buffer[i+1] * fractional_phase_part;
- phase += phi + phi_delta;
- }
-
chaninfo->current_playback_buffer = chaninfo->speed_buffer;
}
-
- playback_distance = i; // + 1;
- last_phase = (phase & fractional_part_mask);
}
bool
-AudioDiskstream::commit (nframes_t nframes)
+AudioDiskstream::commit (nframes_t /*nframes*/)
{
bool need_butler = false;
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
(*chan)->playback_buf->increment_read_ptr (playback_distance);
-
+
if (adjust_capture_position) {
(*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
}
}
-
+
if (adjust_capture_position != 0) {
capture_captured += adjust_capture_position;
adjust_capture_position = 0;
}
-
+
if (_slaved) {
if (_io && _io->active()) {
need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
AudioDiskstream::set_pending_overwrite (bool yn)
{
/* called from audio thread, so we can use the read ptr and playback sample as we wish */
-
+
pending_overwrite = yn;
overwrite_frame = playback_sample;
AudioDiskstream::overwrite_existing_buffers ()
{
boost::shared_ptr<ChannelList> c = channels.reader();
- Sample* mixdown_buffer;
- float* gain_buffer;
- int ret = -1;
+ Sample* mixdown_buffer;
+ float* gain_buffer;
+ int ret = -1;
bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
overwrite_queued = false;
/* assume all are the same size */
nframes_t size = c->front()->playback_buf->bufsize();
-
- mixdown_buffer = new Sample[size];
- gain_buffer = new float[size];
-
+
+ mixdown_buffer = new Sample[size];
+ gain_buffer = new float[size];
+
/* reduce size so that we can fill the buffer correctly. */
size--;
-
+
uint32_t n=0;
nframes_t start;
start = overwrite_frame;
nframes_t cnt = size;
-
+
/* to fill the buffer without resetting the playback sample, we need to
do it one or two chunks (normally two).
^
overwrite_offset
|<- second chunk->||<----------------- first chunk ------------------>|
-
+
*/
-
+
nframes_t to_read = size - overwrite_offset;
if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
_id, size, playback_sample) << endmsg;
goto out;
}
-
+
if (cnt > to_read) {
cnt -= to_read;
-
+
if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
start, cnt, *chan, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
}
ret = 0;
-
+
out:
pending_overwrite = false;
- delete [] gain_buffer;
- delete [] mixdown_buffer;
- return ret;
+ delete [] gain_buffer;
+ delete [] mixdown_buffer;
+ return ret;
}
int
boost::shared_ptr<ChannelList> c = channels.reader();
Glib::Mutex::Lock lm (state_lock);
-
+
for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
(*chan)->playback_buf->reset ();
(*chan)->capture_buf->reset ();
}
-
+
/* can't rec-enable in destructive mode if transport is before start */
-
+
if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
disengage_record_enable ();
}
-
+
playback_sample = frame;
file_frame = frame;
-
+
if (complete_refill) {
while ((ret = do_refill_with_alloc ()) > 0) ;
} else {
for (chan = c->begin(); chan != c->end(); ++chan) {
if ((*chan)->playback_buf->read_space() < distance) {
return false;
- }
+ }
}
return true;
}
first_recordable_frame += distance;
playback_sample += distance;
-
+
return 0;
}
int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
- ChannelInfo* channel_info, int channel, bool reversed)
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
+ ChannelInfo* /*channel_info*/, int channel, bool reversed)
{
nframes_t this_read = 0;
bool reloop = false;
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();
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
position within the loop.
*/
-
+
if (loc && start >= loop_end) {
//cerr << "start adjusted from " << start;
start = loop_start + ((start - loop_start) % loop_length);
if (reversed) {
start -= cnt;
}
-
+
/* take any loop into account. we can't read past the end of the loop. */
if (loc && (loop_end - start < cnt)) {
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(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
+ error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
start) << endmsg;
return -1;
}
_read_data_count = _playlist->read_data_count();
-
+
if (reversed) {
swap_by_ptr (buf, buf + 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;
offset += this_read;
float* gain_buf = new float[disk_io_chunk_frames];
int ret = _do_refill(mix_buf, gain_buf);
-
+
delete [] mix_buf;
delete [] gain_buf;
vector.len[1] = 0;
c->front()->playback_buf->get_write_vector (&vector);
-
+
if ((total_space = vector.len[0] + vector.len[1]) == 0) {
return 0;
}
this track, let the caller know so that it can arrange
for us to be called again, ASAP.
*/
-
+
if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
ret = 1;
}
-
- /* if we're running close to normal speed and there isn't enough
- space to do disk_io_chunk_frames of I/O, then don't bother.
-
+
+ /* if we're running close to normal speed and there isn't enough
+ space to do disk_io_chunk_frames 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.
*/
-
+
if ((total_space < disk_io_chunk_frames) && fabs (_actual_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 < (c->front()->playback_buf->bufsize() / 2)) {
return 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->playback_buf->get_write_vector (&vector);
memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
if (file_frame < total_space) {
- /* too close to the start: read what we can,
- and then zero fill the rest
+ /* too close to the start: read what we can,
+ and then zero fill the rest
*/
zero_fill = total_space - file_frame;
file_frame = 0;
} else {
-
+
zero_fill = 0;
}
if (file_frame == max_frames) {
/* 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->playback_buf->get_write_vector (&vector);
memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
}
return 0;
}
-
+
if (file_frame > max_frames - total_space) {
/* to close to the end: read what we can, and zero fill the rest */
zero_fill = 0;
}
}
-
+
nframes_t file_frame_tmp = 0;
for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
chan->playback_buf->get_write_vector (&vector);
if (vector.len[0] > disk_io_chunk_frames) {
-
+
/* 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_io_chunk_frames that would be filled
-
+
|......|+++++++++++++|...............................|
buf1 buf0
^^^^^^^^^^^^^^^
-
-
- So, just pretend that the buf1 part isn't there.
-
+
+
+ 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;
ret = -1;
goto out;
}
-
+
chan->playback_buf->increment_write_ptr (to_read);
}
}
}
-
+
file_frame = file_frame_tmp;
out:
return ret;
-}
+}
/** Flush pending data to disk.
*
* of data to disk. it will never write more than that. If it writes that
* much and there is more than that waiting to be written, it will return 1,
* otherwise 0 on success or -1 on failure.
- *
+ *
* If there is less than disk_io_chunk_frames to be written, no data will be
* written at all unless @a force_flush is true.
*/
int
-AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
+AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
{
uint32_t to_write;
int32_t ret = 0;
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
+
(*chan)->capture_buf->get_read_vector (&vector);
total = vector.len[0] + vector.len[1];
/* if there are 2+ chunks of disk i/o possible for
this track, let the caller know so that it can arrange
for us to be called again, ASAP.
-
+
if we are forcing a flush, then if there is* any* extra
work, let the caller know.
if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
ret = 1;
- }
+ }
to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
-
+
// check the transition buffer when recording destructive
// important that we get this after the capture buf
for (ti=0; ti < transcount; ++ti) {
CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
-
+
if (captrans.type == CaptureStart) {
// by definition, the first data we got above represents the given capture pos
if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
// shorten to make the write a perfect fit
- uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
+ uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
if (nto_write < to_write) {
ret = 1; // should we?
to_write = nto_write;
(*chan)->write_source->mark_capture_end ();
-
+
// increment past this transition, but go no further
++ti;
break;
(*chan)->capture_buf->increment_read_ptr (to_write);
(*chan)->curr_capture_cnt += to_write;
-
+
if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
-
+
/* we wrote all of vector.len[0] but it wasn't an entire
- disk_io_chunk_frames of data, so arrange for some part
+ disk_io_chunk_frames of data, so arrange for some part
of vector.len[1] to be flushed to disk as well.
*/
-
+
to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
}
_write_data_count += (*chan)->write_source->write_data_count();
-
+
(*chan)->capture_buf->increment_read_ptr (to_write);
(*chan)->curr_capture_cnt += to_write;
}
ChannelList::iterator chan;
vector<CaptureInfo*>::iterator ci;
boost::shared_ptr<ChannelList> c = channels.reader();
- uint32_t n = 0;
+ uint32_t n = 0;
bool mark_write_completed = false;
finish_capture (true, c);
- /* butler is already stopped, but there may be work to do
+ /* butler is already stopped, but there may be work to do
to flush remaining data to disk.
*/
while (more_work && !err) {
- switch (do_flush (Session::TransportContext, true)) {
+ switch (do_flush (TransportContext, true)) {
case 0:
more_work = false;
break;
/* XXX is there anything we can do if err != 0 ? */
Glib::Mutex::Lock lm (capture_info_lock);
-
+
if (capture_info.empty()) {
return;
}
if (abort_capture) {
-
+
if (destructive()) {
goto outout;
}
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
if ((*chan)->write_source) {
-
+
(*chan)->write_source->mark_for_remove ();
(*chan)->write_source->drop_references ();
(*chan)->write_source.reset ();
}
-
+
/* new source set up in "out" below */
}
goto out;
- }
+ }
for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
total_capture += (*ci)->frames;
for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
-
+
if (s) {
srcs.push_back (s);
s->update_header (capture_info.front()->start, when, twhen);
if (destructive()) {
- /* send a signal that any UI can pick up to do the right thing. there is
+ /* send a signal that any UI can pick up to do the right thing. there is
a small problem here in that a UI may need the peak data to be ready
for the data that was recorded and this isn't interlocked with that
process. this problem is deferred to the UI.
*/
-
+
_playlist->Modified();
} else {
so that any sub-regions will obviously be
children of this one (later!)
*/
-
+
try {
- boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
- whole_file_region_name,
- 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
+ boost::shared_ptr<Region> rx (RegionFactory::create (srcs,
+ c->front()->write_source->last_capture_start_frame(), total_capture,
+ whole_file_region_name, 0,
+ Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
region = boost::dynamic_pointer_cast<AudioRegion> (rx);
region->special_set_position (capture_info.front()->start);
}
-
-
+
+
catch (failed_constructor& err) {
error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
/* XXX what now? */
}
-
+
_last_capture_regions.push_back (region);
// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
-
+
XMLNode &before = _playlist->get_state();
_playlist->freeze ();
-
+
for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
-
+
string region_name;
_session.region_name (region_name, whole_file_region_name, false);
-
+
// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
-
+
try {
boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
region = boost::dynamic_pointer_cast<AudioRegion> (rx);
}
-
+
catch (failed_constructor& err) {
error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
continue; /* XXX is this OK? */
}
-
- region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
-
+
+ region->DropReferences.connect_same_thread (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
+
_last_capture_regions.push_back (region);
-
+
i_am_the_modifier++;
- _playlist->add_region (region, (*ci)->start);
+ _playlist->add_region (region, (*ci)->start, 1, non_layered());
i_am_the_modifier--;
-
+
buffer_position += (*ci)->frames;
}
if (recordable() && destructive()) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
+
RingBufferNPT<CaptureTransition>::rw_vector transvec;
(*chan)->capture_transition_buf->get_write_vector(&transvec);
-
+
if (transvec.len[0] > 0) {
transvec.buf[0]->type = CaptureStart;
transvec.buf[0]->capture_val = capture_start_frame;
}
else {
// bad!
- fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
+ fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
<< endmsg;
}
- }
+ }
}
}
}
void
-AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
+AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
{
was_recording = false;
-
+
if (capture_captured == 0) {
return;
}
if (recordable() && destructive()) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
+
RingBufferNPT<CaptureTransition>::rw_vector transvec;
(*chan)->capture_transition_buf->get_write_vector(&transvec);
-
+
if (transvec.len[0] > 0) {
transvec.buf[0]->type = CaptureEnd;
transvec.buf[0]->capture_val = capture_captured;
}
}
}
-
-
+
+
CaptureInfo* ci = new CaptureInfo;
-
+
ci->start = capture_start_frame;
ci->frames = capture_captured;
-
- /* XXX theoretical race condition here. Need atomic exchange ?
- However, the circumstances when this is called right
+
+ /* XXX theoretical race condition here. Need atomic exchange ?
+ However, the circumstances when this is called right
now (either on record-disable or transport_stopped)
mean that no actual race exists. I think ...
We now have a capture_info_lock, but it is only to be used
void
AudioDiskstream::set_record_enabled (bool yn)
{
- if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs().n_audio() == 0) {
+ if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
return;
}
return;
}
- if (yn && channels.reader()->front()->source == 0) {
-
- /* pick up connections not initiated *from* the IO object
- we're associated with.
- */
-
- get_input_sources ();
- }
-
/* yes, i know that this not proof against race conditions, but its
good enough. i think.
*/
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
if ((*chan)->source) {
- (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
+ (*chan)->source->ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
}
capturing_sources.push_back ((*chan)->write_source);
(*chan)->write_source->mark_streaming_write_started ();
}
-
+
} else {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
capturing_sources.push_back ((*chan)->write_source);
node->add_property ("channels", buf);
node->add_property ("playlist", _playlist->name());
-
+
snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
node->add_property ("speed", buf);
Location* pi;
- if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
- snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
+ if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+ snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
} else {
- snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
+ snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
}
cs_child->add_property (X_("at"), buf);
}
int
-AudioDiskstream::set_state (const XMLNode& node)
+AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
{
const XMLProperty* prop;
XMLNodeList nlist = node.children();
in_set_state = true;
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == IO::state_node_name) {
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == IO::state_node_name) {
deprecated_io_node = new XMLNode (**niter);
- }
+ }
if ((*niter)->name() == X_("CapturingSources")) {
capture_pending_node = *niter;
}
- }
+ }
/* prevent write sources from being created */
-
+
in_set_state = true;
-
+
if ((prop = node.property ("name")) != 0) {
_name = prop->value();
- }
+ }
if (deprecated_io_node) {
if ((prop = deprecated_io_node->property ("id")) != 0) {
if ((prop = node.property ("channels")) != 0) {
nchans = atoi (prop->value().c_str());
}
-
+
// create necessary extra channels
// we are always constructed with one and we always need one
_n_channels.set(DataType::AUDIO, channels.reader()->size());
-
+
if (nchans > _n_channels.n_audio()) {
add_channel (nchans - _n_channels.n_audio());
{
bool had_playlist = (_playlist != 0);
-
+
if (find_and_use_playlist (prop->value())) {
return -1;
}
if (!had_playlist) {
_playlist->set_orig_diskstream_id (_id);
}
-
+
if (!destructive() && capture_pending_node) {
/* destructive streams have one and only one source per channel,
and so they never end up in pending capture in any useful
capturing_sources.clear ();
- /* write sources are handled when we handle the input set
+ /* write sources are handled when we handle the input set
up of the IO that owns this DS (::non_realtime_input_change())
*/
-
+
return 0;
}
}
ChannelInfo* chan = (*c)[n];
-
+
if (chan->write_source) {
chan->write_source->done_with_peakfile_writes ();
chan->write_source->set_allow_remove_if_empty (true);
if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
throw failed_constructor();
}
- }
+ }
catch (failed_constructor &err) {
error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
/* do not remove destructive files even if they are empty */
chan->write_source->set_allow_remove_if_empty (!destructive());
+
+ /* until we write, this file is considered removable */
+
+ chan->write_source->mark_for_remove ();
return 0;
}
void
-AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
{
ChannelList::iterator chan;
boost::shared_ptr<ChannelList> c = channels.reader();
uint32_t n;
- if (!recordable()) {
+ if (!_session.writable() || !recordable()) {
return;
}
-
+
capturing_sources.clear ();
for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
}
void
-AudioDiskstream::set_block_size (nframes_t nframes)
+AudioDiskstream::set_block_size (nframes_t /*nframes*/)
{
if (_session.get_block_size() > speed_buffer_size) {
speed_buffer_size = _session.get_block_size();
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
+ if ((*chan)->speed_buffer)
+ delete [] (*chan)->speed_buffer;
(*chan)->speed_buffer = new Sample[speed_buffer_size];
}
}
{
/* make sure the wrap buffer is at least large enough to deal
with the speeds up to 1.2, to allow for micro-variation
- when slaving to MTC, SMPTE etc.
+ when slaving to MTC, Timecode etc.
*/
double sp = max (fabsf (_actual_speed), 1.2f);
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
- (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
- if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
- (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
+ if ((*chan)->playback_wrap_buffer)
+ delete [] (*chan)->playback_wrap_buffer;
+ (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
+ if ((*chan)->capture_wrap_buffer)
+ delete [] (*chan)->capture_wrap_buffer;
+ (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
}
wrap_buffer_size = required_wrap_size;
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
+
if ((*chan)->source) {
(*chan)->source->ensure_monitor_input (yn);
}
}
get_input_sources ();
-
+
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
{
while (how_many--) {
- c->push_back (new ChannelInfo(_session.audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
+ c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
+ interpolation.add_channel_to (_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size);
}
_n_channels.set(DataType::AUDIO, c->size());
AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
{
while (how_many-- && !c->empty()) {
- delete c->back();
+ // FIXME: crash (thread safe with RCU?)
+ // memory leak, when disabled.... :(
+ //delete c->back();
c->pop_back();
+ interpolation.remove_channel_from ();
}
_n_channels.set(DataType::AUDIO, c->size());
{
RCUWriter<ChannelList> writer (channels);
boost::shared_ptr<ChannelList> c = writer.get_copy();
-
+
return remove_channel_from (c, how_many);
}
try {
fs = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, _session,
+ prop->value(), false, _session.frame_rate()));
}
catch (failed_constructor& err) {
}
pending_sources.push_back (fs);
-
+
if (first_fs == 0) {
first_fs = fs;
}
}
boost::shared_ptr<AudioRegion> region;
-
+
try {
- region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
- region_name_from_path (first_fs->name(), true),
- 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
+ region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
+ pending_sources, 0, first_fs->length(first_fs->timeline_position()),
+ region_name_from_path (first_fs->name(), true), 0,
+ Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
region->special_set_position (0);
}
catch (failed_constructor& err) {
- error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
- _name)
- << endmsg;
-
+ error << string_compose (
+ _("%1: cannot create whole-file region from pending capture sources"),
+ _name) << endmsg;
+
return -1;
}
try {
- region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
+ region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
+ pending_sources, 0, first_fs->length(first_fs->timeline_position()),
+ region_name_from_path (first_fs->name(), true)));
}
catch (failed_constructor& err) {
error << string_compose (_("%1: cannot create region from pending capture sources"),
_name)
<< endmsg;
-
+
return -1;
}
return 0;
}
+int
+AudioDiskstream::set_non_layered (bool yn)
+{
+ if (yn != non_layered()) {
+
+ if (yn) {
+ _flags = Flag (_flags | NonLayered);
+ } else {
+ _flags = Flag (_flags & ~NonLayered);
+ }
+ }
+
+ return 0;
+}
+
int
AudioDiskstream::set_destructive (bool yn)
{
bool bounce_ignored;
if (yn != destructive()) {
-
+
if (yn) {
/* requestor should already have checked this and
- bounced if necessary and desired
+ bounced if necessary and desired
*/
if (!can_become_destructive (bounce_ignored)) {
return -1;
assert (first);
/* do the source(s) for the region cover the session start position ? */
-
+
if (first->position() != _session.current_start_frame()) {
if (first->start() > _session.current_start_frame()) {
requires_bounce = true;
assert (afirst);
- if (afirst->source()->used() > 1) {
- requires_bounce = true;
+ if (_session.playlists->source_use_count (afirst->source()) > 1) {
+ requires_bounce = true;
return false;
}
playback_buf = new RingBufferNPT<Sample> (bufsize);
capture_buf = new RingBufferNPT<Sample> (bufsize);
capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
-
+
/* touch the ringbuffer buffers, which will cause
them to be mapped into locked physical RAM if
we're running with mlockall(). this doesn't do
- much if we're not.
+ much if we're not.
*/
memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
if (write_source) {
write_source.reset ();
}
-
+
delete [] speed_buffer;
speed_buffer = 0;
delete [] capture_wrap_buffer;
capture_wrap_buffer = 0;
-
+
delete playback_buf;
playback_buf = 0;
projects / ardour.git / blobdiff