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 {
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 {
return -1;
}
}
+
+/** Do some record stuff [not described in this comment!]
+ *
+ * Also:
+ * - Setup playback_distance with the nframes, or nframes adjusted
+ * for current varispeed, if appropriate.
+ * - Setup current_playback_buffer in each ChannelInfo to point to data
+ * that someone can read playback_distance worth of data from.
+ */
int
-AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool& need_butler)
+AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
{
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
ChannelList::iterator chan;
- int ret = -1;
framecnt_t rec_offset = 0;
framecnt_t rec_nframes = 0;
bool collect_playback = false;
+ bool can_record = _session.actively_recording ();
playback_distance = 0;
for recording, and use rec_offset
*/
- AudioPort* const ap = _io->audio (n);
+ boost::shared_ptr<AudioPort> const ap = _io->audio (n);
assert(ap);
assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
if (rec_nframes > total) {
DiskOverrun ();
- goto out;
+ return -1;
}
- AudioPort* const ap = _io->audio (n);
+ boost::shared_ptr<AudioPort> const ap = _io->audio (n);
assert(ap);
Sample* buf = ap->get_audio_buffer(nframes).data (rec_offset);
collect_playback = true;
}
- if ((_track->monitoring() & MonitorDisk) || collect_playback) {
-
+ if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) {
+
/* we're doing playback */
framecnt_t necessary_samples;
n = 0;
+ /* Setup current_playback_buffer in each ChannelInfo to point to data that someone
+ can read necessary_samples (== nframes at a transport speed of 1) worth of data
+ from right now.
+ */
+
for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
ChannelInfo* chaninfo (*chan);
if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) {
-
+ /* There are enough samples in the first part of the ringbuffer */
chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
} else {
cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
cerr << "underrun for " << _name << endl;
DiskUnderrun ();
- goto out;
+ return -1;
} else {
+ /* We have enough samples, but not in one lump. Coalesce the two parts
+ into one in playback_wrap_buffer in our ChannelInfo, and specify that
+ as our current_playback_buffer.
+ */
+
+ /* Copy buf[0] from playback_buf */
memcpy ((char *) chaninfo->playback_wrap_buffer,
chaninfo->playback_vector.buf[0],
chaninfo->playback_vector.len[0] * sizeof (Sample));
+
+ /* Copy buf[1] from playback_buf */
memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
chaninfo->playback_vector.buf[1],
(necessary_samples - chaninfo->playback_vector.len[0])
}
if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
- process_varispeed_playback(nframes, c);
+
+ interpolation.set_speed (_target_speed);
+
+ int channel = 0;
+ for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
+ ChannelInfo* chaninfo (*chan);
+
+ playback_distance = interpolation.interpolate (
+ channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+
+ chaninfo->current_playback_buffer = chaninfo->speed_buffer;
+ }
+
} else {
playback_distance = nframes;
}
_speed = _target_speed;
-
- }
-
- ret = 0;
-
- if (commit (nframes)) {
- need_butler = true;
}
- out:
- return ret;
-}
-
-void
-AudioDiskstream::process_varispeed_playback (pframes_t nframes, boost::shared_ptr<ChannelList> c)
-{
- ChannelList::iterator chan;
-
- interpolation.set_speed (_target_speed);
-
- int channel = 0;
- for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
- ChannelInfo* chaninfo (*chan);
-
- playback_distance = interpolation.interpolate (
- channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
-
- chaninfo->current_playback_buffer = chaninfo->speed_buffer;
- }
+ return 0;
}
+/** Update various things including playback_sample, read pointer on each channel's playback_buf
+ * and write pointer on each channel's capture_buf. Also wout whether the butler is needed.
+ * @return true if the butler is required.
+ */
bool
-AudioDiskstream::commit (framecnt_t /* nframes */)
+AudioDiskstream::commit (framecnt_t playback_distance)
{
bool need_butler = false;
framecnt_t to_read = size - overwrite_offset;
- if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
+ if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
id(), size, playback_sample) << endmsg;
goto out;
cnt -= to_read;
- if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
- start, cnt, *chan, n, reversed)) {
+ if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
id(), size, playback_sample) << endmsg;
goto out;
return 0;
}
+/** Read some data for 1 channel from our playlist into a buffer.
+ * @param buf Buffer to write to.
+ * @param start Session frame to start reading from; updated to where we end up
+ * after the read.
+ * @param cnt Count of samples to read.
+ * @param reversed true if we are running backwards, otherwise false.
+ */
int
AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
framepos_t& start, framecnt_t cnt,
- ChannelInfo* /*channel_info*/, int channel, bool reversed)
+ int channel, bool reversed)
{
framecnt_t this_read = 0;
bool reloop = false;
*/
if (loc && start >= loop_end) {
- //cerr << "start adjusted from " << start;
start = loop_start + ((start - loop_start) % loop_length);
- //cerr << "to " << start << endl;
}
-
- //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
}
if (reversed) {
start -= cnt;
}
+ /* 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;
- //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
reloop = true;
} else {
reloop = false;
return -1;
}
- _read_data_count = _playlist->read_data_count();
-
if (reversed) {
swap_by_ptr (buf, buf + this_read - 1);
return ret;
}
+/** Get some more data from disk and put it in our channels' playback_bufs,
+ * if there is suitable space in them.
+ */
int
AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
{
int32_t ret = 0;
framecnt_t to_read;
RingBufferNPT<Sample>::rw_vector vector;
- bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
+ bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
framecnt_t total_space;
framecnt_t zero_fill;
uint32_t chan_n;
c->front()->playback_buf->get_write_vector (&vector);
if ((total_space = vector.len[0] + vector.len[1]) == 0) {
+ /* nowhere to write to */
return 0;
}
for us to be called again, ASAP.
*/
- if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
+ if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) {
ret = 1;
}
if (to_read) {
- if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+ if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
ret = -1;
goto out;
}
so read some or all of vector.len[1] as well.
*/
- if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+ if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
ret = -1;
goto out;
}
}
if (zero_fill) {
- /* do something */
+ /* XXX: do something */
}
}
RingBufferNPT<CaptureTransition>::rw_vector transvec;
framecnt_t total;
- _write_data_count = 0;
-
transvec.buf[0] = 0;
transvec.buf[1] = 0;
vector.buf[0] = 0;
return -1;
}
- _write_data_count += (*chan)->write_source->write_data_count();
-
(*chan)->capture_buf->increment_read_ptr (to_write);
(*chan)->curr_capture_cnt += to_write;
}
i_am_the_modifier++;
- if (_playlist->explicit_relayering()) {
- /* We are in `explicit relayering' mode, so we must specify which layer this new region
- should end up on. Put it at the top.
- */
- region->set_layer (_playlist->top_layer() + 1);
- region->set_pending_explicit_relayer (true);
- }
-
+ region->set_pending_layer (max_layer);
_playlist->add_region (region, (*ci)->start, 1, non_layered());
i_am_the_modifier--;
if (Config->get_monitoring_model() == HardwareMonitoring) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
+ (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
capturing_sources.push_back ((*chan)->write_source);
(*chan)->write_source->mark_streaming_write_started ();
}
boost::shared_ptr<ChannelList> c = channels.reader();
if (Config->get_monitoring_model() == HardwareMonitoring) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->source.ensure_monitor_input (false);
+ (*chan)->source.request_jack_monitors_input (false);
}
}
capturing_sources.clear ();
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- if ((*chan)->playback_wrap_buffer)
+ if ((*chan)->playback_wrap_buffer) {
delete [] (*chan)->playback_wrap_buffer;
+ }
(*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
- if ((*chan)->capture_wrap_buffer)
+ if ((*chan)->capture_wrap_buffer) {
delete [] (*chan)->capture_wrap_buffer;
+ }
(*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
}
}
void
-AudioDiskstream::monitor_input (bool yn)
+AudioDiskstream::request_jack_monitors_input (bool yn)
{
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->source.ensure_monitor_input (yn);
+ (*chan)->source.request_jack_monitors_input (yn);
}
}
}
void
-AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const
+AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const
{
if (name.empty()) {
return;
}
- return AudioEngine::instance()->ensure_monitor_input (name, yn);
+ return AudioEngine::instance()->request_jack_monitors_input (name, yn);
}
AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
{
- peak_power = 0.0f;
current_capture_buffer = 0;
current_playback_buffer = 0;
curr_capture_cnt = 0;
projects / ardour.git / blobdiff