*/
PBD::Signal3<void, Port *, Port *, bool> PortConnectedOrDisconnected;
- std::string make_port_name_relative (std::string);
- std::string make_port_name_non_relative (std::string);
+ std::string make_port_name_relative (std::string) const;
+ std::string make_port_name_non_relative (std::string) const;
+ bool port_is_mine (const std::string&) const;
static AudioEngine* instance() { return _instance; }
void died ();
boost::shared_ptr<MuteMaster> _mute_master;
bool no_panner_reset;
boost::shared_ptr<PannerShell> _panshell;
+ framecnt_t scnt;
static bool panners_legal;
static PBD::Signal0<int> PannersLegal;
(*chan)->current_playback_buffer = 0;
}
- /* 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
-
- 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).
- */
-
-
// Safeguard against situations where process() goes haywire when autopunching
// and last_recordable_frame < first_recordable_frame
last_recordable_frame = max_framepos;
}
- 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 (record_enabled()) {
- if (rec_nframes && !was_recording) {
- capture_captured = 0;
- was_recording = true;
- }
+ 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_sources.empty()) {
_last_capture_sources.clear ();
string region_name;
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;
+
+ DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
+ _name, (*ci)->start, (*ci)->frames, region_name));
try {
}
}
- if (portname.find_first_of (':') != string::npos) {
- if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
- /* not an ardour: port */
- return 0;
- }
- }
+ if (!port_is_mine (portname)) {
+ /* not an ardour port */
+ return 0;
+ }
std::string const rel = make_port_name_relative (portname);
}
string
-AudioEngine::make_port_name_relative (string portname)
+AudioEngine::make_port_name_relative (string portname) const
{
string::size_type len;
string::size_type n;
}
string
-AudioEngine::make_port_name_non_relative (string portname)
+AudioEngine::make_port_name_non_relative (string portname) const
{
string str;
return str;
}
+bool
+AudioEngine::port_is_mine (const string& portname) const
+{
+ if (portname.find_first_of (':') != string::npos) {
+ if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
+ return false;
+ }
+ }
+ return true;
+}
+
bool
AudioEngine::is_realtime () const
{
, _no_outs_cuz_we_no_monitor (false)
, _mute_master (mm)
, no_panner_reset (false)
+ , scnt (0)
{
_panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable));
_display_to_user = false;
, _no_outs_cuz_we_no_monitor (false)
, _mute_master (mm)
, no_panner_reset (false)
+ , scnt (0)
{
_panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable));
_display_to_user = false;
panner = _panshell->panner();
+#if 0
+ if (_session.transport_rolling()) {
+ cerr << name() << " first value written : " << scnt << endl;
+ for (BufferSet::audio_iterator b = bufs.audio_begin(); b != bufs.audio_end(); ++b) {
+ Sample* p = b->data ();
+ float s = (float) scnt;
+ for (pframes_t n = 0; n < nframes; ++n) {
+ p[n] = s * 0.001;
+ s += 1.0;
+ }
+ }
+ scnt += nframes;
+ }
+#endif
+
if (panner && !panner->bypassed()) {
// Use the panner to distribute audio to output port buffers
return;
}
- /* we transitioned to recording. lets see if its transport based or a punch */
-
- first_recordable_frame = transport_frame + _capture_offset;
- last_recordable_frame = max_framepos;
capture_start_frame = _session.transport_frame();
+ first_recordable_frame = capture_start_frame + _capture_offset;
+ last_recordable_frame = max_framepos;
- /* in theory, we should be offsetting by _session.worst_playback_latency() when we adjust
- for ExistingMaterial alignment. But that number includes the worst processor latency
- across all routes, and each track will already be roll-delay adjusted to handle that.
- so don't use worst_playback_latency(), just worst_output_latency() which covers
- only downstream latency from IO ports.
- */
-
- DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 basic FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8\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_frame, last_recordable_frame, capture_start_frame,
_capture_offset,
existing_material_offset,
transport_frame,
- _roll_delay));
+ _roll_delay,
+ _session.transport_frame(),
+ _session.worst_output_latency(),
+ _session.worst_track_latency()));
+
if (_alignment_style == ExistingMaterial) {
first_recordable_frame += existing_material_offset;
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift FRF by EMO %1\n",
first_recordable_frame));
- } else {
- capture_start_frame += _roll_delay;
- DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift CFS by roll delay of %1 to %2\n",
- _roll_delay, capture_start_frame));
- }
+ }
prepare_record_status (capture_start_frame);
} else {
/* punch out */
- last_recordable_frame = transport_frame + _capture_offset;
+ last_recordable_frame = _session.transport_frame() + _capture_offset;
if (_alignment_style == ExistingMaterial) {
last_recordable_frame += existing_material_offset;
- } else {
- last_recordable_frame += _roll_delay;
- }
+ }
}
}
}
rec_offset = first_recordable_frame - transport_frame;
break;
}
+
+ DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n",
+ _name, enum_2_string (ot), transport_frame, nframes,
+ first_recordable_frame, last_recordable_frame, rec_nframes, rec_offset));
}
void
drop_threads ();
}
+#if 0
+ /* XXX this only makes sense when we can use just the AudioEngine thread
+ and still keep the graph current with the route list
+ */
if (num_threads <= 1) {
/* no point creating 1 thread - the AudioEngine already gives us one
*/
return;
}
-
+#endif
if (AudioEngine::instance()->create_process_thread (boost::bind (&Graph::main_thread, this), &a_thread, 100000) == 0) {
_thread_list.push_back (a_thread);
}
for (PortSet::const_iterator i = _ports.begin(); i != _ports.end(); ++i) {
if ((latency = i->private_latency_range (_direction == Output).max) > max_latency) {
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("port %1 has %2 latency of %3 - use\n",
+ name(),
+ ((_direction == Output) ? "PLAYBACK" : "CAPTURE"),
+ latency));
max_latency = latency;
}
}
for (vector<string>::const_iterator c = connections.begin();
c != connections.end(); ++c) {
- jack_port_t* remote_port = jack_port_by_name (_engine->jack(), (*c).c_str());
- jack_latency_range_t lr;
-
- if (remote_port) {
- jack_port_get_latency_range (
- remote_port,
- (playback ? JackPlaybackLatency : JackCaptureLatency),
- &lr);
-
- DEBUG_TRACE (DEBUG::Latency, string_compose (
- "\t%1 <-> %2 : latter has latency range %3 .. %4\n",
- name(), *c, lr.min, lr.max));
- range.min = min (range.min, lr.min);
- range.max = max (range.max, lr.max);
- }
+ jack_latency_range_t lr;
+
+ if (!AudioEngine::instance()->port_is_mine (*c)) {
+
+ /* port belongs to some other JACK client, use
+ * JACK to lookup its latency information.
+ */
+
+ jack_port_t* remote_port = jack_port_by_name (_engine->jack(), (*c).c_str());
+
+ if (remote_port) {
+ jack_port_get_latency_range (
+ remote_port,
+ (playback ? JackPlaybackLatency : JackCaptureLatency),
+ &lr);
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "\t%1 <-> %2 : latter has latency range %3 .. %4\n",
+ name(), *c, lr.min, lr.max));
+
+ range.min = min (range.min, lr.min);
+ range.max = max (range.max, lr.max);
+ }
+
+ } else {
+
+ /* port belongs to this instance of ardour,
+ so look up its latency information
+ internally, because our published/public
+ values already contain our plugin
+ latency compensation.
+ */
+
+ Port* remote_port = AudioEngine::instance()->get_port_by_name (*c);
+ if (remote_port) {
+ lr = remote_port->private_latency_range ((playback ? JackPlaybackLatency : JackCaptureLatency));
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "\t%1 <-LOCAL-> %2 : latter has latency range %3 .. %4\n",
+ name(), *c, lr.min, lr.max));
+
+ range.min = min (range.min, lr.min);
+ range.max = max (range.max, lr.max);
+ }
+ }
}
} else {
struct RouteSorter {
/** @return true to run r1 before r2, otherwise false */
+ bool sort_by_rec_enabled (const boost::shared_ptr<Route>& r1, const boost::shared_ptr<Route>& r2) {
+ if (r1->record_enabled()) {
+ if (r2->record_enabled()) {
+ /* both rec-enabled, just use signal order */
+ return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ } else {
+ /* r1 rec-enabled, r2 not rec-enabled, run r2 early */
+ return false;
+ }
+ } else {
+ if (r2->record_enabled()) {
+ /* r2 rec-enabled, r1 not rec-enabled, run r1 early */
+ return true;
+ } else {
+ /* neither rec-enabled, use signal order */
+ return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ }
+ }
+ }
+
bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
if (r2->feeds (r1)) {
/* r1 fed by r2; run r2 early */
} else {
if (r1->not_fed ()) {
if (r2->not_fed ()) {
- /* no ardour-based connections inbound to either route. just use signal order */
- return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ /* no ardour-based connections inbound to either route. */
+ return sort_by_rec_enabled (r1, r2);
} else {
/* r2 has connections, r1 does not; run r1 early */
return true;
failed:
if (!new_routes.empty()) {
- add_routes (new_routes, true, false);
- save_state (_current_snapshot_name);
+ add_routes (new_routes, true, true);
}
return ret;
projects / ardour.git / commitdiff