return;
}
- if (yn) {
- _diskstream->engage_record_enable();
- } else {
- _diskstream->disengage_record_enable();
- }
+ _diskstream->set_record_enabled (yn);
_rec_enable_control->Changed ();
}
Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+
if (!lm.locked()) {
return 0;
}
bool can_record = _session.actively_recording ();
+ /* no outputs? nothing to do ... what happens if we have sends etc. ? */
+
if (n_outputs().n_total() == 0) {
return 0;
}
+ /* not active ... do the minimum possible by just outputting silence */
+
if (!_active) {
silence (nframes);
+ if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
+ _meter->reset();
+ }
return 0;
}
into the route.
*/
be_silent = true;
+
} else {
+
MonitorState const s = monitoring_state ();
/* we are not rolling, so be silent even if we are monitoring disk, as there
will be no disk data coming in.
*/
- be_silent = (s == MonitoringSilence || s == MonitoringDisk);
- }
-
- if (!_have_internal_generator && metering_state() == MeteringInput) {
- _input->process_input (_meter, start_frame, end_frame, nframes);
+ switch (s) {
+ case MonitoringSilence:
+ /* if there is an instrument, be_silent should always
+ be false
+ */
+ be_silent = (the_instrument_unlocked() == 0);
+ break;
+ case MonitoringDisk:
+ be_silent = true;
+ break;
+ case MonitoringInput:
+ be_silent = false;
+ break;
+ default:
+ be_silent = false;
+ break;
+ }
}
- _amp->apply_gain_automation(false);
+ _amp->apply_gain_automation (false);
/* if have_internal_generator, or .. */
- //_input->process_input (_meter, start_frame, end_frame, nframes);
if (be_silent) {
+ if (_meter_point == MeterInput) {
+ /* still need input monitoring and metering */
+
+ bool const track_rec = _diskstream->record_enabled ();
+ bool const auto_input = _session.config.get_auto_input ();
+ bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
+ bool const tape_machine_mode = Config->get_tape_machine_mode ();
+ bool no_meter = false;
+
+ /* this needs a proper K-map
+ * and should be separated into a function similar to monitoring_state()
+ * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
+ *
+ * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
+ */
+ if (!auto_input && !track_rec) {
+ no_meter=true;
+ }
+ else if (tape_machine_mode && !track_rec && auto_input) {
+ no_meter=true;
+ }
+ else if (!software_monitor && tape_machine_mode && !track_rec) {
+ no_meter=true;
+ }
+ else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
+ no_meter=true;
+ }
+
+ if (no_meter) {
+ BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
+ _meter->run (bufs, 0, 0, nframes, true);
+ _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
+ } else {
+ _input->process_input (_meter, start_frame, end_frame, nframes);
+ }
+ }
+
passthru_silence (start_frame, end_frame, nframes, 0);
} else {
- /* we're sending signal, but we may still want to meter the input.
- */
+ BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
+
+ fill_buffers_with_input (bufs, _input, nframes);
+
+ if (_meter_point == MeterInput) {
+ _meter->run (bufs, start_frame, end_frame, nframes, true);
+ }
- passthru (start_frame, end_frame, nframes, false);
+ passthru (bufs, start_frame, end_frame, nframes, false);
}
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
+ framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
+ if (can_internal_playback_seek(playback_distance)) {
+ internal_playback_seek(playback_distance);
+ }
return 0;
}
silence (nframes);
framecnt_t playback_distance;
- int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
+
+ BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
+
+ int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
need_butler = _diskstream->commit (playback_distance);
return dret;
}
}
void
-Track::request_jack_monitors_input (bool m)
+Track::request_input_monitoring (bool m)
{
- _diskstream->request_jack_monitors_input (m);
+ _diskstream->request_input_monitoring (m);
}
void
-Track::ensure_jack_monitors_input (bool m)
+Track::ensure_input_monitoring (bool m)
{
- _diskstream->ensure_jack_monitors_input (m);
+ _diskstream->ensure_input_monitoring (m);
}
bool
MeterState
Track::metering_state () const
{
- return _diskstream->record_enabled() ? MeteringInput : MeteringRoute;
+ bool rv;
+ if (_session.transport_rolling ()) {
+ // audio_track.cc || midi_track.cc roll() runs meter IFF:
+ rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
+ } else {
+ // track no_roll() always metering if
+ rv = _meter_point == MeterInput;
+ }
+ return rv ? MeteringInput : MeteringRoute;
}
+
projects / ardour.git / blobdiff