using namespace ARDOUR;
using namespace PBD;
-
uint32_t Route::order_key_cnt = 0;
-
+sigc::signal<void> Route::SyncOrderKeys;
Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
: IO (sess, name, input_min, input_max, output_min, output_max, default_type),
_soloed = false;
_solo_safe = false;
_phase_invert = false;
+ _denormal_protection = false;
order_keys[strdup (N_("signal"))] = order_key_cnt++;
- _active = true;
_silent = false;
_meter_point = MeterPostFader;
_initial_delay = 0;
Route::set_order_key (const char* name, long n)
{
order_keys[strdup(name)] = n;
+
+ if (Config->get_sync_all_route_ordering()) {
+ for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
+ x->second = n;
+ }
+ }
+
_session.set_dirty ();
}
+void
+Route::sync_order_keys ()
+{
+ uint32_t key;
+
+ if (order_keys.empty()) {
+ return;
+ }
+
+ OrderKeys::iterator x = order_keys.begin();
+ key = x->second;
+ ++x;
+
+ for (; x != order_keys.end(); ++x) {
+ x->second = key;
+ }
+}
+
+string
+Route::ensure_track_or_route_name(string name, Session &session)
+{
+ string newname = name;
+
+ while (session.route_by_name (newname)!=NULL)
+ {
+ newname = bump_name_once (newname);
+ }
+
+ return newname;
+}
+
+
void
Route::inc_gain (gain_t fraction, void *src)
{
}
}
+ /* -----------------------------------------------------------------------------------------------------
+ DENORMAL CONTROL
+ -------------------------------------------------------------------------------------------------- */
+
+ if (_denormal_protection || Config->get_denormal_protection()) {
+
+ for (n = 0; n < nbufs; ++n) {
+ Sample *sp = bufs[n];
+
+ for (nframes_t nx = offset; nx < nframes + offset; ++nx) {
+ sp[nx] += 1.0e-27f;
+ }
+ }
+ }
+
+
/* ----------------------------------------------------------------------------------------------------
PRE-FADER REDIRECTS
-------------------------------------------------------------------------------------------------- */
} else {
- co->deliver_output (bufs, nbufs, nframes, offset);
+ co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
}
}
// OR recording
- // h/w monitoring not in use
+ // AND software monitoring required
- (!Config->get_monitoring_model() == HardwareMonitoring &&
-
- // AND software monitoring required
-
- Config->get_monitoring_model() == SoftwareMonitoring)) {
+ (Config->get_monitoring_model() == SoftwareMonitoring)) {
if (apply_gain_automation) {
(no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
) {
-
+
co->silence (nframes, offset);
} else {
if (_meter_point == MeterPostFader) {
reset_peak_meters ();
}
-
+
IO::silence (nframes, offset);
} else {
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPostFader)) {
-// cerr << "meter post" << endl;
if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
uint32_t no = n_outputs();
{
if (_phase_invert != yn) {
_phase_invert = yn;
+ // phase_invert_changed (src); /* EMIT SIGNAL */
+ }
+}
+
+void
+Route::set_denormal_protection (bool yn, void *src)
+{
+ if (_denormal_protection != yn) {
+ _denormal_protection = yn;
+ // denormal_protection_changed (src); /* EMIT SIGNAL */
}
- // phase_invert_changed (src); /* EMIT SIGNAL */
}
void
{
uint32_t old_rmo = redirect_max_outs;
+ assert (ports_legal);
+
if (!_session.engine().connected()) {
return 1;
}
{
uint32_t old_rmo = redirect_max_outs;
+ assert (ports_legal);
+
if (!_session.engine().connected()) {
return 1;
}
}
(*i).in = required_inputs;
- (*i).out = (*i).insert->compute_output_streams ((*i).cnt);
+
+ if (((*i).out = (*i).insert->compute_output_streams ((*i).cnt)) < 0) {
+ if (err_streams) {
+ *err_streams = required_inputs;
+ }
+ return -1;
+ }
required_inputs = (*i).out;
}
node->add_property("default-type", _default_type.to_string());
- node->add_property("active", _active?"yes":"no");
node->add_property("muted", _muted?"yes":"no");
node->add_property("soloed", _soloed?"yes":"no");
node->add_property("phase-invert", _phase_invert?"yes":"no");
+ node->add_property("denormal-protection", _denormal_protection?"yes":"no");
node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
if ((prop = node.property ("type")) != 0) {
boost::shared_ptr<Insert> insert;
+ bool have_insert = false;
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
-
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
+
insert.reset (new PluginInsert(_session, node));
+ have_insert = true;
} else if (prop->value() == "port") {
insert.reset (new PortInsert (_session, node));
+ have_insert = true;
} else {
error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
}
- add_redirect (insert, this);
+ if (have_insert) {
+ add_redirect (insert, this);
+ }
} else {
error << _("Insert XML node has no type property") << endmsg;
}
if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert(prop->value()=="yes"?true:false, this);
+ set_phase_invert (prop->value()=="yes"?true:false, this);
}
- if ((prop = node.property (X_("active"))) != 0) {
- set_active (prop->value() == "yes");
+ if ((prop = node.property (X_("denormal-protection"))) != 0) {
+ set_denormal_protection (prop->value()=="yes"?true:false, this);
}
if ((prop = node.property (X_("muted"))) != 0) {
break;
}
}
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter){
-
- child = *niter;
-
- if (child->name() == X_("Send")) {
-
-
- if (!IO::ports_legal) {
- deferred_state->add_child_copy (*child);
- } else {
- add_redirect_from_xml (*child);
- }
-
- } else if (child->name() == X_("Insert")) {
-
- if (!IO::ports_legal) {
-
- deferred_state->add_child_copy (*child);
+ XMLNodeList redirect_nodes;
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+
+ child = *niter;
+
+ if (child->name() == X_("Send") || child->name() == X_("Insert")) {
+ redirect_nodes.push_back(child);
+ }
+
+ }
+
+ _set_redirect_states (redirect_nodes);
- } else {
-
- add_redirect_from_xml (*child);
- }
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+ child = *niter;
+ // All redirects (sends and inserts) have been applied already
- } else if (child->name() == X_("Automation")) {
+ if (child->name() == X_("Automation")) {
if ((prop = child->property (X_("path"))) != 0) {
load_automation (prop->value());
return 0;
}
+void
+Route::_set_redirect_states(const XMLNodeList &nlist)
+{
+ XMLNodeConstIterator niter;
+ char buf[64];
+
+ RedirectList::iterator i, o;
+
+ if (!ports_legal) {
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ deferred_state->add_child_copy (**niter);
+ }
+
+ return;
+ }
+
+ // Iterate through existing redirects, remove those which are not in the state list
+ for (i = _redirects.begin(); i != _redirects.end(); ) {
+ RedirectList::iterator tmp = i;
+ ++tmp;
+
+ bool redirectInStateList = false;
+
+ (*i)->id().print (buf, sizeof (buf));
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+
+ if (strncmp (buf,(*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
+ redirectInStateList = true;
+ break;
+ }
+ }
+
+ if (!redirectInStateList) {
+ remove_redirect ( *i, this);
+ }
+
+
+ i = tmp;
+ }
+
+
+ // Iterate through state list and make sure all redirects are on the track and in the correct order,
+ // set the state of existing redirects according to the new state on the same go
+ i = _redirects.begin();
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
+
+ // Check whether the next redirect in the list
+ o = i;
+
+ while (o != _redirects.end()) {
+ (*o)->id().print (buf, sizeof (buf));
+ if ( strncmp(buf, (*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
+ break;
+ ++o;
+ }
+
+ if (o == _redirects.end()) {
+ // If the redirect (*niter) is not on the route, we need to create it
+ // and move it to the correct location
+
+ RedirectList::iterator prev_last = _redirects.end();
+ --prev_last; // We need this to check whether adding succeeded
+
+ add_redirect_from_xml (**niter);
+
+ RedirectList::iterator last = _redirects.end();
+ --last;
+
+ if (prev_last == last) {
+ warning << _name << ": could not fully restore state as some redirects were not possible to create" << endmsg;
+ continue;
+
+ }
+
+ boost::shared_ptr<Redirect> tmp = (*last);
+ // remove the redirect from the wrong location
+ _redirects.erase(last);
+ // insert the new redirect at the current location
+ _redirects.insert(i, tmp);
+
+ --i; // move pointer to the newly inserted redirect
+ continue;
+ }
+
+ // We found the redirect (*niter) on the route, first we must make sure the redirect
+ // is at the location provided in the XML state
+ if (i != o) {
+ boost::shared_ptr<Redirect> tmp = (*o);
+ // remove the old copy
+ _redirects.erase(o);
+ // insert the redirect at the correct location
+ _redirects.insert(i, tmp);
+
+ --i; // move pointer so it points to the right redirect
+ }
+
+ (*i)->set_state( (**niter) );
+ }
+
+ redirects_changed(this);
+}
+
void
Route::curve_reallocate ()
{
{
Glib::Mutex::Lock lm (control_outs_lock);
vector<string>::const_iterator i;
+ uint32_t limit;
if (_control_outs) {
delete _control_outs;
_control_outs = 0;
}
+
+ if (control() || master()) {
+ /* no control outs for these two special busses */
+ return 0;
+ }
if (ports.empty()) {
return 0;
have outputs. we track the changes in ::output_change_handler().
*/
- _control_outs->ensure_io (0, n_outputs(), true, this);
+ limit = n_outputs ();
+
+ if (_control_outs->ensure_io (0, limit, true, this)) {
+ return -1;
+ }
+
+ /* now connect to the named ports */
+
+ for (uint32_t n = 0; n < limit; ++n) {
+ if (_control_outs->connect_output (_control_outs->output (n), ports[n % ports.size()], this)) {
+ error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
+ return -1;
+ }
+ }
return 0;
}
return onoff;
}
-void
-Route::set_active (bool yn)
-{
- _active = yn;
- active_changed(); /* EMIT SIGNAL */
-}
-
void
Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
{
projects / ardour.git / blobdiff