#include "ardour/source_factory.h"
#include "ardour/utils.h"
#include "ardour/session_playlists.h"
+#include "ardour/route.h"
#include "i18n.h"
#include <locale.h>
/* 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.
newname = Playlist::bump_name (_playlist->name(), _session);
- if ((playlist
= boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
+ if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
} else {
int ret = -1;
nframes_t rec_offset = 0;
nframes_t rec_nframes = 0;
- bool nominally_recording;
- bool re = record_enabled ();
bool collect_playback = false;
playback_distance = 0;
check_record_status (transport_frame, nframes, can_record);
- nominally_recording = (can_record && re);
-
if (nframes == 0) {
return 0;
}
(*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;
- }
+ /* 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
- OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+ 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).
+ */
- calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
- 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*/
{
/* called from audio thread, so we can use the read ptr and playback sample as we wish */
- pending_overwrite = yn;
+ _pending_overwrite = yn;
overwrite_frame = playback_sample;
overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
ret = 0;
out:
- pending_overwrite = false;
+ _pending_overwrite = false;
delete [] gain_buffer;
delete [] mixdown_buffer;
return ret;
}
void
-AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
+AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
{
uint32_t buffer_position;
bool more_work = true;
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;
XMLNode&
AudioDiskstream::get_state ()
{
- XMLNode* node = new XMLNode ("AudioDiskstream");
+ XMLNode* node = new XMLNode ("Diskstream");
char buf[64] = "";
LocaleGuard lg (X_("POSIX"));
boost::shared_ptr<ChannelList> c = channels.reader();
}
if (!had_playlist) {
- _playlist->set_orig_diskstream_id (_id);
+ _playlist->set_orig_diskstream_id (id());
}
if (!destructive() && capture_pending_node) {
}
try {
- if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
+ if ((chan->write_source = _session.create_audio_source_for_session (n_channels().n_audio(), name(), n, destructive())) == 0) {
throw failed_constructor();
}
}
when slaving to MTC, Timecode etc.
*/
- double sp = max (fabsf (_actual_speed), 1.2f);
+ double const sp = max (fabsf (_actual_speed), 1.2f);
nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
if (required_wrap_size > wrap_buffer_size) {
AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
{
while (how_many--) {
- 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);
+ c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_playback_buffer_size(),
+ _session.butler()->audio_diskstream_capture_buffer_size(),
+ speed_buffer_size, wrap_buffer_size));
+ interpolation.add_channel_to (_session.butler()->audio_diskstream_playback_buffer_size(), speed_buffer_size);
}
_n_channels.set(DataType::AUDIO, c->size());
return true;
}
-AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
+void
+AudioDiskstream::adjust_playback_buffering ()
+{
+ boost::shared_ptr<ChannelList> c = channels.reader();
+
+ for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
+ (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
+ }
+}
+
+void
+AudioDiskstream::adjust_capture_buffering ()
+{
+ boost::shared_ptr<ChannelList> c = channels.reader();
+
+ for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
+ (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
+ }
+}
+
+AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t playback_bufsize, nframes_t capture_bufsize, nframes_t speed_size, nframes_t wrap_size)
{
peak_power = 0.0f;
source = 0;
playback_wrap_buffer = new Sample[wrap_size];
capture_wrap_buffer = new Sample[wrap_size];
- playback_buf = new RingBufferNPT<Sample> (bufsize);
- capture_buf = new RingBufferNPT<Sample> (bufsize);
+ playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
+ capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
/* touch the ringbuffer buffers, which will cause
memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
}
+void
+AudioDiskstream::ChannelInfo::resize_playback (nframes_t playback_bufsize)
+{
+ delete playback_buf;
+ playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
+ memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
+}
+
+void
+AudioDiskstream::ChannelInfo::resize_capture (nframes_t capture_bufsize)
+{
+ delete capture_buf;
+ capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
+ memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
+}
+
AudioDiskstream::ChannelInfo::~ChannelInfo ()
{
write_source.reset ();
delete capture_transition_buf;
capture_transition_buf = 0;
}
+
projects / ardour.git / blobdiff