along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
#include <algorithm>
#include <pbd/pathscanner.h>
#include <pbd/pthread_utils.h>
#include <pbd/strsplit.h>
+#include <pbd/stacktrace.h>
+#include <pbd/copyfile.h>
#include <ardour/audioengine.h>
#include <ardour/configuration.h>
#include <ardour/utils.h>
#include <ardour/audioplaylist.h>
#include <ardour/audiofilesource.h>
-#include <ardour/destructive_filesource.h>
+#include <ardour/silentfilesource.h>
+#include <ardour/sndfilesource.h>
#include <ardour/sndfile_helpers.h>
#include <ardour/auditioner.h>
#include <ardour/export.h>
#include <ardour/control_protocol_manager.h>
#include <ardour/region_factory.h>
#include <ardour/source_factory.h>
+#include <ardour/playlist_factory.h>
#include <control_protocol/control_protocol.h>
Session::first_stage_init (string fullpath, string snapshot_name)
{
if (fullpath.length() == 0) {
+ destroy ();
throw failed_constructor();
}
char buf[PATH_MAX+1];
if (!realpath (fullpath.c_str(), buf) && (errno != ENOENT)) {
error << string_compose(_("Could not use path %1 (%s)"), buf, strerror(errno)) << endmsg;
+ destroy ();
throw failed_constructor();
}
insert_cnt = 0;
_transport_speed = 0;
_last_transport_speed = 0;
+ auto_play_legal = false;
transport_sub_state = 0;
_transport_frame = 0;
last_stop_frame = 0;
_worst_output_latency = 0;
_worst_input_latency = 0;
_worst_track_latency = 0;
- _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
+ _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading|Deletion);
_slave = 0;
butler_mixdown_buffer = 0;
butler_gain_buffer = 0;
current_trans = 0;
first_file_data_format_reset = true;
first_file_header_format_reset = true;
+ butler_thread = (pthread_t) 0;
+ midi_thread = (pthread_t) 0;
AudioDiskstream::allocate_working_buffers();
RegionFactory::CheckNewRegion.connect (mem_fun (*this, &Session::add_region));
SourceFactory::SourceCreated.connect (mem_fun (*this, &Session::add_source));
- Playlist::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
+ PlaylistFactory::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
Redirect::RedirectCreated.connect (mem_fun (*this, &Session::add_redirect));
NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
_engine.Halted.connect (mem_fun (*this, &Session::engine_halted));
_engine.Xrun.connect (mem_fun (*this, &Session::xrun_recovery));
- if (_engine.running()) {
+ try {
when_engine_running();
- } else {
- first_time_running = _engine.Running.connect (mem_fun (*this, &Session::when_engine_running));
+ }
+
+ /* handle this one in a different way than all others, so that its clear what happened */
+
+ catch (AudioEngine::PortRegistrationFailure& err) {
+ error << _("Unable to create all required ports")
+ << endmsg;
+ return -1;
+ }
+
+ catch (...) {
+ return -1;
}
send_full_time_code ();
if (fspath[fspath.length()-1] != '/') {
fspath += '/';
}
+
fspath += sound_dir (false);
AudioFileSource::set_search_path (fspath);
return -1;
}
- dir = sound_dir ();
+ /* if this is is an existing session with an old "sounds" directory, just use it. see Session::sound_dir() for more details */
- if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
- return -1;
+ if (!Glib::file_test (old_sound_dir(), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
+
+ dir = sound_dir ();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
}
dir = dead_sound_dir ();
return -1;
}
- dir = automation_dir ();
+ dir = export_dir ();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session automation dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create session export dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
return 0;
}
+void
+Session::maybe_write_autosave()
+{
+ if (dirty() && record_status() != Recording) {
+ save_state("", true);
+ }
+}
+
void
Session::remove_pending_capture_state ()
{
unlink (xml_path.c_str());
}
+/** Rename a state file.
+ * @param snapshot_name Snapshot name.
+ */
+void
+Session::rename_state (string old_name, string new_name)
+{
+ if (old_name == _current_snapshot_name || old_name == _name) {
+ /* refuse to rename the current snapshot or the "main" one */
+ return;
+ }
+
+ const string old_xml_path = _path + old_name + _statefile_suffix;
+ const string new_xml_path = _path + new_name + _statefile_suffix;
+
+ if (rename (old_xml_path.c_str(), new_xml_path.c_str()) != 0) {
+ error << string_compose(_("could not rename snapshot %1 to %2"), old_name, new_name) << endmsg;
+ }
+}
+
+/** Remove a state file.
+ * @param snapshot_name Snapshot name.
+ */
+void
+Session::remove_state (string snapshot_name)
+{
+ if (snapshot_name == _current_snapshot_name || snapshot_name == _name) {
+ /* refuse to remove the current snapshot or the "main" one */
+ return;
+ }
+
+ const string xml_path = _path + snapshot_name + _statefile_suffix;
+
+ /* make a backup copy of the state file */
+ const string bak_path = xml_path + ".bak";
+ if (g_file_test (xml_path.c_str(), G_FILE_TEST_EXISTS)) {
+ copy_file (xml_path, bak_path);
+ }
+
+ /* and delete it */
+ unlink (xml_path.c_str());
+}
+
int
Session::save_state (string snapshot_name, bool pending)
{
return 1;
}
+ if (!_engine.connected ()) {
+ error << _("Ardour's audio engine is not connected and state saving would lose all I/O connections. Session not saved")
+ << endmsg;
+ return 1;
+ }
+
tree.set_root (&get_state());
if (snapshot_name.empty()) {
if (!pending) {
+ /* proper save: use _statefile_suffix (.ardour in English) */
xml_path = _path;
xml_path += snapshot_name;
xml_path += _statefile_suffix;
+
+ /* make a backup copy of the old file */
bak_path = xml_path;
bak_path += ".bak";
- // Make backup of state file
-
- if ((access (xml_path.c_str(), F_OK) == 0) &&
- (rename(xml_path.c_str(), bak_path.c_str()))) {
- error << _("could not backup old state file, current state not saved.") << endmsg;
- return -1;
+ if (g_file_test (xml_path.c_str(), G_FILE_TEST_EXISTS)) {
+ copy_file (xml_path, bak_path);
}
} else {
+ /* pending save: use _pending_suffix (.pending in English) */
xml_path = _path;
xml_path += snapshot_name;
xml_path += _pending_suffix;
}
- cerr << "actually writing state\n";
+ string tmp_path;
- if (!tree.write (xml_path)) {
- error << string_compose (_("state could not be saved to %1"), xml_path) << endmsg;
+ tmp_path = _path;
+ tmp_path += snapshot_name;
+ tmp_path += ".tmp";
- /* don't leave a corrupt file lying around if it is
- possible to fix.
- */
-
- if (unlink (xml_path.c_str())) {
- error << string_compose (_("could not remove corrupt state file %1"), xml_path) << endmsg;
- } else {
- if (!pending) {
- if (rename (bak_path.c_str(), xml_path.c_str())) {
- error << string_compose (_("could not restore state file from backup %1"), bak_path) << endmsg;
- }
- }
- }
+ cerr << "actually writing state to " << xml_path << endl;
+ if (!tree.write (tmp_path)) {
+ error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg;
+ unlink (tmp_path.c_str());
return -1;
+
+ } else {
+
+ if (rename (tmp_path.c_str(), xml_path.c_str()) != 0) {
+ error << string_compose (_("could not rename temporary session file %1 to %2"), tmp_path, xml_path) << endmsg;
+ unlink (tmp_path.c_str());
+ return -1;
+ }
}
if (!pending) {
- save_history(snapshot_name);
+
+ save_history (snapshot_name);
bool was_dirty = dirty();
xmlpath += snapshot_name;
xmlpath += _pending_suffix;
- if (!access (xmlpath.c_str(), F_OK)) {
+ if (Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
/* there is pending state from a crashed capture attempt */
xmlpath += snapshot_name;
xmlpath += _statefile_suffix;
}
-
- if (access (xmlpath.c_str(), F_OK)) {
+
+ if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath) << endmsg;
return 1;
}
set_dirty();
- if (state_tree->read (xmlpath)) {
- return 0;
- } else {
+ if (!state_tree->read (xmlpath)) {
error << string_compose(_("Could not understand ardour file %1"), xmlpath) << endmsg;
+ delete state_tree;
+ state_tree = 0;
+ return -1;
}
- delete state_tree;
- state_tree = 0;
- return -1;
+ XMLNode& root (*state_tree->root());
+
+ if (root.name() != X_("Session")) {
+ error << string_compose (_("Session file %1 is not an Ardour session"), xmlpath) << endmsg;
+ delete state_tree;
+ state_tree = 0;
+ return -1;
+ }
+
+ const XMLProperty* prop;
+ bool is_old = false;
+
+ if ((prop = root.property ("version")) == 0) {
+ /* no version implies very old version of Ardour */
+ is_old = true;
+ } else {
+ int major_version;
+ major_version = atoi (prop->value()); // grab just the first number before the period
+ if (major_version < 2) {
+ is_old = true;
+ }
+ }
+
+ if (is_old) {
+ string backup_path;
+
+ backup_path = _path;
+ backup_path += snapshot_name;
+ backup_path += "-1";
+ backup_path += _statefile_suffix;
+
+ info << string_compose (_("Copying old session file %1 to %2\nUse %2 with Ardour versions before 2.0 from now on"),
+ xmlpath, backup_path)
+ << endmsg;
+
+ copy_file (xmlpath, backup_path);
+
+ /* if it fails, don't worry. right? */
+ }
+
+ return 0;
}
int
Session::get_control_protocol_state ()
{
ControlProtocolManager& cpm (ControlProtocolManager::instance());
- XMLNode* node = new XMLNode (X_("ControlProtocols"));
-
- cpm.foreach_known_protocol (bind (mem_fun (*this, &Session::add_control_protocol), node));
-
- return *node;
-}
-
-void
-Session::add_control_protocol (const ControlProtocolInfo* const cpi, XMLNode* node)
-{
- if (cpi->protocol) {
- node->add_child_nocopy (cpi->protocol->get_state());
- }
+ return cpm.get_state();
}
int
try {
boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, node)));
+
+ /* a final detail: this is the one and only place that we know how long missing files are */
+
+ if (region->whole_file()) {
+ for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
+ boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
+ if (sfp) {
+ sfp->set_length (region->length());
+ }
+ }
+ }
+
+
return region;
}
} else {
snprintf (buf, sizeof(buf), "%s/%s-%" PRIu32 ".wav", dir.c_str(), name.c_str(), n);
}
- if (access (buf, F_OK) != 0) {
+
+ if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
return buf;
}
}
+ error << string_compose (_("cannot create new file from region name \"%1\" with ident = \"%2\": too many existing files with similar names"),
+ name, identifier)
+ << endmsg;
+
return "";
}
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((source = XMLSourceFactory (**niter)) == 0) {
- error << _("Session: cannot create Source from XML description.") << endmsg;
+ try {
+ if ((source = XMLSourceFactory (**niter)) == 0) {
+ error << _("Session: cannot create Source from XML description.") << endmsg;
+ }
+ }
+
+ catch (non_existent_source& err) {
+ warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
+ source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
}
}
try {
return SourceFactory::create (*this, node);
}
-
+
catch (failed_constructor& err) {
error << _("Found a sound file that cannot be used by Ardour. Talk to the progammers.") << endmsg;
return boost::shared_ptr<Source>();
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
- Playlist *playlist;
+ boost::shared_ptr<Playlist> playlist;
nlist = node.children();
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
- Playlist *playlist;
+ boost::shared_ptr<Playlist> playlist;
nlist = node.children();
// now manually untrack it
- track_playlist (playlist, false);
+ track_playlist (false, boost::weak_ptr<Playlist> (playlist));
}
return 0;
}
-Playlist *
+boost::shared_ptr<Playlist>
Session::XMLPlaylistFactory (const XMLNode& node)
{
try {
- return new AudioPlaylist (*this, node);
+ return PlaylistFactory::create (*this, node);
}
catch (failed_constructor& err) {
- return 0;
+ return boost::shared_ptr<Playlist>();
}
}
{
string res = _path;
res += dead_sound_dir_name;
- res += '/';
+
return res;
}
string
-Session::sound_dir (bool with_path) const
+Session::old_sound_dir (bool with_path) const
{
- /* support old session structure */
+ string res;
- struct stat statbuf;
- string old_nopath;
- string old_withpath;
+ if (with_path) {
+ res = _path;
+ }
- old_nopath += old_sound_dir_name;
- old_nopath += '/';
-
- old_withpath = _path;
- old_withpath += old_sound_dir_name;
- old_withpath += '/';
+ res += old_sound_dir_name;
- if (stat (old_withpath.c_str(), &statbuf) == 0) {
- if (with_path)
- return old_withpath;
-
- return old_nopath;
- }
+ return res;
+}
+string
+Session::sound_dir (bool with_path) const
+{
string res;
+ string full;
if (with_path) {
res = _path;
+ } else {
+ full = _path;
}
res += interchange_dir_name;
res += legalize_for_path (_name);
res += '/';
res += sound_dir_name;
- res += '/';
+
+ if (with_path) {
+ full = res;
+ } else {
+ full += res;
+ }
+
+ /* if this already exists, don't check for the old session sound directory */
+
+ if (Glib::file_test (full, Glib::FILE_TEST_IS_DIR|Glib::FILE_TEST_EXISTS)) {
+ return res;
+ }
+
+ /* possibly support old session structure */
+
+ string old_nopath;
+ string old_withpath;
+
+ old_nopath += old_sound_dir_name;
+ old_nopath += '/';
+
+ old_withpath = _path;
+ old_withpath += old_sound_dir_name;
+
+ if (Glib::file_test (old_withpath.c_str(), Glib::FILE_TEST_IS_DIR|Glib::FILE_TEST_EXISTS)) {
+ if (with_path)
+ return old_withpath;
+
+ return old_nopath;
+ }
+
+ /* ok, old "sounds" directory isn't there, return the new path */
return res;
}
return path;
}
+string
+Session::export_dir () const
+{
+ string res = _path;
+ res += export_dir_name;
+ res += '/';
+ return res;
+}
+
string
Session::suffixed_search_path (string suffix, bool data)
{
Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
{
for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) {
- i->first->set_meter_point (i->second, arg);
+
+ boost::shared_ptr<Route> r = (i->first.lock());
+
+ if (r) {
+ r->set_meter_point (i->second, arg);
+ }
}
}
Session::set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void* arg)
{
for (GlobalRouteBooleanState::iterator i = s.begin(); i != s.end(); ++i) {
- Route* r = i->first.get();
- (r->*method) (i->second, arg);
+
+ boost::shared_ptr<Route> r = (i->first.lock());
+
+ if (r) {
+ Route* rp = r.get();
+ (rp->*method) (i->second, arg);
+ }
}
}
return 0;
}
+struct RegionCounter {
+ typedef std::map<PBD::ID,boost::shared_ptr<AudioSource> > AudioSourceList;
+ AudioSourceList::iterator iter;
+ boost::shared_ptr<Region> region;
+ uint32_t count;
+
+ RegionCounter() : count (0) {}
+};
+
int
Session::cleanup_sources (Session::cleanup_report& rep)
{
vector<boost::shared_ptr<Source> > dead_sources;
- vector<Playlist*> playlists_tbd;
+ vector<boost::shared_ptr<Playlist> > playlists_tbd;
PathScanner scanner;
string sound_path;
vector<space_and_path>::iterator i;
/* now delete any that were marked for deletion */
- for (vector<Playlist*>::iterator x = playlists_tbd.begin(); x != playlists_tbd.end(); ++x) {
- PlaylistList::iterator foo;
-
- if ((foo = unused_playlists.find (*x)) != unused_playlists.end()) {
- unused_playlists.erase (foo);
- }
- delete *x;
+ for (vector<boost::shared_ptr<Playlist> >::iterator x = playlists_tbd.begin(); x != playlists_tbd.end(); ++x) {
+ (*x)->drop_references ();
}
- /* step 2: find all un-referenced sources */
+ playlists_tbd.clear ();
+
+ /* step 2: find all un-used sources */
rep.paths.clear ();
rep.space = 0;
for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
-
+
AudioSourceList::iterator tmp;
tmp = i;
++tmp;
- /* only remove files that are not in use and have some size
- to them. otherwise we remove the current "nascent"
+ /* do not bother with files that are zero size, otherwise we remove the current "nascent"
capture files.
*/
- cerr << "checking out source " << i->second->name() << " use_count = " << i->second.use_count() << endl;
-
- if (i->second.use_count() == 1 && i->second->length() > 0) {
+ if (!i->second->used() && i->second->length() > 0) {
dead_sources.push_back (i->second);
-
- /* remove this source from our own list to avoid us
- adding it to the list of all sources below
- */
-
- audio_sources.erase (i);
- }
+ i->second->GoingAway();
+ }
i = tmp;
}
- /* Step 3: get rid of all regions in the region list that use any dead sources
- in case the sources themselves don't go away (they might be referenced in
- other snapshots).
- */
-
- for (vector<boost::shared_ptr<Source> >::iterator i = dead_sources.begin(); i != dead_sources.end();++i) {
-
- for (AudioRegionList::iterator r = audio_regions.begin(); r != audio_regions.end(); ) {
- AudioRegionList::iterator tmp;
- boost::shared_ptr<AudioRegion> ar;
-
- tmp = r;
- ++tmp;
-
- ar = r->second;
-
- for (uint32_t n = 0; n < ar->n_channels(); ++n) {
- if (ar->source (n) == (*i)) {
- /* this region is dead */
- remove_region (ar);
- }
- }
-
- r = tmp;
- }
- }
-
/* build a list of all the possible sound directories for the session */
for (i = session_dirs.begin(); i != session_dirs.end(); ) {
++nexti;
sound_path += (*i).path;
- sound_path += sound_dir_name;
+ sound_path += sound_dir (false);
if (nexti != session_dirs.end()) {
sound_path += ':';
i = nexti;
}
-
+
/* now do the same thing for the files that ended up in the sounds dir(s)
but are not referenced as sources in any snapshot.
*/
}
}
+ char tmppath1[PATH_MAX+1];
+ char tmppath2[PATH_MAX+1];
+
for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
used = false;
for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
- if (spath == *i) {
+ realpath(spath.c_str(), tmppath1);
+ realpath((*i).c_str(), tmppath2);
+
+ if (strcmp(tmppath1, tmppath2) == 0) {
used = true;
break;
}
-
}
if (!used) {
on whichever filesystem it was already on.
*/
- newpath = Glib::path_get_dirname (*x);
- newpath = Glib::path_get_dirname (newpath);
+ if ((*x).find ("/sounds/") != string::npos) {
+
+ /* old school, go up 1 level */
+
+ newpath = Glib::path_get_dirname (*x); // "sounds"
+ newpath = Glib::path_get_dirname (newpath); // "session-name"
+
+ } else {
+
+ /* new school, go up 4 levels */
+
+ newpath = Glib::path_get_dirname (*x); // "audiofiles"
+ newpath = Glib::path_get_dirname (newpath); // "session-name"
+ newpath = Glib::path_get_dirname (newpath); // "interchange"
+ newpath = Glib::path_get_dirname (newpath); // "session-dir"
+ }
newpath += '/';
newpath += dead_sound_dir_name;
+
+ if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session peakfile dir \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
+ return -1;
+ }
+
newpath += '/';
newpath += Glib::path_get_basename ((*x));
<< endmsg;
goto out;
}
-
/* see if there an easy to find peakfile for this file, and remove it.
*/
goto out;
}
}
-
}
ret = 0;
}
}
+void
+Session::set_deletion_in_progress ()
+{
+ _state_of_the_state = StateOfTheState (_state_of_the_state | Deletion);
+}
+
void
Session::add_controllable (Controllable* c)
{
+ /* this adds a controllable to the list managed by the Session.
+ this is a subset of those managed by the Controllable class
+ itself, and represents the only ones whose state will be saved
+ as part of the session.
+ */
+
Glib::Mutex::Lock lm (controllables_lock);
controllables.insert (c);
}
return -1;
}
- cerr << "actually writing history\n";
-
if (!tree.write (xml_path))
{
error << string_compose (_("history could not be saved to %1"), xml_path) << endmsg;
XMLTree tree;
string xmlpath;
+ if (snapshot_name.empty()) {
+ snapshot_name = _current_snapshot_name;
+ }
+
/* read xml */
xmlpath = _path + snapshot_name + ".history";
cerr << string_compose(_("Loading history from '%1'."), xmlpath) << endmsg;
if (n->name() == "MementoCommand" ||
n->name() == "MementoUndoCommand" ||
n->name() == "MementoRedoCommand") {
+
if ((c = memento_command_factory(n))) {
ut->add_command(c);
}
+
+ } else if (n->name() == X_("GlobalRouteStateCommand")) {
+
+ if ((c = global_state_command_factory (*n))) {
+ ut->add_command (c);
+ }
+
} else {
+
error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
}
}
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
- //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
(*i)->monitor_input (!Config->get_auto_input());
}
}
poke_midi_thread ();
+ } else if (PARAM_IS ("mmc-device-id")) {
+
+ if (mmc) {
+ mmc->set_device_id (Config->get_mmc_device_id());
+ }
+
} else if (PARAM_IS ("midi-control")) {
poke_midi_thread ();
setup_raid_path (Config->get_raid_path());
- } else if (PARAM_IS ("smpte-frames-per-second") || PARAM_IS ("smpte-drop-frames")) {
+ } else if (PARAM_IS ("smpte-format")) {
sync_time_vars ();
/* mark us ready to send */
next_quarter_frame_to_send = 0;
}
+ } else {
+ session_send_mtc = false;
}
} else if (PARAM_IS ("send-mmc")) {
if (_mmc_port != 0) {
session_send_mmc = Config->get_send_mmc();
+ } else {
+ mmc = 0;
+ session_send_mmc = false;
}
} else if (PARAM_IS ("midi-feedback")) {
}
first_file_data_format_reset = false;
+
+ } else if (PARAM_IS ("slave-source")) {
+ set_slave_source (Config->get_slave_source());
+ } else if (PARAM_IS ("remote-model")) {
+ set_remote_control_ids ();
}
-
+
set_dirty ();
#undef PARAM_IS
projects / ardour.git / blobdiff