#include "pbd/stacktrace.h"
#include "pbd/file_utils.h"
#include "pbd/convert.h"
-#include "pbd/strsplit.h"
#include "pbd/unwind.h"
+#include "pbd/search_path.h"
#include "ardour/amp.h"
#include "ardour/analyser.h"
, _step_editors (0)
, _suspend_timecode_transmission (0)
, _speakers (new Speakers)
+ , _order_hint (0)
, ignore_route_processor_changes (false)
, _midi_ports (0)
, _mmc (0)
throw failed_constructor ();
}
+ /* if a mix template was provided, then ::create() will
+ * have copied it into the session and we need to load it
+ * so that we have the state ready for ::set_state()
+ * after the engine is started.
+ *
+ * Note that we do NOT try to get the sample rate from
+ * the template at this time, though doing so would
+ * be easy if we decided this was an appropriate part
+ * of a template.
+ */
+
+ if (!mix_template.empty() && load_state (_current_snapshot_name)) {
+ throw failed_constructor ();
+ }
+
} else {
if (load_state (_current_snapshot_name)) {
}
routes.flush ();
- DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
- for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
- DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
- i->second->drop_references ();
- }
+ {
+ DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
+ Glib::Threads::Mutex::Lock lm (source_lock);
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
+ i->second->drop_references ();
+ }
- sources.clear ();
+ sources.clear ();
+ }
DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
{
XMLNode* child = 0;
- _ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
- _ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
+ _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
+ _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
- if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
+ if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
_ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
} else {
{
reconnect_ltc_input ();
}
- if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
+ if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
_ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
} else {
{
* IO style of NAME/TYPE-{in,out}N
*/
- _ltc_input->nth (0)->set_name (_("LTC-in"));
- _ltc_output->nth (0)->set_name (_("LTC-out"));
+ _ltc_input->nth (0)->set_name (X_("LTC-in"));
+ _ltc_output->nth (0)->set_name (X_("LTC-out"));
}
void
Session::setup_click ()
{
- XMLNode* child = 0;
-
_clicking = false;
- _click_io.reset (new ClickIO (*this, "click"));
+ _click_io.reset (new ClickIO (*this, X_("Click")));
_click_gain.reset (new Amp (*this));
_click_gain->activate ();
+ if (state_tree) {
+ setup_click_state (state_tree->root());
+ } else {
+ setup_click_state (0);
+ }
+}
+
+void
+Session::setup_click_state (const XMLNode* node)
+{
+ const XMLNode* child = 0;
- if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
+ if (node && (child = find_named_node (*node, "Click")) != 0) {
/* existing state for Click */
int c = 0;
/* force reversion to Solo-In-Place */
Config->set_solo_control_is_listen_control (false);
+ /* if we are auditioning, cancel it ... this is a workaround
+ to a problem (auditioning does not execute the process graph,
+ which is needed to remove routes when using >1 core for processing)
+ */
+ cancel_audition ();
+
{
/* Hold process lock while doing this so that we don't hear bits and
* pieces of audio as we work on each route.
remove_route (_monitor_out);
auto_connect_master_bus ();
+
+ if (auditioner) {
+ auditioner->connect ();
+ }
}
void
(*x)->enable_monitor_send ();
}
}
+
+ if (auditioner) {
+ auditioner->connect ();
+ }
}
void
DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
- (*i)->name(), (*i)->order_key (MixerSort)));
+ (*i)->name(), (*i)->order_key ()));
}
#endif
for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
string port;
- if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
+ if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
- } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
+ } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
/* master bus is audio only */
if (_master_out && _master_out->n_inputs().get(*t) > 0) {
port = _master_out->input()->ports().port(*t,
ChanCount existing_outputs;
uint32_t order = next_control_id();
+ if (_order_hint != 0) {
+ order = _order_hint;
+ _order_hint = 0;
+ }
+
count_existing_track_channels (existing_inputs, existing_outputs);
{
ID in most situations.
*/
- if (!r->has_order_key (EditorSort)) {
+ if (!r->has_order_key ()) {
if (r->is_auditioner()) {
/* use an arbitrarily high value */
- r->set_order_key (EditorSort, UINT_MAX);
- r->set_order_key (MixerSort, UINT_MAX);
+ r->set_order_key (UINT_MAX);
} else {
DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
- r->set_order_key (EditorSort, order);
- r->set_order_key (MixerSort, order);
+ r->set_order_key (order);
order++;
}
}
if (b->is_monitor()) {
return false;
}
- return a->order_key (MixerSort) < b->order_key (MixerSort);
+ return a->order_key () < b->order_key ();
}
bool
}
}
-string
+std::vector<std::string>
Session::source_search_path (DataType type) const
{
- vector<string> s;
+ Searchpath sp;
if (session_dirs.size() == 1) {
switch (type) {
case DataType::AUDIO:
- s.push_back (_session_dir->sound_path());
+ sp.push_back (_session_dir->sound_path());
break;
case DataType::MIDI:
- s.push_back (_session_dir->midi_path());
+ sp.push_back (_session_dir->midi_path());
break;
}
} else {
SessionDirectory sdir (i->path);
switch (type) {
case DataType::AUDIO:
- s.push_back (sdir.sound_path());
+ sp.push_back (sdir.sound_path());
break;
case DataType::MIDI:
- s.push_back (sdir.midi_path());
+ sp.push_back (sdir.midi_path());
break;
}
}
if (type == DataType::AUDIO) {
const string sound_path_2X = _session_dir->sound_path_2X();
if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
- if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
- s.push_back (sound_path_2X);
+ if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
+ sp.push_back (sound_path_2X);
}
}
}
- /* now check the explicit (possibly user-specified) search path
- */
-
- vector<string> dirs;
+ // now check the explicit (possibly user-specified) search path
switch (type) {
case DataType::AUDIO:
- split (config.get_audio_search_path (), dirs, ':');
+ sp += Searchpath(config.get_audio_search_path ());
break;
case DataType::MIDI:
- split (config.get_midi_search_path (), dirs, ':');
+ sp += Searchpath(config.get_midi_search_path ());
break;
}
- for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
- if (find (s.begin(), s.end(), *i) == s.end()) {
- s.push_back (*i);
- }
- }
-
- string search_path;
-
- for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
- if (!search_path.empty()) {
- search_path += ':';
- }
- search_path += *si;
- }
-
- return search_path;
+ return sp;
}
void
Session::ensure_search_path_includes (const string& path, DataType type)
{
- string search_path;
- vector<string> dirs;
+ Searchpath sp;
if (path == ".") {
return;
switch (type) {
case DataType::AUDIO:
- search_path = config.get_audio_search_path ();
+ sp += Searchpath(config.get_audio_search_path ());
break;
case DataType::MIDI:
- search_path = config.get_midi_search_path ();
+ sp += Searchpath (config.get_midi_search_path ());
break;
}
- split (search_path, dirs, ':');
-
- for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
+ for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
/* No need to add this new directory if it has the same inode as
an existing one; checking inode rather than name prevents duplicated
directories when we are using symlinks.
}
}
- if (!search_path.empty()) {
- search_path += ':';
- }
-
- search_path += path;
+ sp += path;
switch (type) {
case DataType::AUDIO:
- config.set_audio_search_path (search_path);
+ config.set_audio_search_path (sp.to_string());
break;
case DataType::MIDI:
- config.set_midi_search_path (search_path);
+ config.set_midi_search_path (sp.to_string());
break;
}
}
}
switch (Config->get_remote_model()) {
- case MixerSort:
- case EditorSort:
+ case MixerOrdered:
Route::RemoteControlIDChange (); /* EMIT SIGNAL */
break;
default:
}
void
-Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
+Session::sync_order_keys ()
{
if (deletion_in_progress()) {
return;
opportunity to keep them in sync if they wish to.
*/
- DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
+ DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
- Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
+ Route::SyncOrderKeys (); /* EMIT SIGNAL */
DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
}
projects / ardour.git / blobdiff