/* prevent any write sources from being created */
in_set_state = true;
-
- init(flag);
use_new_playlist ();
-
in_set_state = false;
}
, channels (new ChannelList)
{
in_set_state = true;
- init (Recordable);
+ init ();
if (set_state (node, Stateful::loading_state_version)) {
in_set_state = false;
}
void
-AudioDiskstream::init (Diskstream::Flag f)
+AudioDiskstream::init ()
{
- Diskstream::init(f);
-
/* there are no channels at this point, so these
two calls just get speed_buffer_size and wrap_buffer
size setup without duplicating their code.
}
int
-AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
+AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
{
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
int ret = -1;
nframes_t rec_offset = 0;
nframes_t rec_nframes = 0;
- bool nominally_recording;
- bool re = record_enabled ();
bool collect_playback = false;
- /* if we've already processed the frames corresponding to this call,
- just return. this allows multiple routes that are taking input
- from this diskstream to call our ::process() method, but have
- this stuff only happen once. more commonly, it allows both
- the AudioTrack that is using this AudioDiskstream *and* the Session
- to call process() without problems.
- */
-
- if (_processed) {
- return 0;
- }
-
- commit_should_unlock = false;
+ playback_distance = 0;
if (!_io || !_io->active()) {
- _processed = true;
return 0;
}
check_record_status (transport_frame, nframes, can_record);
- nominally_recording = (can_record && re);
-
if (nframes == 0) {
- _processed = true;
return 0;
}
- /* This lock is held until the end of AudioDiskstream::commit, so these two functions
- must always be called as a pair. The only exception is if this function
- returns a non-zero value, in which case, ::commit should not be called.
- */
+ Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
- // If we can't take the state lock return.
- if (!state_lock.trylock()) {
+ if (!sm.locked()) {
return 1;
}
- commit_should_unlock = true;
+
adjust_capture_position = 0;
for (chan = c->begin(); chan != c->end(); ++chan) {
(*chan)->current_playback_buffer = 0;
}
- 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;
- }
-
- OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+ /* two conditions to test for here:
+
+ A: this track is rec-enabled, and the session has confirmed that we can record
+ B: this track is rec-enabled, has been recording, and we are set up for auto-punch-in
- calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
+ The second test is necessary to capture the extra material that arrives AFTER the transport
+ frame has left the punch range (which will cause the "can_record" argument to be false).
+ */
- if (rec_nframes && !was_recording) {
- capture_captured = 0;
- was_recording = true;
- }
- }
+ // 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;
+ }
+
+ OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+
+ calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
+
+ if (rec_nframes && !was_recording) {
+ capture_captured = 0;
+ was_recording = true;
+ }
if (can_record && !_last_capture_regions.empty()) {
_last_capture_regions.clear ();
}
- if (nominally_recording || rec_nframes) {
+ if (rec_nframes) {
uint32_t limit = _io->n_ports ().n_audio();
AudioPort* const ap = _io->audio (n);
assert(ap);
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);
+ memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
} else {
adjust_capture_position = rec_nframes;
- } else if (nominally_recording) {
+ } else if (can_record && record_enabled()) {
/* can't do actual capture yet - waiting for latency effects to finish before we start*/
_speed = _target_speed;
- }
+ }
ret = 0;
- out:
- _processed = true;
-
- if (ret) {
-
- /* we're exiting with failure, so ::commit will not
- be called. unlock the state lock.
- */
-
- commit_should_unlock = false;
- state_lock.unlock();
- }
+ if (commit (nframes)) {
+ need_butler = true;
+ }
+ out:
return ret;
}
}
bool
-AudioDiskstream::commit (nframes_t /*nframes*/)
+AudioDiskstream::commit (nframes_t /* nframes */)
{
bool need_butler = false;
}
}
- if (commit_should_unlock) {
- state_lock.unlock();
- }
-
- _processed = false;
-
return need_butler;
}
string region_name;
- _session.region_name (region_name, whole_file_region_name, false);
+ RegionFactory::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;
AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
{
was_recording = false;
+ first_recordable_frame = max_frames;
+ last_recordable_frame = max_frames;
if (capture_captured == 0) {
return;
AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
{
while (how_many-- && !c->empty()) {
- // FIXME: crash (thread safe with RCU?)
- // memory leak, when disabled.... :(
- //delete c->back();
+ delete c->back();
c->pop_back();
interpolation.remove_channel_from ();
}
AudioDiskstream::ChannelInfo::~ChannelInfo ()
{
- if (write_source) {
- write_source.reset ();
- }
+ write_source.reset ();
delete [] speed_buffer;
speed_buffer = 0;