keyboard->set_state (*node, Stateful::loading_state_version);
}
- /* we don't like certain modifiers */
- Bindings::set_ignored_state (GDK_LOCK_MASK|GDK_MOD2_MASK|GDK_MOD3_MASK);
+ /* we don't like certain modifiers */
+ Bindings::set_ignored_state (GDK_LOCK_MASK|GDK_MOD2_MASK|GDK_MOD3_MASK);
reset_dpi();
}
setup_clock ();
- speaker_config_window->set (new SpeakerDialog);
+ speaker_config_window->set (new SpeakerDialog);
starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
-
MessageDialog msg (
- string_compose (_("WARNING: Your system has a limit for maximum amount of locked memory. "
- "This might cause %1 to run out of memory before your system "
- "runs out of memory. \n\n"
- "You can view the memory limit with 'ulimit -l', "
- "and it is normally controlled by /etc/security/limits.conf"),
- PROGRAM_NAME).c_str());
-
+ string_compose (
+ _("WARNING: Your system has a limit for maximum amount of locked memory. "
+ "This might cause %1 to run out of memory before your system "
+ "runs out of memory. \n\n"
+ "You can view the memory limit with 'ulimit -l', "
+ "and it is normally controlled by /etc/security/limits.conf"),
+ PROGRAM_NAME).c_str());
+
VBox* vbox = msg.get_vbox();
HBox hbox;
CheckButton cb (_("Do not show this window again"));
{
if (engine) {
if (!engine->connected()) {
- MessageDialog msg (string_compose (_("%1 is not connected to JACK\n"
- "You cannot open or close sessions in this condition"),
- PROGRAM_NAME));
+ MessageDialog msg (string_compose (
+ _("%1 is not connected to JACK\n"
+ "You cannot open or close sessions in this condition"),
+ PROGRAM_NAME));
pop_back_splash ();
msg.run ();
return false;
char timebuf[128];
time_t n;
struct tm local_time;
-
+
time (&n);
localtime_r (&n, &local_time);
strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
}
/// @todo some minor tweaks.
-
+
bus_profile.output_ac = AutoConnectOption (0);
if (_startup->connect_outputs ()) {
/* absolute path or cwd-relative path specified for session name: infer session folder
from what was given.
*/
-
+
session_path = Glib::path_get_dirname (session_name);
session_name = Glib::path_get_basename (session_name);
session_path = _startup->session_folder();
if (session_name.find ('/') != string::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '/' character"));
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
}
-
+
if (session_name.find ('\\') != string::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '\\' character"));
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
}
if (session_name.find ('/') != std::string::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '/' character"));
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '/' character"));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
}
if (session_name.find ('\\') != std::string::npos) {
- MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
- "session names may not contain a '\\' character"));
+ MessageDialog msg (*_startup,
+ _("To ensure compatibility with various systems\n"
+ "session names may not contain a '\\' character"));
msg.run ();
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
continue;
catch (...) {
- MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"),path, snap_name),
+ MessageDialog msg (string_compose(
+ _("Session \"%1 (snapshot %2)\" did not load successfully"),
+ path, snap_name),
true,
Gtk::MESSAGE_INFO,
BUTTONS_OK);
if (rep.space < 1000) {
bprefix = X_("");
space_adjusted = rep.space;
- } else if (rep.space < 1000000) {
- bprefix = X_("kilo");
+ } else if (rep.space < 1000000) {
+ bprefix = X_("kilo");
space_adjusted = truncf((float)rep.space / 1000.0);
} else if (rep.space < 1000000 * 1000) {
bprefix = X_("mega");
results.run ();
-}
+}
void
ARDOUR_UI::cleanup ()
if (!have_disk_speed_dialog_displayed) {
have_disk_speed_dialog_displayed = true;
- MessageDialog* msg = new MessageDialog (*editor,
- string_compose (_("The disk system on your computer\n\
+ MessageDialog* msg = new MessageDialog (
+ *editor, string_compose (_("The disk system on your computer\n\
was not able to keep up with %1.\n\
\n\
Specifically, it failed to read data from disk\n\
ARDOUR_UI::toggle_translations ()
{
using namespace Glib;
-
+
RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("EnableTranslation"));
if (act) {
RefPtr<ToggleAction> ract = RefPtr<ToggleAction>::cast_dynamic (act);
if (ract) {
-
+
string i18n_killer = ARDOUR::translation_kill_path();
-
+
bool already_enabled = !ARDOUR::translations_are_disabled ();
-
+
if (ract->get_active ()) {
/* we don't care about errors */
int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644);
/* we don't care about errors */
unlink (i18n_killer.c_str());
}
-
+
if (already_enabled != ract->get_active()) {
MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"),
false,
}
}
}
-}
+}
/** Add a window proxy to our list, so that its state will be saved.
* This call also causes the window to be created and opened if its
remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
}
}
-
+
get_input_sources ();
set_capture_offset ();
- set_align_style_from_io ();
-
+ set_align_style_from_io ();
+
input_change_pending = IOChange::NoChange;
/* implicit unlock */
connections.clear ();
- cerr << "Getting Nth connection from io " << n << " = " << _io->nth(n) << endl;
+ cerr << "Getting Nth connection from io " << n << " = " << _io->nth(n) << endl;
if (_io->nth (n)->get_connections (connections) == 0) {
- cerr << "\tThere were NO connections, apparently ...\n";
+ cerr << "\tThere were NO connections, apparently ...\n";
if ((*chan)->source) {
// _source->disable_metering ();
}
(*chan)->source = 0;
} else {
- cerr << "\tThere were some connections, apparently ... to " << connections[0] << endl;
+ cerr << "\tThere were some connections, apparently ... to " << connections[0] << endl;
(*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
}
}
framecnt_t rec_nframes = 0;
bool collect_playback = false;
- playback_distance = 0;
+ playback_distance = 0;
if (!_io || !_io->active()) {
return 0;
return 0;
}
- Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
- if (!sm.locked()) {
+ if (!sm.locked()) {
return 1;
}
(*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
+ /* two conditions to test for here:
- 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).
- */
+ 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
+ // Safeguard against situations where process() goes haywire when autopunching
+ // and last_recordable_frame < first_recordable_frame
+
+ if (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);
- if (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);
- calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
-
- if (rec_nframes && !was_recording) {
- capture_captured = 0;
- was_recording = true;
- }
+ if (rec_nframes && !was_recording) {
+ capture_captured = 0;
+ was_recording = true;
+ }
if (can_record && !_last_capture_sources.empty()) {
_last_capture_sources.clear ();
ret = 0;
- if (commit (nframes)) {
- need_butler = true;
- }
+ if (commit (nframes)) {
+ need_butler = true;
+ }
out:
return ret;
// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
- _playlist->clear_changes ();
+ _playlist->clear_changes ();
_playlist->freeze ();
for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
{
was_recording = false;
- first_recordable_frame = max_framepos;
- last_recordable_frame = max_framepos;
+ first_recordable_frame = max_framepos;
+ last_recordable_frame = max_framepos;
if (capture_captured == 0) {
return;
boost::shared_ptr<ChannelList> c = channels.reader();
snprintf (buf, sizeof(buf), "%zd", c->size());
node.add_property ("channels", buf);
-
+
if (!capturing_sources.empty() && _session.get_record_enabled()) {
XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
}
}
- if (Diskstream::set_state (node, version)) {
- return -1;
- }
+ if (Diskstream::set_state (node, version)) {
+ return -1;
+ }
if ((prop = node.property ("channels")) != 0) {
nchans = atoi (prop->value().c_str());
}
-
- if (!destructive() && capture_pending_node) {
- /* destructive streams have one and only one source per channel,
- and so they never end up in pending capture in any useful
- sense.
- */
- use_pending_capture_data (*capture_pending_node);
- }
+
+ if (!destructive() && capture_pending_node) {
+ /* destructive streams have one and only one source per channel,
+ and so they never end up in pending capture in any useful
+ sense.
+ */
+ use_pending_capture_data (*capture_pending_node);
+ }
in_set_state = false;
ChannelInfo* chan = (*c)[n];
try {
- if ((chan->write_source = _session.create_audio_source_for_session (n_channels().n_audio(),
- name(), n, destructive())) == 0) {
+ if ((chan->write_source = _session.create_audio_source_for_session (
+ n_channels().n_audio(), name(), n, destructive())) == 0) {
throw failed_constructor();
}
}
list<boost::shared_ptr<Source> >
AudioDiskstream::steal_write_sources()
{
- /* not possible to steal audio write sources */
- list<boost::shared_ptr<Source> > ret;
- return ret;
+ /* not possible to steal audio write sources */
+ list<boost::shared_ptr<Source> > ret;
+ return ret;
}
void
(*chan)->write_source->done_with_peakfile_writes ();
}
- if ((*chan)->write_source->removable()) {
- (*chan)->write_source->mark_for_remove ();
- (*chan)->write_source->drop_references ();
- }
+ if ((*chan)->write_source->removable()) {
+ (*chan)->write_source->mark_for_remove ();
+ (*chan)->write_source->drop_references ();
+ }
- (*chan)->write_source.reset ();
- }
+ (*chan)->write_source.reset ();
+ }
use_new_write_source (n);
{
bool have_physical = false;
- if (_alignment_choice != Automatic) {
- return;
- }
+ if (_alignment_choice != Automatic) {
+ return;
+ }
if (_io == 0) {
return;
boost::shared_ptr<ChannelList> c = channels.reader();
- cerr << "Checking " << c->size() << " for physical connections\n";
+ cerr << "Checking " << c->size() << " for physical connections\n";
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- cerr << "Channel connected via " << (*chan)->source << endl;
+ cerr << "Channel connected via " << (*chan)->source << endl;
if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
- cerr << "\tchannel has physical connection to " << (*chan)->source->name() << endl;
+ cerr << "\tchannel has physical connection to " << (*chan)->source->name() << endl;
have_physical = true;
break;
}
}
- cerr << "\tphysical? " << have_physical << endl;
+ cerr << "\tphysical? " << have_physical << endl;
if (have_physical) {
set_align_style (ExistingMaterial);
AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
{
while (how_many--) {
- c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_playback_buffer_size(),
- _session.butler()->audio_diskstream_capture_buffer_size(),
- speed_buffer_size, wrap_buffer_size));
- interpolation.add_channel_to (_session.butler()->audio_diskstream_playback_buffer_size(), speed_buffer_size);
+ c->push_back (new ChannelInfo(
+ _session.butler()->audio_diskstream_playback_buffer_size(),
+ _session.butler()->audio_diskstream_capture_buffer_size(),
+ speed_buffer_size, wrap_buffer_size));
+ interpolation.add_channel_to (
+ _session.butler()->audio_diskstream_playback_buffer_size(),
+ speed_buffer_size);
}
_n_channels.set(DataType::AUDIO, c->size());
try {
fs = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, _session,
- prop->value(), string(), false, _session.frame_rate()));
+ SourceFactory::createWritable (
+ DataType::AUDIO, _session,
+ prop->value(), string(), false, _session.frame_rate()));
}
catch (failed_constructor& err) {
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
- }
+ (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
+ }
}
void
boost::shared_ptr<ChannelList> c = channels.reader();
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
- (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
- }
+ (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
+ }
}
AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
void
AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
{
- delete playback_buf;
+ delete playback_buf;
playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
}
void
AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
{
- delete capture_buf;
+ delete capture_buf;
capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
AudioDiskstream::ChannelInfo::~ChannelInfo ()
{
- write_source.reset ();
+ write_source.reset ();
delete [] speed_buffer;
speed_buffer = 0;
using namespace PBD;
AudioEngine* Port::_engine = 0;
-bool Port::_connecting_blocked = false;
-pframes_t Port::_global_port_buffer_offset = 0;
-pframes_t Port::_cycle_nframes = 0;
+bool Port::_connecting_blocked = false;
+pframes_t Port::_global_port_buffer_offset = 0;
+pframes_t Port::_cycle_nframes = 0;
/** @param n Port short name */
Port::Port (std::string const & n, DataType t, Flags f)
, _flags (f)
, _last_monitor (false)
{
- _private_playback_latency.min = 0;
- _private_playback_latency.max = 0;
- _private_capture_latency.min = 0;
- _private_capture_latency.max = 0;
-
- /* Unfortunately we have to pass the DataType into this constructor so that we can
- create the right kind of JACK port; aside from this we'll use the virtual function type ()
- to establish type.
+ _private_playback_latency.min = 0;
+ _private_playback_latency.max = 0;
+ _private_capture_latency.min = 0;
+ _private_capture_latency.max = 0;
+
+ /* Unfortunately we have to pass the DataType into this constructor so that
+ we can create the right kind of JACK port; aside from this we'll use the
+ virtual function type () to establish type.
*/
assert (_name.find_first_of (':') == std::string::npos);
}
if ((_jack_port = jack_port_register (_engine->jack (), _name.c_str (), t.to_jack_type (), _flags, 0)) == 0) {
- cerr << "Failed to register JACK port, reason is unknown from here\n";
+ cerr << "Failed to register JACK port, reason is unknown from here\n";
throw failed_constructor ();
}
}
bool
Port::connected_to (std::string const & o) const
{
- if (!_engine->connected()) {
- /* in some senses, this answer isn't the right one all the time,
- because we know about our connections and will re-establish
- them when we reconnect to JACK.
- */
- return false;
- }
-
- return jack_port_connected_to (_jack_port, _engine->make_port_name_non_relative(o).c_str ());
+ if (!_engine->connected()) {
+ /* in some senses, this answer isn't the right one all the time,
+ because we know about our connections and will re-establish
+ them when we reconnect to JACK.
+ */
+ return false;
+ }
+
+ return jack_port_connected_to (_jack_port,
+ _engine->make_port_name_non_relative(o).c_str ());
}
/** @param o Filled in with port full names of ports that we are connected to */
{
int n = 0;
- if (_engine->connected()) {
- const char** jc = jack_port_get_connections (_jack_port);
- if (jc) {
- for (int i = 0; jc[i]; ++i) {
- c.push_back (jc[i]);
- ++n;
- }
+ if (_engine->connected()) {
+ const char** jc = jack_port_get_connections (_jack_port);
+ if (jc) {
+ for (int i = 0; jc[i]; ++i) {
+ c.push_back (jc[i]);
+ ++n;
+ }
- jack_free (jc);
- }
- }
+ jack_free (jc);
+ }
+ }
return n;
}
_connections.erase (other);
}
- return r;
+ return r;
}
void
Port::set_public_latency_range (jack_latency_range_t& range, bool playback) const
{
- /* this sets the visible latency that the rest of JACK sees. because we do latency
- compensation, all (most) of our visible port latency values are identical.
- */
+ /* this sets the visible latency that the rest of JACK sees. because we do latency
+ compensation, all (most) of our visible port latency values are identical.
+ */
- if (!jack_port_set_latency_range) {
- return;
- }
+ if (!jack_port_set_latency_range) {
+ return;
+ }
- DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 %4 PUBLIC latency now [%2 - %3]\n", name(),
- range.min,
- range.max,
- (playback ? "PLAYBACK" : "CAPTURE")));;
-
- jack_port_set_latency_range (_jack_port, (playback ? JackPlaybackLatency : JackCaptureLatency), &range);
+ DEBUG_TRACE (DEBUG::Latency,
+ string_compose ("SET PORT %1 %4 PUBLIC latency now [%2 - %3]\n",
+ name(), range.min, range.max,
+ (playback ? "PLAYBACK" : "CAPTURE")));;
+
+ jack_port_set_latency_range (_jack_port,
+ (playback ? JackPlaybackLatency : JackCaptureLatency),
+ &range);
}
void
Port::set_private_latency_range (jack_latency_range_t& range, bool playback)
{
- if (playback) {
- _private_playback_latency = range;
- DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 playback PRIVATE latency now [%2 - %3]\n", name(),
- _private_playback_latency.min,
- _private_playback_latency.max));
- } else {
- _private_capture_latency = range;
- DEBUG_TRACE (DEBUG::Latency, string_compose ("SET PORT %1 capture PRIVATE latency now [%2 - %3]\n", name(),
- _private_capture_latency.min,
- _private_capture_latency.max));
- }
-
- /* push to public (JACK) location so that everyone else can see it */
-
- set_public_latency_range (range, playback);
+ if (playback) {
+ _private_playback_latency = range;
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "SET PORT %1 playback PRIVATE latency now [%2 - %3]\n",
+ name(),
+ _private_playback_latency.min,
+ _private_playback_latency.max));
+ } else {
+ _private_capture_latency = range;
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "SET PORT %1 capture PRIVATE latency now [%2 - %3]\n",
+ name(),
+ _private_capture_latency.min,
+ _private_capture_latency.max));
+ }
+
+ /* push to public (JACK) location so that everyone else can see it */
+
+ set_public_latency_range (range, playback);
}
const jack_latency_range_t&
Port::private_latency_range (bool playback) const
{
- if (playback) {
- DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1 playback PRIVATE latency now [%2 - %3]\n", name(),
- _private_playback_latency.min,
- _private_playback_latency.max));
- return _private_playback_latency;
- } else {
- DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1 capture PRIVATE latency now [%2 - %3]\n", name(),
- _private_playback_latency.min,
- _private_playback_latency.max));
- return _private_capture_latency;
- }
+ if (playback) {
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "GET PORT %1 playback PRIVATE latency now [%2 - %3]\n",
+ name(),
+ _private_playback_latency.min,
+ _private_playback_latency.max));
+ return _private_playback_latency;
+ } else {
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "GET PORT %1 capture PRIVATE latency now [%2 - %3]\n",
+ name(),
+ _private_playback_latency.min,
+ _private_playback_latency.max));
+ return _private_capture_latency;
+ }
}
jack_latency_range_t
Port::public_latency_range (bool playback) const
{
- jack_latency_range_t r;
-
- jack_port_get_latency_range (_jack_port,
- sends_output() ? JackPlaybackLatency : JackCaptureLatency,
- &r);
- DEBUG_TRACE (DEBUG::Latency, string_compose ("GET PORT %1: %4 PUBLIC latency range %2 .. %3\n",
- name(), r.min, r.max,
- sends_output() ? "PLAYBACK" : "CAPTURE"));
- return r;
+ jack_latency_range_t r;
+
+ jack_port_get_latency_range (_jack_port,
+ sends_output() ? JackPlaybackLatency : JackCaptureLatency,
+ &r);
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "GET PORT %1: %4 PUBLIC latency range %2 .. %3\n",
+ name(), r.min, r.max,
+ sends_output() ? "PLAYBACK" : "CAPTURE"));
+ return r;
}
void
Port::get_connected_latency_range (jack_latency_range_t& range, bool playback) const
{
- if (!jack_port_get_latency_range) {
- return;
- }
+ if (!jack_port_get_latency_range) {
+ return;
+ }
- vector<string> connections;
- jack_client_t* jack = _engine->jack();
+ vector<string> connections;
+ jack_client_t* jack = _engine->jack();
- if (!jack) {
- range.min = 0;
- range.max = 0;
- PBD::warning << _("get_connected_latency_range() called while disconnected from JACK") << endmsg;
- return;
- }
+ if (!jack) {
+ range.min = 0;
+ range.max = 0;
+ PBD::warning << _("get_connected_latency_range() called while disconnected from JACK") << endmsg;
+ return;
+ }
- get_connections (connections);
+ get_connections (connections);
- if (!connections.empty()) {
+ if (!connections.empty()) {
- range.min = ~((jack_nframes_t) 0);
- range.max = 0;
-
- for (vector<string>::iterator c = connections.begin(); c != connections.end(); ++c) {
-
- cerr << "Connection between " << name() << " and " << *c << endl;
-
- 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);
- } else {
- cerr << "\t NO PORT BY NAME!\n";
- }
- }
-
- } else {
+ range.min = ~((jack_nframes_t) 0);
+ range.max = 0;
+
+ for (vector<string>::const_iterator c = connections.begin();
+ c != connections.end(); ++c) {
+
+ cerr << "Connection between " << name() << " and " << *c << endl;
+
+ 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);
+ } else {
+ cerr << "\t NO PORT BY NAME!\n";
+ }
+ }
- range.min = 0;
- range.max = 0;
- }
+ } else {
+ range.min = 0;
+ range.max = 0;
+ }
}
int
if (jc) {
for (int i = 0; jc[i]; ++i) {
- jack_port_t* port = jack_port_by_name (_engine->jack(), jc[i]);
+ jack_port_t* port = jack_port_by_name (_engine->jack(), jc[i]);
- if (port && (jack_port_flags (port) & JackPortIsPhysical)) {
- jack_free (jc);
- return true;
- }
+ if (port && (jack_port_flags (port) & JackPortIsPhysical)) {
+ jack_free (jc);
+ return true;
+ }
}
jack_free (jc);
}
- return false;
+ return false;
}
: SessionObject (sess, name)
, Automatable (sess)
, GraphNode( sess.route_graph )
- , _active (true)
- , _signal_latency (0)
- , _initial_delay (0)
- , _roll_delay (0)
+ , _active (true)
+ , _signal_latency (0)
+ , _initial_delay (0)
+ , _roll_delay (0)
, _flags (flg)
- , _pending_declick (true)
- , _meter_point (MeterPostFader)
- , _self_solo (false)
- , _soloed_by_others_upstream (0)
- , _soloed_by_others_downstream (0)
- , _solo_isolated (0)
- , _denormal_protection (false)
- , _recordable (true)
- , _silent (false)
- , _declickable (false)
+ , _pending_declick (true)
+ , _meter_point (MeterPostFader)
+ , _self_solo (false)
+ , _soloed_by_others_upstream (0)
+ , _soloed_by_others_downstream (0)
+ , _solo_isolated (0)
+ , _denormal_protection (false)
+ , _recordable (true)
+ , _silent (false)
+ , _declickable (false)
, _mute_master (new MuteMaster (sess, name))
- , _have_internal_generator (false)
- , _solo_safe (false)
+ , _have_internal_generator (false)
+ , _solo_safe (false)
, _default_type (default_type)
- , _remote_control_id (0)
- , _in_configure_processors (false)
+ , _remote_control_id (0)
+ , _in_configure_processors (false)
{
processor_max_streams.reset();
order_keys[N_("signal")] = order_key_cnt++;
int
Route::init ()
{
- /* add standard controls */
+ /* add standard controls */
_solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
_mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
add_control (_solo_control);
add_control (_mute_control);
- /* panning */
-
+ /* panning */
+
Pannable* p = new Pannable (_session);
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
boost_debug_shared_ptr_mark_interesting (p, "Pannable");
#endif
- _pannable.reset (p);
+ _pannable.reset (p);
/* input and output objects */
_intreturn.reset (new InternalReturn (_session));
_intreturn->activate ();
- /* the thing that provides proper control over a control/monitor/listen bus
- (such as per-channel cut, dim, solo, invert, etc).
- */
- _monitor_control.reset (new MonitorProcessor (_session));
+ /* the thing that provides proper control over a control/monitor/listen bus
+ (such as per-channel cut, dim, solo, invert, etc).
+ */
+ _monitor_control.reset (new MonitorProcessor (_session));
_monitor_control->activate ();
}
- if (is_master() || is_monitor() || is_hidden()) {
- _mute_master->set_solo_ignore (true);
- }
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
/* now that we have _meter, its safe to connect to this */
configure_processors (0);
}
- return 0;
+ return 0;
}
Route::~Route ()
void
Route::maybe_declick (BufferSet&, framecnt_t, int)
{
- /* this is the "bus" implementation and they never declick.
- */
- return;
+ /* this is the "bus" implementation and they never declick.
+ */
+ return;
}
/** Process this route for one (sub) cycle (process thread)
bufs.is_silent (false);
/* figure out if we're going to use gain automation */
- if (gain_automation_ok) {
- _amp->setup_gain_automation (start_frame, end_frame, nframes);
- } else {
- _amp->apply_gain_automation (false);
- }
-
+ if (gain_automation_ok) {
+ _amp->setup_gain_automation (start_frame, end_frame, nframes);
+ } else {
+ _amp->apply_gain_automation (false);
+ }
+
/* tell main outs what to do about monitoring */
_main_outs->no_outs_cuz_we_no_monitor (!monitor);
GLOBAL DECLICK (for transport changes etc.)
----------------------------------------------------------------------------------------- */
- maybe_declick (bufs, nframes, declick);
+ maybe_declick (bufs, nframes, declick);
_pending_declick = 0;
/* -------------------------------------------------------------------------------------------
}
#ifndef NDEBUG
- /* if it has any inputs, make sure they match */
- if ((*i)->input_streams() != ChanCount::ZERO) {
- if (bufs.count() != (*i)->input_streams()) {
- cerr << _name << " bufs = " << bufs.count()
- << " input for " << (*i)->name() << " = " << (*i)->input_streams()
- << endl;
- abort ();
- }
- }
+ /* if it has any inputs, make sure they match */
+ if ((*i)->input_streams() != ChanCount::ZERO) {
+ if (bufs.count() != (*i)->input_streams()) {
+ cerr << _name << " bufs = " << bufs.count()
+ << " input for " << (*i)->name() << " = " << (*i)->input_streams()
+ << endl;
+ abort ();
+ }
+ }
#endif
- /* should we NOT run plugins here if the route is inactive?
- do we catch route != active somewhere higher?
- */
+ /* should we NOT run plugins here if the route is inactive?
+ do we catch route != active somewhere higher?
+ */
- (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
+ (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
bufs.set_count ((*i)->output_streams());
}
}
void
Route::set_listen (bool yn, void* src)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
if (_monitor_send) {
if (yn != _monitor_send->active()) {
if (yn) {
_monitor_send->activate ();
- _mute_master->set_soloed (true);
- } else {
+ _mute_master->set_soloed (true);
+ } else {
_monitor_send->deactivate ();
- _mute_master->set_soloed (false);
+ _mute_master->set_soloed (false);
}
listen_changed (src); /* EMIT SIGNAL */
if (self_soloed() != yn) {
set_self_solo (yn);
- set_mute_master_solo ();
+ set_mute_master_solo ();
solo_changed (true, src); /* EMIT SIGNAL */
_solo_control->Changed (); /* EMIT SIGNAL */
}
void
Route::set_self_solo (bool yn)
{
- _self_solo = yn;
+ _self_solo = yn;
}
void
Route::mod_solo_by_others_upstream (int32_t delta)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
- uint32_t old_sbu = _soloed_by_others_upstream;
+ uint32_t old_sbu = _soloed_by_others_upstream;
if (delta < 0) {
if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
_soloed_by_others_upstream += delta;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
- name(), delta, _soloed_by_others_upstream, old_sbu,
- _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
-
- /* push the inverse solo change to everything that feeds us.
-
- This is important for solo-within-group. When we solo 1 track out of N that
- feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
- on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
- tracks that feed it. This will silence them if they were audible because
- of a bus solo, but the newly soloed track will still be audible (because
- it is self-soloed).
-
- but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
- not in reverse.
- */
-
- if ((_self_solo || _soloed_by_others_downstream) &&
- ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
- (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
-
- if (delta > 0 || !Config->get_exclusive_solo()) {
- DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
- for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
- boost::shared_ptr<Route> sr = i->r.lock();
- if (sr) {
- sr->mod_solo_by_others_downstream (-delta);
- }
- }
- }
- }
-
- set_mute_master_solo ();
- solo_changed (false, this);
+ DEBUG_TRACE (DEBUG::Solo, string_compose (
+ "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
+ name(), delta, _soloed_by_others_upstream, old_sbu,
+ _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
+
+ /* push the inverse solo change to everything that feeds us.
+
+ This is important for solo-within-group. When we solo 1 track out of N that
+ feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
+ on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
+ tracks that feed it. This will silence them if they were audible because
+ of a bus solo, but the newly soloed track will still be audible (because
+ it is self-soloed).
+
+ but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
+ not in reverse.
+ */
+
+ if ((_self_solo || _soloed_by_others_downstream) &&
+ ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
+ (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
+
+ if (delta > 0 || !Config->get_exclusive_solo()) {
+ DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
+ for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
+ boost::shared_ptr<Route> sr = i->r.lock();
+ if (sr) {
+ sr->mod_solo_by_others_downstream (-delta);
+ }
+ }
+ }
+ }
+
+ set_mute_master_solo ();
+ solo_changed (false, this);
}
void
Route::mod_solo_by_others_downstream (int32_t delta)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
- if (delta < 0) {
+ if (delta < 0) {
if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
_soloed_by_others_downstream += delta;
} else {
_soloed_by_others_downstream += delta;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
- set_mute_master_solo ();
- solo_changed (false, this);
+ set_mute_master_solo ();
+ solo_changed (false, this);
}
void
Route::set_mute_master_solo ()
{
- _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
+ _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
}
void
for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
- continue;
- }
+ continue;
+ }
bool sends_only;
bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
}
}
- /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
+ /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
- bool changed = false;
+ bool changed = false;
if (yn) {
- if (_solo_isolated == 0) {
- _mute_master->set_solo_ignore (true);
- changed = true;
- }
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (true);
+ changed = true;
+ }
_solo_isolated++;
} else {
if (_solo_isolated > 0) {
_solo_isolated--;
- if (_solo_isolated == 0) {
- _mute_master->set_solo_ignore (false);
- changed = true;
- }
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (false);
+ changed = true;
+ }
}
}
- if (changed) {
- solo_isolated_changed (src);
- }
+ if (changed) {
+ solo_isolated_changed (src);
+ }
}
bool
void
Route::set_mute_points (MuteMaster::MutePoint mp)
{
- _mute_master->set_mute_points (mp);
- mute_points_changed (); /* EMIT SIGNAL */
-
- if (_mute_master->muted_by_self()) {
- mute_changed (this); /* EMIT SIGNAL */
+ _mute_master->set_mute_points (mp);
+ mute_points_changed (); /* EMIT SIGNAL */
+
+ if (_mute_master->muted_by_self()) {
+ mute_changed (this); /* EMIT SIGNAL */
_mute_control->Changed (); /* EMIT SIGNAL */
- }
+ }
}
void
}
if (muted() != yn) {
- _mute_master->set_muted_by_self (yn);
+ _mute_master->set_muted_by_self (yn);
mute_changed (src); /* EMIT SIGNAL */
_mute_control->Changed (); /* EMIT SIGNAL */
}
bool
Route::muted () const
{
- return _mute_master->muted_by_self();
+ return _mute_master->muted_by_self();
}
#if 0
assert (processor != _meter);
assert (processor != _main_outs);
- DEBUG_TRACE (DEBUG::Processors, string_compose ("%1 adding processor %2\n", name(), processor->name()));
+ DEBUG_TRACE (DEBUG::Processors, string_compose (
+ "%1 adding processor %2\n", name(), processor->name()));
ChanCount old_pms = processor_max_streams;
return false;
}
- if (processor->set_state (node, version)) {
- return false;
- }
+ if (processor->set_state (node, version)) {
+ return false;
+ }
return (add_processor (processor, placement) == 0);
}
(*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
}
-
+
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
ChanCount
Route::input_streams () const
{
- return _input->n_ports ();
+ return _input->n_ports ();
}
list<pair<ChanCount, ChanCount> >
}
}
- /* now remove from old order - its taken care of no matter what */
+ /* now remove from old order - its taken care of no matter what */
oiter = _processors.erase (oiter);
}
cmt->add_content (_comment);
}
- node->add_child_nocopy (_pannable->state (full_state));
+ node->add_child_nocopy (_pannable->state (full_state));
for (i = _processors.begin(); i != _processors.end(); ++i) {
node->add_child_nocopy((*i)->state (full_state));
_flags = Flag (0);
}
- if (is_master() || is_monitor() || is_hidden()) {
- _mute_master->set_solo_ignore (true);
- }
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
/* add all processors (except amp, which is always present) */
}
- if (child->name() == X_("Pannable")) {
- _pannable->set_state (*child, version);
- }
+ if (child->name() == X_("Pannable")) {
+ _pannable->set_state (*child, version);
+ }
}
set_processor_state (processor_state);
if ((prop = node.property (X_("meter-point"))) != 0) {
MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
- set_meter_point (mp, true);
+ set_meter_point (mp, true);
if (_meter) {
_meter->set_display_to_user (_meter_point == MeterCustom);
}
_solo_control->set_state (*child, version);
} else if (prop->value() == X_("mute")) {
_mute_control->set_state (*child, version);
- }
-
+ }
+
} else if (child->name() == X_("RemoteControl")) {
if ((prop = child->property (X_("id"))) != 0) {
int32_t x;
{
const XMLNodeList &nlist = node.children();
XMLNodeConstIterator niter;
- ProcessorList new_order;
- bool must_configure = false;
+ ProcessorList new_order;
+ bool must_configure = false;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
XMLProperty* prop = (*niter)->property ("type");
if (prop->value() == "amp") {
- _amp->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_amp);
- } else if (prop->value() == "meter") {
- _meter->set_state (**niter, Stateful::current_state_version);
- } else if (prop->value() == "main-outs") {
- _main_outs->set_state (**niter, Stateful::current_state_version);
- } else if (prop->value() == "intreturn") {
- if (!_intreturn) {
- _intreturn.reset (new InternalReturn (_session));
- must_configure = true;
- }
- _intreturn->set_state (**niter, Stateful::current_state_version);
- } else if (is_monitor() && prop->value() == "monitor") {
- if (!_monitor_control) {
- _monitor_control.reset (new MonitorProcessor (_session));
- must_configure = true;
- }
- _monitor_control->set_state (**niter, Stateful::current_state_version);
+ _amp->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_amp);
+ } else if (prop->value() == "meter") {
+ _meter->set_state (**niter, Stateful::current_state_version);
+ } else if (prop->value() == "main-outs") {
+ _main_outs->set_state (**niter, Stateful::current_state_version);
+ } else if (prop->value() == "intreturn") {
+ if (!_intreturn) {
+ _intreturn.reset (new InternalReturn (_session));
+ must_configure = true;
+ }
+ _intreturn->set_state (**niter, Stateful::current_state_version);
+ } else if (is_monitor() && prop->value() == "monitor") {
+ if (!_monitor_control) {
+ _monitor_control.reset (new MonitorProcessor (_session));
+ must_configure = true;
+ }
+ _monitor_control->set_state (**niter, Stateful::current_state_version);
} else if (prop->value() == "capture") {
_capturing_processor.reset (new CapturingProcessor (_session));
- } else {
- ProcessorList::iterator o;
+ } else {
+ ProcessorList::iterator o;
for (o = _processors.begin(); o != _processors.end(); ++o) {
XMLProperty* id_prop = (*niter)->property(X_("id"));
if (id_prop && (*o)->id() == id_prop->value()) {
- (*o)->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (*o);
+ (*o)->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (*o);
break;
}
}
- // If the processor (*niter) is not on the route then create it
-
- if (o == _processors.end()) {
-
-
boost::shared_ptr<Processor> processor;
-
- if (prop->value() == "intsend") {
-
- processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
- } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "vst" ||
- prop->value() == "audiounit") {
-
- processor.reset (new PluginInsert(_session));
-
- } else if (prop->value() == "port") {
-
- processor.reset (new PortInsert (_session, _pannable, _mute_master));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, _pannable, _mute_master));
-
- } else {
- error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
- continue;
- }
+ // If the processor (*niter) is not on the route then create it
+
+ if (o == _processors.end()) {
+
+ boost::shared_ptr<Processor> processor;
+
+ if (prop->value() == "intsend") {
+
+ processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
+ } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
+
+ processor.reset (new PluginInsert(_session));
+
+ } else if (prop->value() == "port") {
+
+ processor.reset (new PortInsert (_session, _pannable, _mute_master));
+
+ } else if (prop->value() == "send") {
+
+ processor.reset (new Send (_session, _pannable, _mute_master));
+
+ } else {
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
+ continue;
+ }
if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
/* This processor could not be configured. Turn it into a UnknownProcessor */
new_order.push_back (processor);
must_configure = true;
- }
- }
- }
+ }
+ }
+ }
{
Glib::RWLock::WriterLock lm (_processor_lock);
- _processors = new_order;
+ _processors = new_order;
- if (must_configure) {
+ if (must_configure) {
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- configure_processors_unlocked (0);
- }
+ configure_processors_unlocked (0);
+ }
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
boost::shared_ptr<PluginInsert> pi;
}
}
}
- }
+ }
- processors_changed (RouteProcessorChange ());
+ processors_changed (RouteProcessorChange ());
set_processor_positions ();
}
remove_processor (*x, &err);
rl.acquire ();
- /* list could have been demolished while we dropped the lock
+ /* list could have been demolished while we dropped the lock
so start over.
*/
bool
Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
{
- FeedRecord fr (other, via_sends_only);
+ FeedRecord fr (other, via_sends_only);
- pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
+ pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
- if (!result.second) {
+ if (!result.second) {
- /* already a record for "other" - make sure sends-only information is correct */
- if (!via_sends_only && result.first->sends_only) {
- FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
- frp->sends_only = false;
- }
- }
-
- return result.second;
+ /* already a record for "other" - make sure sends-only information is correct */
+ if (!via_sends_only && result.first->sends_only) {
+ FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
+ frp->sends_only = false;
+ }
+ }
+
+ return result.second;
}
void
Route::clear_fed_by ()
{
- _fed_by.clear ();
+ _fed_by.clear ();
}
bool
Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
{
- const FedBy& fed_by (other->fed_by());
+ const FedBy& fed_by (other->fed_by());
- for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
- boost::shared_ptr<Route> sr = f->r.lock();
+ for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
+ boost::shared_ptr<Route> sr = f->r.lock();
- if (sr && (sr.get() == this)) {
+ if (sr && (sr.get() == this)) {
- if (via_sends_only) {
- *via_sends_only = f->sends_only;
- }
+ if (via_sends_only) {
+ *via_sends_only = f->sends_only;
+ }
- return true;
- }
- }
+ return true;
+ }
+ }
- return false;
+ return false;
}
bool
Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
{
framepos_t now = _session.transport_frame();
-
+
{
Glib::RWLock::ReaderLock lm (_processor_lock);
automation_snapshot (now, true);
}
- Automatable::transport_stopped (now);
+ Automatable::transport_stopped (now);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
- (*i)->flush ();
+ (*i)->flush ();
}
-
+
(*i)->transport_stopped (now);
}
}
already there
*/
start.set (*i, start.get (*i) + 1);
-
+
_session.auto_connect_route (this, dummy, dummy, false, false, ChanCount(), change.before);
}
}
silence_unlocked (_roll_delay);
transport_frame += _roll_delay;
- /* shuffle all the port buffers for things that lead "out" of this Route
- to reflect that we just wrote _roll_delay frames of silence.
- */
+ /* shuffle all the port buffers for things that lead "out" of this Route
+ to reflect that we just wrote _roll_delay frames of silence.
+ */
- Glib::RWLock::ReaderLock lm (_processor_lock);
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
- if (iop) {
- iop->increment_port_buffer_offset (_roll_delay);
- }
- }
- _output->increment_port_buffer_offset (_roll_delay);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
+ if (iop) {
+ iop->increment_port_buffer_offset (_roll_delay);
+ }
+ }
+ _output->increment_port_buffer_offset (_roll_delay);
_roll_delay = 0;
Glib::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->flush ();
+ (*i)->flush ();
}
}
DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
if (_signal_latency != l) {
- _signal_latency = l;
+ _signal_latency = l;
signal_latency_changed (); /* EMIT SIGNAL */
}
_initial_delay = 0;
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: compensate for maximum latency of %2, given own latency of %3, using initial delay of %4\n",
- name(), longest_session_latency, _signal_latency, _initial_delay));
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "%1: compensate for maximum latency of %2,"
+ "given own latency of %3, using initial delay of %4\n",
+ name(), longest_session_latency, _signal_latency, _initial_delay));
if (_initial_delay != old) {
initial_delay_changed (); /* EMIT SIGNAL */
void
Route::automation_snapshot (framepos_t now, bool force)
{
- _pannable->automation_snapshot (now, force);
+ _pannable->automation_snapshot (now, force);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->automation_snapshot (now, force);
}
Route::shift (framepos_t pos, framecnt_t frames)
{
/* gain automation */
- {
-
boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
-
- XMLNode &before = gc->alist()->get_state ();
- gc->alist()->shift (pos, frames);
- XMLNode &after = gc->alist()->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
- }
+ {
+ boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
+
+ XMLNode &before = gc->alist()->get_state ();
+ gc->alist()->shift (pos, frames);
+ XMLNode &after = gc->alist()->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
+ }
/* pan automation */
- {
- ControlSet::Controls& c (_pannable->controls());
-
- for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
-
boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
- if (pc) {
-
boost::shared_ptr<AutomationList> al = pc->alist();
- XMLNode& before = al->get_state ();
- al->shift (pos, frames);
- XMLNode& after = al->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
- }
- }
- }
+ {
+ ControlSet::Controls& c (_pannable->controls());
+
+ for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
+ boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
+ if (pc) {
+ boost::shared_ptr<AutomationList> al = pc->alist();
+ XMLNode& before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode& after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
/* redirect automation */
{
set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
-
boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
- if (ac) {
-
boost::shared_ptr<AutomationList> al = ac->alist();
- XMLNode &before = al->get_state ();
- al->shift (pos, frames);
- XMLNode &after = al->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
- }
- }
- }
+ boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
+ if (ac) {
+ boost::shared_ptr<AutomationList> al = ac->alist();
+ XMLNode &before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode &after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
}
}
if (_phase_invert[c] != yn) {
_phase_invert[c] = yn;
phase_invert_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
+ _session.set_dirty ();
}
}
if (_phase_invert != p) {
_phase_invert = p;
phase_invert_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
+ _session.set_dirty ();
}
}
boost::shared_ptr<Panner>
Route::panner() const
{
- /* may be null ! */
+ /* may be null ! */
return _main_outs->panner_shell()->panner();
}
bool
Route::has_io_processor_named (const string& name)
{
- Glib::RWLock::ReaderLock lm (_processor_lock);
- ProcessorList::iterator i;
-
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- if (boost::dynamic_pointer_cast<Send> (*i) ||
-
boost::dynamic_pointer_cast<PortInsert> (*i)) {
- if ((*i)->name() == name) {
- return true;
- }
- }
- }
-
- return false;
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<Send> (*i) ||
+ boost::dynamic_pointer_cast<PortInsert> (*i)) {
+ if ((*i)->name() == name) {
+ return true;
+ }
+ }
+ }
+
+ return false;
}
MuteMaster::MutePoint
framecnt_t
Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
{
- /* we assume that all our input ports feed all our output ports. its not
- universally true, but the alternative is way too corner-case to worry about.
- */
-
- jack_latency_range_t all_connections;
-
- all_connections.min = ~((jack_nframes_t) 0);
- all_connections.max = 0;
-
- /* iterate over all "from" ports and determine the latency range for all of their
- connections to the "outside" (outside of this Route).
- */
-
- for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
-
- jack_latency_range_t range;
-
- p->get_connected_latency_range (range, playback);
-
- all_connections.min = min (all_connections.min, range.min);
- all_connections.max = max (all_connections.max, range.max);
- }
-
- /* set the "from" port latencies to the max/min range of all their connections */
-
- for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
- p->set_private_latency_range (all_connections, playback);
- }
-
- /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
-
- all_connections.min += our_latency;
- all_connections.max += our_latency;
-
- for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
- p->set_private_latency_range (all_connections, playback);
- }
-
- return all_connections.max;
+ /* we assume that all our input ports feed all our output ports. its not
+ universally true, but the alternative is way too corner-case to worry about.
+ */
+
+ jack_latency_range_t all_connections;
+
+ all_connections.min = ~((jack_nframes_t) 0);
+ all_connections.max = 0;
+
+ /* iterate over all "from" ports and determine the latency range for all of their
+ connections to the "outside" (outside of this Route).
+ */
+
+ for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
+
+ jack_latency_range_t range;
+
+ p->get_connected_latency_range (range, playback);
+
+ all_connections.min = min (all_connections.min, range.min);
+ all_connections.max = max (all_connections.max, range.max);
+ }
+
+ /* set the "from" port latencies to the max/min range of all their connections */
+
+ for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
+ p->set_private_latency_range (all_connections, playback);
+ }
+
+ /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
+
+ all_connections.min += our_latency;
+ all_connections.max += our_latency;
+
+ for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
+ p->set_private_latency_range (all_connections, playback);
+ }
+
+ return all_connections.max;
}
framecnt_t
{
framecnt_t own_latency = 0;
- /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR
- LATENCY CALLBACK.
+ /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
+ OR LATENCY CALLBACK.
- This is called (early) from the latency callback. It computes the REAL latency associated
- with each port and stores the result as the "private" latency of the port. A later
- call to Route::set_public_port_latencies() sets all ports to the same value to reflect
- the fact that we do latency compensation and so all signals are delayed by the
- same amount as they flow through ardour.
- */
+ This is called (early) from the latency callback. It computes the REAL
+ latency associated with each port and stores the result as the "private"
+ latency of the port. A later call to Route::set_public_port_latencies()
+ sets all ports to the same value to reflect the fact that we do latency
+ compensation and so all signals are delayed by the same amount as they
+ flow through ardour.
+ */
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->active ()) {
}
}
- if (playback) {
- /* playback: propagate latency from "outside the route" to outputs to inputs */
- return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
- } else {
- /* capture: propagate latency from "outside the route" to inputs to outputs */
- return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
- }
+ if (playback) {
+ /* playback: propagate latency from "outside the route" to outputs to inputs */
+ return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
+ } else {
+ /* capture: propagate latency from "outside the route" to inputs to outputs */
+ return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
+ }
}
void
Route::set_public_port_latencies (framecnt_t value, bool playback) const
{
- /* this is called to set the JACK-visible port latencies, which take latency compensation
- into account.
- */
+ /* this is called to set the JACK-visible port latencies, which take
+ latency compensation into account.
+ */
+
+ jack_latency_range_t range;
- jack_latency_range_t range;
+ range.min = value;
+ range.max = value;
- range.min = value;
- range.max = value;
-
- {
- const PortSet& ports (_input->ports());
- for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
- p->set_public_latency_range (range, playback);
- }
- }
+ {
+ const PortSet& ports (_input->ports());
+ for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
+ p->set_public_latency_range (range, playback);
+ }
+ }
- {
- const PortSet& ports (_output->ports());
- for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
- p->set_public_latency_range (range, playback);
- }
- }
+ {
+ const PortSet& ports (_output->ports());
+ for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
+ p->set_public_latency_range (range, playback);
+ }
+ }
}
/** Put the invisible processors in the right place in _processors.
Route::setup_invisible_processors ()
{
#ifndef NDEBUG
- Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
+ Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
assert (!lm.locked ());
#endif
- if (!_main_outs) {
- /* too early to be doing this stuff */
- return;
- }
+ if (!_main_outs) {
+ /* too early to be doing this stuff */
+ return;
+ }
/* we'll build this new list here and then use it */
new_processors.insert (amp, _meter);
break;
case MeterPostFader:
- /* do nothing here */
+ /* do nothing here */
break;
case MeterOutput:
- /* do nothing here */
+ /* do nothing here */
break;
case MeterCustom:
/* the meter is visible, so we don't touch it here */
/* MAIN OUTS */
- assert (_main_outs);
- assert (!_main_outs->display_to_user ());
- new_processors.push_back (_main_outs);
+ assert (_main_outs);
+ assert (!_main_outs->display_to_user ());
+ new_processors.push_back (_main_outs);
- /* iterator for the main outs */
-
- ProcessorList::iterator main = new_processors.end();
- --main;
+ /* iterator for the main outs */
- /* OUTPUT METERING */
+ ProcessorList::iterator main = new_processors.end();
+ --main;
- if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
- assert (!_meter->display_to_user ());
+ /* OUTPUT METERING */
- /* add the processor just before or just after the main outs */
-
- ProcessorList::iterator meter_point = main;
+ if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
+ assert (!_meter->display_to_user ());
- if (_meter_point == MeterOutput) {
- ++meter_point;
- }
- new_processors.insert (meter_point, _meter);
- }
+ /* add the processor just before or just after the main outs */
+
+ ProcessorList::iterator meter_point = main;
+
+ if (_meter_point == MeterOutput) {
+ ++meter_point;
+ }
+ new_processors.insert (meter_point, _meter);
+ }
/* MONITOR SEND */
if (_monitor_send && !is_monitor ()) {
assert (!_monitor_send->display_to_user ());
- if (Config->get_solo_control_is_listen_control()) {
- switch (Config->get_listen_position ()) {
- case PreFaderListen:
- switch (Config->get_pfl_position ()) {
- case PFLFromBeforeProcessors:
- new_processors.push_front (_monitor_send);
- break;
- case PFLFromAfterProcessors:
- new_processors.insert (amp, _monitor_send);
- break;
- }
- break;
- case AfterFaderListen:
- switch (Config->get_afl_position ()) {
- case AFLFromBeforeProcessors:
- new_processors.insert (after_amp, _monitor_send);
- break;
- case AFLFromAfterProcessors:
- new_processors.insert (new_processors.end(), _monitor_send);
- break;
- }
- break;
- }
- } else {
- new_processors.insert (new_processors.end(), _monitor_send);
- }
+ if (Config->get_solo_control_is_listen_control()) {
+ switch (Config->get_listen_position ()) {
+ case PreFaderListen:
+ switch (Config->get_pfl_position ()) {
+ case PFLFromBeforeProcessors:
+ new_processors.push_front (_monitor_send);
+ break;
+ case PFLFromAfterProcessors:
+ new_processors.insert (amp, _monitor_send);
+ break;
+ }
+ break;
+ case AfterFaderListen:
+ switch (Config->get_afl_position ()) {
+ case AFLFromBeforeProcessors:
+ new_processors.insert (after_amp, _monitor_send);
+ break;
+ case AFLFromAfterProcessors:
+ new_processors.insert (new_processors.end(), _monitor_send);
+ break;
+ }
+ break;
+ }
+ } else {
+ new_processors.insert (new_processors.end(), _monitor_send);
+ }
}
/* MONITOR CONTROL */
switch (Config->get_monitoring_model()) {
case HardwareMonitoring:
case ExternalMonitoring:
- return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
+ return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
break;
default:
- break;
+ break;
}
- return true;
+ return true;
}
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
Session::Session (AudioEngine &eng,
- const string& fullpath,
- const string& snapshot_name,
+ const string& fullpath,
+ const string& snapshot_name,
BusProfile* bus_profile,
- string mix_template)
- : _engine (eng)
+ string mix_template)
+ : _engine (eng)
, _target_transport_speed (0.0)
, _requested_return_frame (-1)
, _session_dir (new SessionDirectory(fullpath))
StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
- _is_new = false;
+ _is_new = false;
}
Session::~Session ()
_butler->drop_references ();
delete _butler;
delete midi_control_ui;
- delete _all_route_group;
+ delete _all_route_group;
if (click_data != default_click) {
delete [] click_data;
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
- boost::shared_ptr<Bundle> c (new Bundle (buf, true));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, outputs[DataType::AUDIO][np]);
char buf[32];
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
- boost::shared_ptr<Bundle> c (new Bundle (buf, false));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, inputs[DataType::AUDIO][np]);
char buf[32];
snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
- boost::shared_ptr<Bundle> c (new Bundle (buf, false));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, inputs[DataType::AUDIO][np]);
c->add_channel (_("R"), DataType::AUDIO);
string n = inputs[DataType::MIDI][np];
boost::erase_first (n, X_("alsa_pcm:"));
- boost::shared_ptr<Bundle> c (new Bundle (n, false));
+ boost::shared_ptr<Bundle> c (new Bundle (n, false));
c->add_channel ("", DataType::MIDI);
c->set_port (0, inputs[DataType::MIDI][np]);
add_bundle (c);
string n = outputs[DataType::MIDI][np];
boost::erase_first (n, X_("alsa_pcm:"));
- boost::shared_ptr<Bundle> c (new Bundle (n, true));
+ boost::shared_ptr<Bundle> c (new Bundle (n, true));
c->add_channel ("", DataType::MIDI);
c->set_port (0, outputs[DataType::MIDI][np]);
add_bundle (c);
if (_is_new && !no_auto_connect()) {
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
- /* don't connect the master bus outputs if there is a monitor bus */
+ /* don't connect the master bus outputs if there is a monitor bus */
if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
}
} else {
-
+
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
uint32_t mod = n_physical_outputs.get (*t);
uint32_t limit = _monitor_out->n_outputs().get(*t);
BootMessage (_("Connect to engine"));
_engine.set_session (this);
- update_latency_compensation (true);
+ update_latency_compensation (true);
}
void
Delivery::reset_panners ();
- /* Connect tracks to monitor/listen bus if there is one.
- Note that in an existing session, the internal sends will
- already exist, but we want the routes to notice that
- they connect to the control out specifically.
- */
+ /* Connect tracks to monitor/listen bus if there is one. Note that in an
+ existing session, the internal sends will already exist, but we want the
+ routes to notice that they connect to the control out specifically.
+ */
if (_monitor_out) {
boost::shared_ptr<RouteList> r = routes.reader ();
void
Session::set_track_monitor_input_status (bool yn)
{
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
-
boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
- if (tr && tr->record_enabled ()) {
- //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- tr->monitor_input (yn);
- }
- }
+ boost::shared_ptr<RouteList> rl = routes.reader ();
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
+ if (tr && tr->record_enabled ()) {
+ //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
+ tr->monitor_input (yn);
+ }
+ }
}
void
Session::reset_input_monitor_state ()
{
if (transport_rolling()) {
- set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
+ set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
} else {
- set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring);
+ set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring);
}
}
MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
- set_track_monitor_input_status (true);
+ set_track_monitor_input_status (true);
}
RecordStateChanged ();
}
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
- set_track_monitor_input_status (false);
+ set_track_monitor_input_status (false);
}
RecordStateChanged (); /* emit signal */
if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
- set_track_monitor_input_status (false);
+ set_track_monitor_input_status (false);
}
}
}
static void
trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
{
- boost::shared_ptr<Route> r2;
+ boost::shared_ptr<Route> r2;
if (r1->feeds (rbase) && rbase->feeds (r1)) {
info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> r = writer.get_copy ();
+ boost::shared_ptr<RouteList> r = writer.get_copy ();
resort_routes_using (r);
/* writer goes out of scope and forces update */
}
in = ChanCount::ZERO;
out = ChanCount::ZERO;
- boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
goto failed;
}
- boost::shared_ptr<MidiTrack> track;
+ boost::shared_ptr<MidiTrack> track;
try {
track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
Session::auto_connect_route (Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs,
bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
{
- if (!IO::connecting_legal) {
- return;
- }
+ if (!IO::connecting_legal) {
+ return;
+ }
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
- if (with_lock) {
- lm.acquire ();
- }
+ if (with_lock) {
+ lm.acquire ();
+ }
/* If both inputs and outputs are auto-connected to physical ports,
use the max of input and output offsets to ensure auto-connected
offset possible.
*/
- cerr << "ACR: existing in = " << existing_inputs << " out = " << existing_outputs << endl;
+ cerr << "ACR: existing in = " << existing_inputs << " out = " << existing_outputs << endl;
const bool in_out_physical =
- (Config->get_input_auto_connect() & AutoConnectPhysical)
+ (Config->get_input_auto_connect() & AutoConnectPhysical)
&& (Config->get_output_auto_connect() & AutoConnectPhysical)
&& connect_inputs;
if (!physinputs.empty() && connect_inputs) {
uint32_t nphysical_in = physinputs.size();
- cerr << "There are " << nphysical_in << " physical inputs of type " << *t << endl;
+ cerr << "There are " << nphysical_in << " physical inputs of type " << *t << endl;
for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
string port;
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- cerr << "Get index " << in_offset.get(*t) << " + " << i << " % " << nphysical_in << " = "
- << (in_offset.get(*t) + i) % nphysical_in
- << endl;
+ cerr << "Get index " << in_offset.get(*t) << " + " << i << " % " << nphysical_in << " = "
+ << (in_offset.get(*t) + i) % nphysical_in
+ << endl;
port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
}
- cerr << "Connect route " << route->name() << " IN to " << port << endl;
+ cerr << "Connect route " << route->name() << " IN to " << port << endl;
if (!port.empty() && route->input()->connect (
- route->input()->ports().port(*t, i), port, this)) {
+ route->input()->ports().port(*t, i), port, this)) {
break;
}
}
}
}
- cerr << "Connect route " << route->name() << " OUT to " << port << endl;
+ cerr << "Connect route " << route->name() << " OUT to " << port << endl;
if (!port.empty() && route->output()->connect (
route->output()->ports().port(*t, i), port, this)) {
goto failed;
}
-
boost::shared_ptr<AudioTrack> track;
+ boost::shared_ptr<AudioTrack> track;
try {
track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
RemoteModel m = Config->get_remote_model();
bool emit_signal = false;
- boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (MixerOrdered == m) {
Track::zero_diskstream_id_in_xml (node_copy);
try {
- boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
+ boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
if (route == 0) {
error << _("Session: cannot create track/bus from template description") << endmsg;
{
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> r = writer.get_copy ();
+ boost::shared_ptr<RouteList> r = writer.get_copy ();
r->insert (r->end(), new_routes.begin(), new_routes.end());
}
}
- if (auto_connect) {
+ if (auto_connect) {
- ChanCount existing_inputs;
- ChanCount existing_outputs;
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
- count_existing_route_channels (existing_inputs, existing_outputs);
+ count_existing_route_channels (existing_inputs, existing_outputs);
- auto_connect_route (r, existing_inputs, existing_outputs, true);
- }
- }
+ auto_connect_route (r, existing_inputs, existing_outputs, true);
+ }
+ }
if (_monitor_out && IO::connecting_legal) {
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> rs = writer.get_copy ();
+ boost::shared_ptr<RouteList> rs = writer.get_copy ();
rs->remove (route);
return;
}
- bool send_changed = false;
-
- if (route->solo_isolated()) {
- if (_solo_isolated_cnt == 0) {
- send_changed = true;
- }
- _solo_isolated_cnt++;
- } else if (_solo_isolated_cnt > 0) {
- _solo_isolated_cnt--;
- if (_solo_isolated_cnt == 0) {
- send_changed = true;
- }
- }
-
- if (send_changed) {
- IsolatedChanged (); /* EMIT SIGNAL */
- }
+ bool send_changed = false;
+
+ if (route->solo_isolated()) {
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ _solo_isolated_cnt++;
+ } else if (_solo_isolated_cnt > 0) {
+ _solo_isolated_cnt--;
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ }
+
+ if (send_changed) {
+ IsolatedChanged (); /* EMIT SIGNAL */
+ }
}
void
}
source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
- }
+ }
}
void
boost::shared_ptr<Speakers>
Session::get_speakers()
{
- return _speakers;
+ return _speakers;
}
list<string>
void
Session::update_latency (bool playback)
{
- DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
- if (_state_of_the_state & (InitialConnecting|Deletion)) {
- return;
- }
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
boost::shared_ptr<RouteList> r = routes.reader ();
- framecnt_t max_latency = 0;
+ framecnt_t max_latency = 0;
- if (playback) {
- /* reverse the list so that we work backwards from the last route to run to the first */
- reverse (r->begin(), r->end());
- }
+ if (playback) {
+ /* reverse the list so that we work backwards from the last route to run to the first */
+ reverse (r->begin(), r->end());
+ }
- /* compute actual latency values for the given direction and store them all in per-port
- structures. this will also publish the same values (to JACK) so that computation of latency
- for routes can consistently use public latency values.
- */
+ /* compute actual latency values for the given direction and store them all in per-port
+ structures. this will also publish the same values (to JACK) so that computation of latency
+ for routes can consistently use public latency values.
+ */
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
- }
+ max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
+ }
- if (playback) {
+ if (playback) {
- post_playback_latency ();
+ post_playback_latency ();
- /* because we latency compensate playback, our published playback latencies should
- be the same for all output ports - all material played back by ardour has
- the same latency, whether its caused by plugins or by latency compensation. since
- these may differ from the values computed above, reset all playback port latencies
- to the same value.
- */
-
- DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_public_port_latencies (max_latency, playback);
- }
+ /* because we latency compensate playback, our published playback latencies should
+ be the same for all output ports - all material played back by ardour has
+ the same latency, whether its caused by plugins or by latency compensation. since
+ these may differ from the values computed above, reset all playback port latencies
+ to the same value.
+ */
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_public_port_latencies (max_latency, playback);
+ }
- } else {
+ } else {
- post_capture_latency ();
- }
+ post_capture_latency ();
+ }
- DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
+ DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
}
void
Session::post_playback_latency ()
{
- set_worst_playback_latency ();
+ set_worst_playback_latency ();
- boost::shared_ptr<RouteList> r = routes.reader ();
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden() && ((*i)->active())) {
- _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
- }
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
+ _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
+ }
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_latency_compensation (_worst_track_latency);
- }
- }
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_latency_compensation (_worst_track_latency);
+ }
+ }
}
void
Session::post_capture_latency ()
{
- set_worst_capture_latency ();
+ set_worst_capture_latency ();
- /* reflect any changes in capture latencies into capture offsets
- */
+ /* reflect any changes in capture latencies into capture offsets
+ */
- boost::shared_ptr<RouteList> rl = routes.reader();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr) {
- tr->set_capture_offset ();
- }
- }
+ boost::shared_ptr<RouteList> rl = routes.reader();
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->set_capture_offset ();
+ }
+ }
}
void
Session::set_worst_io_latencies ()
{
- set_worst_playback_latency ();
- set_worst_capture_latency ();
+ set_worst_playback_latency ();
+ set_worst_capture_latency ();
}
void
Session::set_worst_playback_latency ()
{
- if (_state_of_the_state & (InitialConnecting|Deletion)) {
- return;
- }
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
- _worst_output_latency = 0;
+ _worst_output_latency = 0;
if (!_engine.connected()) {
return;
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
+ _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
}
void
Session::set_worst_capture_latency ()
{
- if (_state_of_the_state & (InitialConnecting|Deletion)) {
- return;
- }
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
- _worst_input_latency = 0;
+ _worst_input_latency = 0;
if (!_engine.connected()) {
return;
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
+ _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
}
DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
- _worst_track_latency = 0;
+ _worst_track_latency = 0;
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden() && ((*i)->active())) {
- framecnt_t tl;
- if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
- update_jack = true;
- }
- _worst_track_latency = max (tl, _worst_track_latency);
- }
- }
+ framecnt_t tl;
+ if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
+ update_jack = true;
+ }
+ _worst_track_latency = max (tl, _worst_track_latency);
+ }
+ }
- DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
- (update_jack ? "yes" : "no")));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
+ (update_jack ? "yes" : "no")));
if (force_whole_graph || update_jack) {
- /* trigger a full recompute of latency numbers for the graph.
- everything else that we need to do will be done in the latency
- callback.
- */
+ /* trigger a full recompute of latency numbers for the graph.
+ everything else that we need to do will be done in the latency
+ callback.
+ */
_engine.update_total_latencies ();
- return; // everything else will be done in the latency callback
+ return; // everything else will be done in the latency callback
}
past that point to pick up delayed input (and/or to delick)
*/
- if (worst_playback_latency() > current_block_size) {
- /* we rolled past the stop point to pick up data that had
- not yet arrived. move back to where the stop occured.
- */
- decrement_transport_position (current_block_size + (worst_playback_latency() - current_block_size));
- } else {
- decrement_transport_position (current_block_size);
- }
+ if (worst_playback_latency() > current_block_size) {
+ /* we rolled past the stop point to pick up data that had
+ not yet arrived. move back to where the stop occured.
+ */
+ decrement_transport_position (current_block_size + (worst_playback_latency() - current_block_size));
+ } else {
+ decrement_transport_position (current_block_size);
+ }
/* the duration change is not guaranteed to have happened, but is likely */
_clear_event_type (SessionEvent::RangeStop);
_clear_event_type (SessionEvent::RangeLocate);
- /* if we're going to clear loop state, then force disabling record BUT only if we're not doing latched rec-enable */
+ /* if we're going to clear loop state, then force disabling record BUT only if we're not doing latched rec-enable */
disable_record (true, (!Config->get_latched_record_enable() && clear_state));
-
+
reset_slave_state ();
_transport_speed = 0;
DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler transport work, todo = %1\n", enum_2_string (ptw)));
- if (ptw & PostTransportAdjustPlaybackBuffering) {
+ if (ptw & PostTransportAdjustPlaybackBuffering) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr) {
tr->adjust_playback_buffering ();
- /* and refill those buffers ... */
- tr->non_realtime_locate (_transport_frame);
+ /* and refill those buffers ... */
+ tr->non_realtime_locate (_transport_frame);
}
}
-
- }
- if (ptw & PostTransportAdjustCaptureBuffering) {
+ }
+
+ if (ptw & PostTransportAdjustCaptureBuffering) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr) {
tr->adjust_capture_buffering ();
}
}
- }
+ }
if (ptw & PostTransportCurveRealloc) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: DS stop\n"));
- if (abort && did_record) {
- /* no reason to save the session file when we remove sources
- */
- _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
- }
+ if (abort && did_record) {
+ /* no reason to save the session file when we remove sources
+ */
+ _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
+ }
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
}
}
- if (abort && did_record) {
- _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
- }
+ if (abort && did_record) {
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
+ }
boost::shared_ptr<RouteList> r = routes.reader ();
}
if (_engine.running()) {
- PostTransportWork ptw = post_transport_work ();
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ PostTransportWork ptw = post_transport_work ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
}
update_latency_compensation ();
if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
!(ptw & PostTransportLocate)) {
- /* no explicit locate queued */
+ /* no explicit locate queued */
bool do_locate = false;
send_full_time_code (_transport_frame);
- if (!dynamic_cast<MTC_Slave*>(_slave)) {
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
- send_mmc_locate (_transport_frame);
- }
+ if (!dynamic_cast<MTC_Slave*>(_slave)) {
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+ send_mmc_locate (_transport_frame);
+ }
if ((ptw & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
saved = true;
}
- /* always try to get rid of this */
+ /* always try to get rid of this */
- remove_pending_capture_state ();
+ remove_pending_capture_state ();
/* save the current state of things if appropriate */
}
if (yn && Config->get_seamless_loop() && synced_to_jack()) {
- warning << string_compose (_("Seamless looping cannot be supported while %1 is using JACK transport.\n"
- "Recommend changing the configured options"), PROGRAM_NAME)
+ warning << string_compose (
+ _("Seamless looping cannot be supported while %1 is using JACK transport.\n"
+ "Recommend changing the configured options"), PROGRAM_NAME)
<< endmsg;
return;
}
if (with_roll) {
/* switch from input if we're going to roll */
if (Config->get_monitoring_model() == HardwareMonitoring) {
- set_track_monitor_input_status (!config.get_auto_input());
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else {
/* otherwise we're going to stop, so do the opposite */
if (Config->get_monitoring_model() == HardwareMonitoring) {
- set_track_monitor_input_status (true);
+ set_track_monitor_input_status (true);
}
}
/* we are rolling and we want to stop */
if (Config->get_monitoring_model() == HardwareMonitoring) {
- set_track_monitor_input_status (true);
+ set_track_monitor_input_status (true);
}
if (synced_to_jack ()) {
/* we are stopped and we want to start rolling at speed 1 */
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
- set_track_monitor_input_status (false);
+ set_track_monitor_input_status (false);
}
if (synced_to_jack()) {
} else {
if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
- warning << string_compose (_("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
- PROGRAM_NAME)
+ warning << string_compose (
+ _("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
+ PROGRAM_NAME)
<< endmsg;
return;
}
if (tr) {
tr->prepare_to_stop (_transport_frame);
}
- }
+ }
/* we need to capture the audio that has still not yet been received by the system
at the time the stop is requested, so we have to roll past that time.
*/
SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
- _transport_frame + _worst_input_latency - current_block_size,
- 0, 0, abort);
+ _transport_frame + _worst_input_latency - current_block_size,
+ 0, 0, abort);
merge_event (ev);
transport_sub_state |= StopPendingCapture;
if ((transport_sub_state & PendingDeclickOut) == 0) {
- if (!(transport_sub_state & StopPendingCapture)) {
+ if (!(transport_sub_state & StopPendingCapture)) {
boost::shared_ptr<RouteList> rl = routes.reader();
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_frame);
}
- }
- }
-
+ }
+ }
+
transport_sub_state |= PendingDeclickOut;
/* we'll be called again after the declick */
pending_abort = abort;
if (tr) {
tr->realtime_set_speed (tr->speed(), true);
}
- (*i)->automation_snapshot (_transport_frame, true);
+ (*i)->automation_snapshot (_transport_frame, true);
}
- Timecode::Time time;
- timecode_time_subframes (_transport_frame, time);
- if (!dynamic_cast<MTC_Slave*>(_slave)) {
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
- }
+ Timecode::Time time;
+ timecode_time_subframes (_transport_frame, time);
+ if (!dynamic_cast<MTC_Slave*>(_slave)) {
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
+ }
TransportStateChange (); /* EMIT SIGNAL */
}
return;
}
- if (config.get_video_pullup() != 0.0f) {
- return;
- }
+ if (config.get_video_pullup() != 0.0f) {
+ return;
+ }
new_slave = new JACK_Slave (_engine.jack());
break;
bool
Session::maybe_stop (framepos_t limit)
{
- if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
- if (synced_to_jack () && config.get_jack_time_master ()) {
- _engine.transport_stop ();
- } else if (!synced_to_jack ()) {
- stop_transport ();
- }
- return true;
- }
- return false;
+ if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
+ if (synced_to_jack () && config.get_jack_time_master ()) {
+ _engine.transport_stop ();
+ } else if (!synced_to_jack ()) {
+ stop_transport ();
+ }
+ return true;
+ }
+ return false;
}
void
projects / ardour.git / commitdiff