smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-16 19:56:31 +01:00
Code Issues Projects Releases Wiki Activity

Remove code related to capture-offset.

Browse source
This commit is contained in:
Robin Gareus 2017-09-28 04:42:13 +02:00
parent d98f87d542
commit 2fa1f1b0b3
5 changed files with 18 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

11
libs/ardour/ardour/disk_writer.h
View file

@ -87,8 +87,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
PBD::Signal0<void> AlignmentStyleChanged; PBD::Signal0<void> AlignmentStyleChanged;
void set_input_latency (samplecnt_t);
bool configure_io (ChanCount in, ChanCount out); bool configure_io (ChanCount in, ChanCount out);
std::list<boost::shared_ptr<Source> >& last_capture_sources () { return _last_capture_sources; } std::list<boost::shared_ptr<Source> >& last_capture_sources () { return _last_capture_sources; }
@ -114,9 +112,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
virtual void request_input_monitoring (bool) {} virtual void request_input_monitoring (bool) {}
virtual void ensure_input_monitoring (bool) {} virtual void ensure_input_monitoring (bool) {}
samplecnt_t capture_offset() const { return _capture_offset; }
virtual void set_capture_offset ();
int seek (samplepos_t sample, bool complete_refill); int seek (samplepos_t sample, bool complete_refill);
static PBD::Signal0<void> Overrun; static PBD::Signal0<void> Overrun;
@ -132,8 +127,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
PBD::Signal0<void> RecordEnableChanged; PBD::Signal0<void> RecordEnableChanged;
PBD::Signal0<void> RecordSafeChanged; PBD::Signal0<void> RecordSafeChanged;
void check_record_status (samplepos_t transport_sample, bool can_record);
void transport_looped (samplepos_t transport_sample); void transport_looped (samplepos_t transport_sample);
void transport_stopped_wallclock (struct tm&, time_t, bool abort); void transport_stopped_wallclock (struct tm&, time_t, bool abort);
@ -148,7 +141,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
void set_align_style_from_io(); void set_align_style_from_io();
void setup_destructive_playlist (); void setup_destructive_playlist ();
void use_destructive_playlist (); void use_destructive_playlist ();
void prepare_to_stop (samplepos_t transport_pos, samplepos_t audible_sample);
void engage_record_enable (); void engage_record_enable ();
void disengage_record_enable (); void disengage_record_enable ();
@ -172,8 +164,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
samplepos_t capture_start_sample; samplepos_t capture_start_sample;
samplecnt_t capture_captured; samplecnt_t capture_captured;
bool was_recording; bool was_recording;
samplecnt_t adjust_capture_position;
samplecnt_t _capture_offset;
samplepos_t first_recordable_sample; samplepos_t first_recordable_sample;
samplepos_t last_recordable_sample; samplepos_t last_recordable_sample;
int last_possibly_recording; int last_possibly_recording;
@ -197,6 +187,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
MidiBuffer _gui_feed_buffer; MidiBuffer _gui_feed_buffer;
mutable Glib::Threads::Mutex _gui_feed_buffer_mutex; mutable Glib::Threads::Mutex _gui_feed_buffer_mutex;
void check_record_status (samplepos_t transport_sample, double speed, bool can_record);
void finish_capture (boost::shared_ptr<ChannelList> c); void finish_capture (boost::shared_ptr<ChannelList> c);
}; };

1
libs/ardour/ardour/track.h
View file

@ -155,7 +155,6 @@ class LIBARDOUR_API Track : public Route, public Recordable
bool realtime_speed_change (); bool realtime_speed_change ();
void transport_stopped_wallclock (struct tm &, time_t, bool); void transport_stopped_wallclock (struct tm &, time_t, bool);
bool pending_overwrite () const; bool pending_overwrite () const;
void prepare_to_stop (samplepos_t, samplepos_t);
void set_slaved (bool); void set_slaved (bool);
ChanCount n_channels (); ChanCount n_channels ();
samplepos_t get_capture_start_sample (uint32_t n = 0) const; samplepos_t get_capture_start_sample (uint32_t n = 0) const;

93
libs/ardour/disk_writer.cc
View file

@ -50,8 +50,6 @@ DiskWriter::DiskWriter (Session& s, string const & str, DiskIOProcessor::Flag f)
, capture_start_sample (0) , capture_start_sample (0)
, capture_captured (0) , capture_captured (0)
, was_recording (false) , was_recording (false)
, adjust_capture_position (0)
, _capture_offset (0)
, first_recordable_sample (max_samplepos) , first_recordable_sample (max_samplepos)
, last_recordable_sample (max_samplepos) , last_recordable_sample (max_samplepos)
, last_possibly_recording (0) , last_possibly_recording (0)
@ -88,7 +86,7 @@ DiskWriter::set_write_source_name (string const & str)
} }
void void
DiskWriter::check_record_status (samplepos_t transport_sample, bool can_record) DiskWriter::check_record_status (samplepos_t transport_sample, double speed, bool can_record)
{ {
int possibly_recording; int possibly_recording;
int rolling; int rolling;
@ -110,34 +108,28 @@ DiskWriter::check_record_status (samplepos_t transport_sample, bool can_record)
return; return;
} }
const samplecnt_t existing_material_offset = _session.worst_playback_latency();
if (possibly_recording == fully_rec_enabled) { if (possibly_recording == fully_rec_enabled) {
if (last_possibly_recording == fully_rec_enabled) { if (last_possibly_recording == fully_rec_enabled) {
return; return;
} }
capture_start_sample = _session.transport_sample(); capture_start_sample = transport_sample;
first_recordable_sample = capture_start_sample + _capture_offset; first_recordable_sample = capture_start_sample + _input_latency;
last_recordable_sample = max_samplepos; if (_alignment_style == ExistingMaterial) {
// XXX
}
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 (%9) FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8 WOL %10 WTL %11\n", DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 (%9) FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8 WOL %10 WTL %11\n",
name(), first_recordable_sample, last_recordable_sample, capture_start_sample, name(), first_recordable_sample, last_recordable_sample, capture_start_sample,
_capture_offset, 0,
existing_material_offset, 0,
transport_sample, transport_sample,
_session.transport_sample(), _session.transport_sample(),
_session.worst_output_latency(), _session.worst_output_latency(),
_session.worst_track_latency())); _session.worst_track_latency()));
if (_alignment_style == ExistingMaterial) {
first_recordable_sample += existing_material_offset;
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift FRF by EMO %1\n",
first_recordable_sample));
}
prepare_record_status (capture_start_sample); prepare_record_status (capture_start_sample);
} else { } else {
@ -156,10 +148,10 @@ DiskWriter::check_record_status (samplepos_t transport_sample, bool can_record)
} else { } else {
/* punch out */ /* punch out */
last_recordable_sample = _session.transport_sample() + _capture_offset; last_recordable_sample = _session.transport_sample();
if (_alignment_style == ExistingMaterial) { if (_alignment_style == ExistingMaterial) {
last_recordable_sample += existing_material_offset; //XXX
} }
} }
} }
@ -217,29 +209,6 @@ DiskWriter::calculate_record_range (Evoral::OverlapType ot, samplepos_t transpor
first_recordable_sample, last_recordable_sample, rec_nframes, rec_offset)); first_recordable_sample, last_recordable_sample, rec_nframes, rec_offset));
} }
void
DiskWriter::prepare_to_stop (samplepos_t transport_sample, samplepos_t audible_sample)
{
switch (_alignment_style) {
case ExistingMaterial:
last_recordable_sample = transport_sample + _capture_offset;
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable sample to %2 + %3 = %4\n", _name, transport_sample, _capture_offset, last_recordable_sample));
break;
case CaptureTime:
last_recordable_sample = audible_sample; // note that capture_offset is zero
/* we may already have captured audio before the last_recordable_sample (audible sample),
so deal with this.
*/
if (last_recordable_sample > capture_start_sample) {
capture_captured = min (capture_captured, last_recordable_sample - capture_start_sample);
}
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable sample to audible sample @ %2\n", _name, audible_sample));
break;
}
}
void void
DiskWriter::engage_record_enable () DiskWriter::engage_record_enable ()
{ {
@ -293,31 +262,6 @@ DiskWriter::get_captured_samples (uint32_t n) const
} }
} }
void
DiskWriter::set_input_latency (samplecnt_t l)
{
Processor::set_input_latency (l);
set_capture_offset ();
}
void
DiskWriter::set_capture_offset ()
{
switch (_alignment_style) {
case ExistingMaterial:
_capture_offset = _input_latency;
break;
case CaptureTime:
default:
_capture_offset = 0;
break;
}
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: using input latency %4, capture offset set to %2 with style = %3\n", name(), _capture_offset, enum_2_string (_alignment_style), _input_latency));
}
void void
DiskWriter::set_align_style (AlignStyle a, bool force) DiskWriter::set_align_style (AlignStyle a, bool force)
{ {
@ -327,7 +271,6 @@ DiskWriter::set_align_style (AlignStyle a, bool force)
if ((a != _alignment_style) || force) { if ((a != _alignment_style) || force) {
_alignment_style = a; _alignment_style = a;
set_capture_offset ();
AlignmentStyleChanged (); AlignmentStyleChanged ();
} }
} }
@ -428,7 +371,7 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
_need_butler = false; _need_butler = false;
check_record_status (start_sample, can_record); check_record_status (start_sample, 1, can_record);
if (nframes == 0) { if (nframes == 0) {
return; return;
@ -452,8 +395,6 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
get_location_times (loop_loc, &loop_start, &loop_end, &loop_length); get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
} }
adjust_capture_position = 0;
if (nominally_recording || (re && was_recording && _session.get_record_enabled() && (_session.config.get_punch_in() || _session.preroll_record_punch_enabled()))) { if (nominally_recording || (re && was_recording && _session.get_record_enabled() && (_session.config.get_punch_in() || _session.preroll_record_punch_enabled()))) {
Evoral::OverlapType ot = Evoral::coverage (first_recordable_sample, last_recordable_sample, start_sample, end_sample); Evoral::OverlapType ot = Evoral::coverage (first_recordable_sample, last_recordable_sample, start_sample, end_sample);

7
libs/ardour/session_transport.cc
View file

@ -1590,13 +1590,6 @@ Session::stop_transport (bool abort, bool clear_state)
boost::shared_ptr<RouteList> rl = routes.reader(); boost::shared_ptr<RouteList> rl = routes.reader();
samplepos_t stop_target = audible_sample(); samplepos_t stop_target = audible_sample();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr) {
tr->prepare_to_stop (_transport_sample, stop_target);
}
}
SubState new_bits; SubState new_bits;
if (actively_recording() && /* we are recording */ if (actively_recording() && /* we are recording */

11
libs/ardour/track.cc
View file

@ -425,8 +425,6 @@ Track::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sam
return 0; return 0;
} }
bool can_record = _session.actively_recording ();
/* no outputs? nothing to do ... what happens if we have sends etc. ? */ /* no outputs? nothing to do ... what happens if we have sends etc. ? */
if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) { if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) {
@ -460,10 +458,7 @@ Track::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sam
*/ */
} }
_disk_writer->check_record_status (start_sample, can_record);
bool be_silent; bool be_silent;
MonitorState const s = monitoring_state (); MonitorState const s = monitoring_state ();
/* we are not rolling, so be silent even if we are monitoring disk, as there /* we are not rolling, so be silent even if we are monitoring disk, as there
will be no disk data coming in. will be no disk data coming in.
@ -740,12 +735,6 @@ Track::pending_overwrite () const
return _disk_reader->pending_overwrite (); return _disk_reader->pending_overwrite ();
} }
void
Track::prepare_to_stop (samplepos_t t, samplepos_t a)
{
_disk_writer->prepare_to_stop (t, a);
}
void void
Track::set_slaved (bool s) Track::set_slaved (bool s)
{ {