static void set_midi_readahead_frames (framecnt_t frames_ahead) { midi_readahead = frames_ahead; }
static void set_no_disk_output (bool yn);
+ static bool no_disk_output() { return _no_disk_output; }
protected:
friend class Track;
static framecnt_t _chunk_frames;
static framecnt_t midi_readahead;
- static bool no_disk_output;
+ static bool _no_disk_output;
/* The MIDI stuff */
void helper_thread();
- int silent_process_routes (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
- bool& need_butler);
-
int process_routes (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
bool& need_butler);
bool _process_non_rt_pending;
int _process_declick;
- bool _process_silent;
bool _process_noroll;
int _process_retval;
bool _process_need_butler;
bool follow_slave (pframes_t);
void calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta);
void track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t this_delta);
- void follow_slave_silently (pframes_t nframes, float slave_speed);
void switch_to_sync_source (SyncSource); /* !RT context */
void drop_sync_source (); /* !RT context */
virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
bool state_changing);
- int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
- bool& need_butler);
-
virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
int declick, bool& need_butler) = 0;
Sample* DiskReader::_mixdown_buffer = 0;
gain_t* DiskReader::_gain_buffer = 0;
framecnt_t DiskReader::midi_readahead = 4096;
-bool DiskReader::no_disk_output = false;
+bool DiskReader::_no_disk_output = false;
DiskReader::DiskReader (Session& s, string const & str, DiskIOProcessor::Flag f)
: DiskIOProcessor (s, str, f)
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
ChannelList::iterator chan;
- frameoffset_t playback_distance;
+ frameoffset_t disk_samples_to_consume;
MonitorState ms = _route->monitoring_state ();
if (_active) {
if (speed != 1.0f && speed != -1.0f) {
interpolation.set_speed (speed);
midi_interpolation.set_speed (speed);
- playback_distance = midi_interpolation.distance (nframes);
+ disk_samples_to_consume = midi_interpolation.distance (nframes);
if (speed < 0.0) {
- playback_distance = -playback_distance;
+ disk_samples_to_consume = -disk_samples_to_consume;
}
} else {
- playback_distance = nframes;
+ disk_samples_to_consume = nframes;
}
BufferSet& scratch_bufs (_session.get_scratch_buffers (bufs.count()));
const bool still_locating = _session.global_locate_pending();
- if (!result_required || ((ms & MonitoringDisk) == 0) || still_locating) {
+ cerr << name() << " use disk output ? " << !_no_disk_output << endl;
+
+ 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) {
+ if (!still_locating || _no_disk_output) {
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->buf->increment_read_ptr (playback_distance);
+ (*chan)->buf->increment_read_ptr (disk_samples_to_consume);
}
}
/* if monitoring disk but locating put silence in the buffers */
- if (still_locating && (ms == MonitoringDisk)) {
- bufs.silence (playback_distance, 0);
+ if (_no_disk_output || (still_locating && (ms == MonitoringDisk))) {
+ bufs.silence (nframes, 0);
}
} else {
chaninfo->buf->get_read_vector (&(*chan)->rw_vector);
- if (playback_distance <= (framecnt_t) chaninfo->rw_vector.len[0]) {
+ if (disk_samples_to_consume <= (framecnt_t) chaninfo->rw_vector.len[0]) {
if (fabsf (speed) != 1.0f) {
(void) interpolation.interpolate (
chaninfo->rw_vector.buf[0],
disk_signal);
} else if (speed != 0.0) {
- memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * playback_distance);
+ memcpy (disk_signal, chaninfo->rw_vector.buf[0], sizeof (Sample) * disk_samples_to_consume);
}
} else {
const framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
- if (playback_distance <= total) {
+ if (disk_samples_to_consume <= total) {
/* We have enough samples, but not in one lump.
*/
chaninfo->rw_vector.buf[0],
disk_signal);
disk_signal += chaninfo->rw_vector.len[0];
- interpolation.interpolate (n, playback_distance - 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) {
chaninfo->rw_vector.len[0] * sizeof (Sample));
memcpy (disk_signal + chaninfo->rw_vector.len[0],
chaninfo->rw_vector.buf[1],
- (playback_distance - chaninfo->rw_vector.len[0]) * sizeof (Sample));
+ (disk_samples_to_consume - chaninfo->rw_vector.len[0]) * sizeof (Sample));
}
} else {
- cerr << _name << " Need " << playback_distance << " total = " << total << endl;
+ cerr << _name << " Need " << disk_samples_to_consume << " total = " << total << endl;
cerr << "underrun for " << _name << endl;
DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, total space = %3\n",
DEBUG_THREAD_SELF, name(), total));
apply_gain_to_buffer (disk_signal, nframes, scaling);
}
- chaninfo->buf->increment_read_ptr (playback_distance);
+ chaninfo->buf->increment_read_ptr (disk_samples_to_consume);
- if (!no_disk_output && (speed != 0.0) && (ms & MonitoringInput)) {
+ if ((speed != 0.0) && (ms & MonitoringInput)) {
/* mix the disk signal into the input signal (already in bufs) */
- mix_buffers_no_gain (output.data(), disk_signal, speed == 0.0 ? nframes : playback_distance);
+ mix_buffers_no_gain (output.data(), disk_signal, speed == 0.0 ? nframes : disk_samples_to_consume);
}
}
}
/* MIDI data handling */
if (!_session.declick_out_pending()) {
+ MidiBuffer* dst;
+
+ if (_no_disk_output) {
+ dst = &scratch_bufs.get_midi(0);
+ } else {
+ dst = &bufs.get_midi (0);
+ }
+
if (ms & MonitoringDisk && !still_locating) {
- get_midi_playback (bufs.get_midi (0), playback_distance, ms, scratch_bufs, speed, playback_distance);
+ get_midi_playback (*dst, disk_samples_to_consume, ms, scratch_bufs, speed, disk_samples_to_consume);
}
}
bool butler_required = false;
if (speed < 0.0) {
- playback_sample -= playback_distance;
+ playback_sample -= disk_samples_to_consume;
} else {
- playback_sample += playback_distance;
+ playback_sample += disk_samples_to_consume;
}
if (_playlists[DataType::AUDIO]) {
/*
cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
" = " << frames_written - frames_read
- << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
+ << " + " << disk_samples_to_consume << " < " << midi_readahead << " = " << need_butler << ")" << endl;
*/
/* frames_read will generally be less than frames_written, but
* and can stall
*/
if (frames_read <= frames_written) {
- if ((frames_written - frames_read) + playback_distance < midi_readahead) {
+ if ((frames_written - frames_read) + disk_samples_to_consume < midi_readahead) {
butler_required = true;
}
} else {
* so that an event at playback_sample has time = 0
*/
void
-DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState ms, BufferSet& scratch_bufs, double speed, framecnt_t playback_distance)
+DiskReader::get_midi_playback (MidiBuffer& dst, framecnt_t nframes, MonitorState ms, BufferSet& scratch_bufs, double speed, framecnt_t disk_samples_to_consume)
{
MidiBuffer* target;
if (speed != 0.0 && fabsf (speed) != 1.0f) {
for (MidiBuffer::iterator i = target->begin(); i != target->end(); ++i) {
MidiBuffer::TimeType *tme = i.timeptr();
- *tme = (*tme) * nframes / playback_distance;
+ *tme = (*tme) * nframes / disk_samples_to_consume;
}
}
don't want any actual disk output yet because we are still not
synced.
*/
- no_disk_output = yn;
+ _no_disk_output = yn;
}
-
#endif
}
-int
-Graph::silent_process_routes (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool& need_butler)
-{
- if (!_threads_active) return 0;
-
- _process_nframes = nframes;
- _process_start_frame = start_frame;
- _process_end_frame = end_frame;
-
- _process_silent = true;
- _process_noroll = false;
- _process_retval = 0;
- _process_need_butler = false;
-
- if (!_graph_empty) {
- DEBUG_TRACE(DEBUG::ProcessThreads, "wake graph for silent process\n");
- _callback_start_sem.signal ();
- _callback_done_sem.wait ();
- DEBUG_TRACE (DEBUG::ProcessThreads, "graph execution complete\n");
- }
-
- need_butler = _process_need_butler;
-
- return _process_retval;
-}
-
int
Graph::process_routes (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
{
_process_end_frame = end_frame;
_process_declick = declick;
- _process_silent = false;
_process_noroll = false;
_process_retval = 0;
_process_need_butler = false;
_process_declick = declick;
_process_non_rt_pending = non_rt_pending;
- _process_silent = false;
_process_noroll = true;
_process_retval = 0;
_process_need_butler = false;
DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 runs route %2\n", pthread_name(), route->name()));
- if (_process_silent) {
- retval = route->silent_roll (_process_nframes, _process_start_frame, _process_end_frame, need_butler);
- } else if (_process_noroll) {
+ if (_process_noroll) {
route->set_pending_declick (_process_declick);
retval = route->no_roll (_process_nframes, _process_start_frame, _process_end_frame, _process_non_rt_pending);
} else {
return 0;
}
-/** @param need_butler to be set to true by this method if it needs the butler,
- * otherwise it must be left alone.
- */
-int
-Session::silent_process_routes (pframes_t nframes, bool& need_butler)
-{
- DiskReader::set_no_disk_output (true);
- int ret = process_routes (nframes, need_butler);
- DiskReader::set_no_disk_output (false);
- return ret;
-}
-
void
Session::get_track_statistics ()
{
_slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
- if (_slave_state == Running && !_slave->is_always_synced() &&
- !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
- ) {
+ if (_slave_state == Running && !_slave->is_always_synced() && !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)) {
+
+ /* may need to varispeed to sync with slave */
if (_transport_speed != 0.0f) {
slave_speed));
}
-#if 1
if (!actively_recording() && (framecnt_t) abs(average_slave_delta) > _slave->resolution()) {
- cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
- goto silent_motion;
+ DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => silent motion\n", abs(average_slave_delta), _slave->resolution()));
+ /* run routes as normal, but no disk output */
+ cerr << "sync too far apart " << average_slave_delta << ", NO disk audio for now\n";
+ DiskReader::set_no_disk_output (true);
+ return true;
+ }
+
+ if (!have_first_delta_accumulator) {
+ DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready\n");
+ /* run routes as normal, but no disk output */
+ cerr << "can't measure sync yet, NO disk audio for now\n";
+ DiskReader::set_no_disk_output (true);
+ return true;
}
-#endif
}
}
- if (_slave_state == Running && 0 == (post_transport_work () & ~PostTransportSpeed)) {
+ if (!have_first_delta_accumulator) {
+ DiskReader::set_no_disk_output (true);
+ } else {
+ DiskReader::set_no_disk_output (false);
+ }
+
+ if ((_slave_state == Running) && (0 == (post_transport_work () & ~PostTransportSpeed))) {
/* speed is set, we're locked, and good to go */
+ cerr << "slave is locked, play disk audio ? " << !DiskReader::no_disk_output() << " delta = " << average_slave_delta << endl;
return true;
}
- silent_motion:
- DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
- follow_slave_silently (nframes, slave_speed);
-
noroll:
/* don't move at all */
DEBUG_TRACE (DEBUG::Slave, "no roll\n")
}
}
-void
-Session::follow_slave_silently (pframes_t nframes, float slave_speed)
-{
- if (slave_speed && _transport_speed) {
-
- /* something isn't right, but we should move with the master
- for now.
- */
-
- bool need_butler = false;
-
- silent_process_routes (nframes, need_butler);
-
- get_track_statistics ();
-
- if (need_butler) {
- DEBUG_TRACE (DEBUG::Butler, "f-slave-silently: session needs butler, call it\n");
- _butler->summon ();
- }
-
- int32_t frames_moved;
-
- if (locate_pending()) {
- frames_moved = 0;
- } else {
- frames_moved = (int32_t) floor (_transport_speed * nframes);
- }
-
- if (frames_moved < 0) {
- decrement_transport_position (-frames_moved);
- } else if (frames_moved) {
- increment_transport_position (frames_moved);
- }
-
- framepos_t const stop_limit = compute_stop_limit ();
- maybe_stop (stop_limit);
- }
-}
-
void
Session::process_without_events (pframes_t nframes)
{
return 0;
}
-int
-Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
-{
- Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
- if (!lm.locked()) {
- // XXX DISK reader needs to seek ahead the correct distance ?? OR DOES IT ?
- //framecnt_t playback_distance = _disk_reader->calculate_playback_distance(nframes);
- //if (can_internal_playback_seek(playback_distance)) {
- // internal_playback_seek(playback_distance);
- //}
- return 0;
- }
-
- if (n_outputs().n_total() == 0 && _processors.empty()) {
- return 0;
- }
-
- if (!_active) {
- silence (nframes);
- return 0;
- }
-
- _silent = true;
- _amp->apply_gain_automation(false);
-
- silence (nframes);
- flush_processor_buffers_locked (nframes);
-
- //BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
- // XXXX DISKWRITER/READER ADVANCE, SET need_butler
- return 0;
-}
-
boost::shared_ptr<Playlist>
Track::playlist ()
{
projects / ardour.git / commitdiff