/*
- Copyright (C) 1999-2002 Paul Davis
+ Copyright (C) 1999-2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+
*/
+
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
#include <algorithm>
#include <fstream>
#include <string>
#endif
#include <glibmm.h>
-
-#include <midi++/mmc.h>
-#include <midi++/port.h>
-#include <pbd/error.h>
-
#include <glibmm/thread.h>
-#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/session.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/utils.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/silentfilesource.h>
-#include <ardour/sndfilesource.h>
-#include <ardour/sndfile_helpers.h>
-#include <ardour/auditioner.h>
-#include <ardour/export.h>
-#include <ardour/redirect.h>
-#include <ardour/send.h>
-#include <ardour/insert.h>
-#include <ardour/connection.h>
-#include <ardour/slave.h>
-#include <ardour/tempo.h>
-#include <ardour/audio_track.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/utils.h>
-#include <ardour/named_selection.h>
-#include <ardour/version.h>
-#include <ardour/location.h>
-#include <ardour/audioregion.h>
-#include <ardour/crossfade.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>
+
+#include "midi++/mmc.h"
+#include "midi++/port.h"
+
+#include "pbd/error.h"
+#include "pbd/pathscanner.h"
+#include "pbd/pthread_utils.h"
+#include "pbd/search_path.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/audio_diskstream.h"
+#include "ardour/audio_track.h"
+#include "ardour/audioengine.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/audioplaylist.h"
+#include "ardour/audioregion.h"
+#include "ardour/auditioner.h"
+#include "ardour/buffer.h"
+#include "ardour/butler.h"
+#include "ardour/configuration.h"
+#include "ardour/control_protocol_manager.h"
+#include "ardour/crossfade.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/directory_names.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/io_processor.h"
+#include "ardour/location.h"
+#include "ardour/midi_diskstream.h"
+#include "ardour/midi_patch_manager.h"
+#include "ardour/midi_playlist.h"
+#include "ardour/midi_region.h"
+#include "ardour/midi_source.h"
+#include "ardour/midi_track.h"
+#include "ardour/named_selection.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/processor.h"
+#include "ardour/region_factory.h"
+#include "ardour/route_group.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_metadata.h"
+#include "ardour/session_state_utils.h"
+#include "ardour/session_utils.h"
+#include "ardour/silentfilesource.h"
+#include "ardour/slave.h"
+#include "ardour/smf_source.h"
+#include "ardour/sndfile_helpers.h"
+#include "ardour/sndfilesource.h"
+#include "ardour/source_factory.h"
+#include "ardour/template_utils.h"
+#include "ardour/tempo.h"
+#include "ardour/ticker.h"
+#include "ardour/user_bundle.h"
+#include "ardour/utils.h"
+#include "ardour/utils.h"
+#include "ardour/version.h"
+
+#include "control_protocol/control_protocol.h"
#include "i18n.h"
#include <locale.h>
_path += '/';
}
+ if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
+ cerr << "Session non-writable based on " << _path << endl;
+ _writable = false;
+ } else {
+ cerr << "Session writable based on " << _path << endl;
+ _writable = true;
+ }
+
/* these two are just provisional settings. set_state()
will likely override them.
*/
_name = _current_snapshot_name = snapshot_name;
+ set_history_depth (Config->get_history_depth());
+
_current_frame_rate = _engine.frame_rate ();
+ _nominal_frame_rate = _current_frame_rate;
+ _base_frame_rate = _current_frame_rate;
+
_tempo_map = new TempoMap (_current_frame_rate);
_tempo_map->StateChanged.connect (mem_fun (*this, &Session::tempo_map_changed));
+
+ _non_soloed_outs_muted = false;
+ _listen_cnt = 0;
g_atomic_int_set (&processing_prohibited, 0);
- insert_cnt = 0;
_transport_speed = 0;
_last_transport_speed = 0;
+ _target_transport_speed = 0;
auto_play_legal = false;
transport_sub_state = 0;
_transport_frame = 0;
- last_stop_frame = 0;
end_location = new Location (0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
start_location = new Location (0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
- _end_location_is_free = true;
g_atomic_int_set (&_record_status, Disabled);
loop_changing = false;
play_loop = false;
+ have_looped = false;
_last_roll_location = 0;
_last_record_location = 0;
pending_locate_frame = 0;
pending_locate_roll = false;
pending_locate_flush = false;
- dstream_buffer_size = 0;
- state_tree = 0;
state_was_pending = false;
set_next_event ();
outbound_mtc_smpte_frame = 0;
next_quarter_frame_to_send = -1;
current_block_size = 0;
solo_update_disabled = false;
- currently_soloing = false;
_have_captured = false;
_worst_output_latency = 0;
_worst_input_latency = 0;
_worst_track_latency = 0;
- _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading|Deletion);
+ _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
+
_slave = 0;
- butler_mixdown_buffer = 0;
- butler_gain_buffer = 0;
- mmc = 0;
session_send_mmc = false;
session_send_mtc = false;
post_transport_work = PostTransportWork (0);
- g_atomic_int_set (&butler_should_do_transport_work, 0);
- g_atomic_int_set (&butler_active, 0);
g_atomic_int_set (&_playback_load, 100);
g_atomic_int_set (&_capture_load, 100);
g_atomic_int_set (&_playback_load_min, 100);
g_atomic_int_set (&_capture_load_min, 100);
_play_range = false;
- waiting_to_start = false;
_exporting = false;
+ _exporting_realtime = false;
_gain_automation_buffer = 0;
_pan_automation_buffer = 0;
_npan_buffers = 0;
pending_abort = false;
destructive_index = 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;
+ //midi_thread = (pthread_t) 0;
AudioDiskstream::allocate_working_buffers();
-
+
/* default short fade = 15ms */
- Crossfade::set_short_xfade_length ((nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
- SndFileSource::setup_standard_crossfades (frame_rate());
+ Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate()));
+ SndFileSource::setup_standard_crossfades (*this, frame_rate());
last_mmc_step.tv_sec = 0;
last_mmc_step.tv_usec = 0;
/* click sounds are unset by default, which causes us to internal
waveforms for clicks.
*/
-
- click_data = 0;
- click_emphasis_data = 0;
+
click_length = 0;
click_emphasis_length = 0;
_clicking = false;
process_function = &Session::process_with_events;
- if (Config->get_use_video_sync()) {
+ if (config.get_use_video_sync()) {
waiting_for_sync_offset = true;
} else {
waiting_for_sync_offset = false;
}
- _current_frame_rate = 48000;
- _base_frame_rate = 48000;
-
last_smpte_when = 0;
_smpte_offset = 0;
_smpte_offset_negative = true;
/* slave stuff */
- average_slave_delta = 1800;
+ average_slave_delta = 1800; // !!! why 1800 ????
have_first_delta_accumulator = false;
delta_accumulator_cnt = 0;
slave_state = Stopped;
RegionFactory::CheckNewRegion.connect (mem_fun (*this, &Session::add_region));
SourceFactory::SourceCreated.connect (mem_fun (*this, &Session::add_source));
PlaylistFactory::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
- Redirect::RedirectCreated.connect (mem_fun (*this, &Session::add_redirect));
+ Processor::ProcessorCreated.connect (mem_fun (*this, &Session::add_processor));
NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
- AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
+ AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable));
- IO::MoreOutputs.connect (mem_fun (*this, &Session::ensure_passthru_buffers));
+ IO::PortCountChanged.connect (mem_fun (*this, &Session::ensure_buffers));
/* stop IO objects from doing stuff until we're ready for them */
- IO::disable_panners ();
- IO::disable_ports ();
+ Delivery::disable_panners ();
IO::disable_connecting ();
}
int
Session::second_stage_init (bool new_session)
{
- AudioFileSource::set_peak_dir (peak_dir());
+ AudioFileSource::set_peak_dir (_session_dir->peak_path().to_string());
if (!new_session) {
if (load_state (_current_snapshot_name)) {
remove_empty_sounds ();
}
- if (start_butler_thread()) {
+ if (_butler->start_thread()) {
return -1;
}
// set_state() will call setup_raid_path(), but if it's a new session we need
// to call setup_raid_path() here.
+
if (state_tree) {
- if (set_state (*state_tree->root())) {
+ if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
return -1;
}
} else {
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
- // set_auto_input (true);
+
_locations.changed.connect (mem_fun (this, &Session::locations_changed));
_locations.added.connect (mem_fun (this, &Session::locations_added));
setup_click_sounds (0);
}
/* 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;
+ error << err.what() << endmsg;
return -1;
}
return -1;
}
- send_full_time_code ();
+ BootMessage (_("Reset Remote Controls"));
+
+ send_full_time_code (0);
_engine.transport_locate (0);
deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
+ MidiClockTicker::instance().set_session(*this);
+ MIDI::Name::MidiPatchManager::instance().set_session(*this);
+
+ /* initial program change will be delivered later; see ::config_changed() */
+
+ BootMessage (_("Reset Control Protocols"));
+
ControlProtocolManager::instance().set_session (*this);
- if (new_session) {
- _end_location_is_free = true;
- } else {
- _end_location_is_free = false;
+ config.set_end_marker_is_free (new_session);
+
+ _state_of_the_state = Clean;
+
+ DirtyChanged (); /* EMIT SIGNAL */
+
+ if (state_was_pending) {
+ save_state (_current_snapshot_name);
+ remove_pending_capture_state ();
+ state_was_pending = false;
}
-
+
+ BootMessage (_("Session loading complete"));
+
return 0;
}
string
Session::raid_path () const
{
- string path;
+ SearchPath raid_search_path;
for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
- path += (*i).path;
- path += ':';
+ raid_search_path += sys::path((*i).path);
}
-
- return path.substr (0, path.length() - 1); // drop final colon
+
+ return raid_search_path.to_string ();
}
void
Session::setup_raid_path (string path)
{
- string::size_type colon;
- string remaining;
- space_and_path sp;
- string fspath;
- string::size_type len = path.length();
- int colons;
-
- colons = 0;
-
- if (path.length() == 0) {
+ if (path.empty()) {
return;
}
- session_dirs.clear ();
-
- for (string::size_type n = 0; n < len; ++n) {
- if (path[n] == ':') {
- colons++;
- }
- }
-
- if (colons == 0) {
-
- /* no multiple search path, just one location (common case) */
-
- sp.path = path;
- sp.blocks = 0;
- session_dirs.push_back (sp);
-
- string fspath;
-
- /* sounds dir */
-
- fspath += sp.path;
- if (fspath[fspath.length()-1] != '/') {
- fspath += '/';
- }
-
- fspath += sound_dir (false);
-
- AudioFileSource::set_search_path (fspath);
+ space_and_path sp;
+ string fspath;
- return;
- }
+ session_dirs.clear ();
- remaining = path;
+ SearchPath search_path(path);
+ SearchPath sound_search_path;
+ SearchPath midi_search_path;
- while ((colon = remaining.find_first_of (':')) != string::npos) {
-
- sp.blocks = 0;
- sp.path = remaining.substr (0, colon);
+ for (SearchPath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
+ sp.path = (*i).to_string ();
+ sp.blocks = 0; // not needed
session_dirs.push_back (sp);
- /* add sounds to file search path */
-
- fspath += sp.path;
- if (fspath[fspath.length()-1] != '/') {
- fspath += '/';
- }
- fspath += sound_dir (false);
- fspath += ':';
-
- remaining = remaining.substr (colon+1);
- }
-
- if (remaining.length()) {
-
- sp.blocks = 0;
- sp.path = remaining;
-
- fspath += ':';
- fspath += sp.path;
- if (fspath[fspath.length()-1] != '/') {
- fspath += '/';
- }
- fspath += sound_dir (false);
- fspath += ':';
+ SessionDirectory sdir(sp.path);
- session_dirs.push_back (sp);
+ sound_search_path += sdir.sound_path ();
+ midi_search_path += sdir.midi_path ();
}
- /* set the AudioFileSource search path */
-
- AudioFileSource::set_search_path (fspath);
-
- /* reset the round-robin soundfile path thingie */
+ // set the search path for each data type
+ FileSource::set_search_path (DataType::AUDIO, sound_search_path.to_string ());
+ SMFSource::set_search_path (DataType::MIDI, midi_search_path.to_string ());
+ // reset the round-robin soundfile path thingie
last_rr_session_dir = session_dirs.begin();
}
int
-Session::create (bool& new_session, string* mix_template, nframes_t initial_length)
+Session::ensure_subdirs ()
{
string dir;
- if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session dir \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
+ dir = session_directory().peak_path().to_string();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
- dir = peak_dir ();
+ dir = session_directory().sound_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session peakfile dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
- /* if this is is an existing session with an old "sounds" directory, just use it. see Session::sound_dir() for more details */
+ dir = session_directory().midi_path().to_string();
- 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;
- }
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
}
- dir = dead_sound_dir ();
+ dir = session_directory().dead_sound_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session dead sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
- dir = automation_dir ();
+ dir = session_directory().export_path().to_string();
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 folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
- dir = export_dir ();
+ dir = analysis_dir ();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session export dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create session analysis folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+Session::create (bool& new_session, const string& mix_template, nframes_t initial_length)
+{
+
+ if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session folder \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
return -1;
}
+ if (ensure_subdirs ()) {
+ return -1;
+ }
/* check new_session so we don't overwrite an existing one */
- if (mix_template) {
- std::string in_path = *mix_template;
+ if (!mix_template.empty()) {
+ std::string in_path = mix_template;
ifstream in(in_path.c_str());
if (in){
string out_path = _path;
out_path += _name;
- out_path += _statefile_suffix;
+ out_path += statefile_suffix;
ofstream out(out_path.c_str());
return 0;
} else {
- error << string_compose (_("Could not open %1 for writing mix template"), out_path)
+ error << string_compose (_("Could not open %1 for writing mix template"), out_path)
<< endmsg;
return -1;
}
} else {
- error << string_compose (_("Could not open mix template %1 for reading"), in_path)
+ error << string_compose (_("Could not open mix template %1 for reading"), in_path)
<< endmsg;
return -1;
}
}
+ /* Instantiate metadata */
+
+ _metadata = new SessionMetadata ();
+
/* set initial start + end point */
start_location->set_end (0);
_state_of_the_state = Clean;
- if (save_state (_current_snapshot_name)) {
- return -1;
- }
+ save_state ("");
return 0;
}
+
int
Session::load_diskstreams (const XMLNode& node)
{
XMLNodeList clist;
XMLNodeConstIterator citer;
-
+
clist = node.children();
for (citer = clist.begin(); citer != clist.end(); ++citer) {
-
try {
- boost::shared_ptr<AudioDiskstream> dstream (new AudioDiskstream (*this, **citer));
- add_diskstream (dstream);
- }
-
+ /* diskstreams added automatically by DiskstreamCreated handler */
+ if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
+ boost::shared_ptr<AudioDiskstream> dstream (new AudioDiskstream (*this, **citer));
+ add_diskstream (dstream);
+ } else if ((*citer)->name() == "MidiDiskstream") {
+ boost::shared_ptr<MidiDiskstream> dstream (new MidiDiskstream (*this, **citer));
+ add_diskstream (dstream);
+ } else {
+ error << _("Session: unknown diskstream type in XML") << endmsg;
+ }
+ }
+
catch (failed_constructor& err) {
- error << _("Session: could not load diskstream via XML state") << endmsg;
+ error << _("Session: could not load diskstream via XML state") << endmsg;
return -1;
}
}
return 0;
}
+void
+Session::maybe_write_autosave()
+{
+ if (dirty() && record_status() != Recording) {
+ save_state("", true);
+ }
+}
+
void
Session::remove_pending_capture_state ()
{
- string xml_path;
+ sys::path pending_state_file_path(_session_dir->root_path());
+
+ pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix;
+
+ try
+ {
+ sys::remove (pending_state_file_path);
+ }
+ catch(sys::filesystem_error& ex)
+ {
+ error << string_compose(_("Could remove pending capture state at path \"%1\" (%2)"),
+ pending_state_file_path.to_string(), ex.what()) << endmsg;
+ }
+}
+
+/** 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_filename = legalize_for_path (old_name) + statefile_suffix;
+ const string new_xml_filename = legalize_for_path (new_name) + statefile_suffix;
+
+ const sys::path old_xml_path = _session_dir->root_path() / old_xml_filename;
+ const sys::path new_xml_path = _session_dir->root_path() / new_xml_filename;
+
+ try
+ {
+ sys::rename (old_xml_path, new_xml_path);
+ }
+ catch (const sys::filesystem_error& err)
+ {
+ error << string_compose(_("could not rename snapshot %1 to %2 (%3)"),
+ old_name, new_name, err.what()) << 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;
+ }
- xml_path = _path;
- xml_path += _current_snapshot_name;
- xml_path += _pending_suffix;
+ sys::path xml_path(_session_dir->root_path());
- unlink (xml_path.c_str());
+ xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
+
+ if (!create_backup_file (xml_path)) {
+ // don't remove it if a backup can't be made
+ // create_backup_file will log the error.
+ return;
+ }
+
+ // and delete it
+ sys::remove (xml_path);
}
int
Session::save_state (string snapshot_name, bool pending)
{
XMLTree tree;
- string xml_path;
- string bak_path;
+ sys::path xml_path(_session_dir->root_path());
- if (_state_of_the_state & CannotSave) {
+ if (!_writable || (_state_of_the_state & CannotSave)) {
return 1;
}
return 1;
}
+ /* tell sources we're saving first, in case they write out to a new file
+ * which should be saved with the state rather than the old one */
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i)
+ i->second->session_saved();
+
tree.set_root (&get_state());
if (snapshot_name.empty()) {
if (!pending) {
- xml_path = _path;
- xml_path += snapshot_name;
- xml_path += _statefile_suffix;
+ /* proper save: use statefile_suffix (.ardour in English) */
- bak_path = xml_path;
- bak_path += ".bak";
-
- if (g_file_test (xml_path.c_str(), G_FILE_TEST_EXISTS)) {
- copy_file (xml_path, bak_path);
+ xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
+
+ /* make a backup copy of the old file */
+
+ if (sys::exists(xml_path) && !create_backup_file (xml_path)) {
+ // create_backup_file will log the error
+ return -1;
}
} else {
- xml_path = _path;
- xml_path += snapshot_name;
- xml_path += _pending_suffix;
-
+ /* pending save: use pending_suffix (.pending in English) */
+ xml_path /= legalize_for_path (snapshot_name) + pending_suffix;
}
- string tmp_path;
+ sys::path tmp_path(_session_dir->root_path());
- tmp_path = _path;
- tmp_path += snapshot_name;
- tmp_path += ".tmp";
+ tmp_path /= legalize_for_path (snapshot_name) + temp_suffix;
- cerr << "actually writing state\n";
+ // cerr << "actually writing state to " << xml_path.to_string() << endl;
- if (!tree.write (tmp_path)) {
- error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg;
- unlink (tmp_path.c_str());
+ if (!tree.write (tmp_path.to_string())) {
+ error << string_compose (_("state could not be saved to %1"), tmp_path.to_string()) << endmsg;
+ sys::remove (tmp_path);
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());
+ if (rename (tmp_path.to_string().c_str(), xml_path.to_string().c_str()) != 0) {
+ error << string_compose (_("could not rename temporary session file %1 to %2"),
+ tmp_path.to_string(), xml_path.to_string()) << endmsg;
+ sys::remove (tmp_path);
return -1;
}
}
if (!pending) {
- save_history (snapshot_name);
+ save_history (snapshot_name);
bool was_dirty = dirty();
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
-
+
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
}
-
+
StateSaved (snapshot_name); /* EMIT SIGNAL */
}
Session::restore_state (string snapshot_name)
{
if (load_state (snapshot_name) == 0) {
- set_state (*state_tree->root());
+ set_state (*state_tree->root(), Stateful::loading_state_version);
}
-
+
return 0;
}
int
Session::load_state (string snapshot_name)
{
- if (state_tree) {
- delete state_tree;
- state_tree = 0;
- }
+ delete state_tree;
+ state_tree = 0;
- string xmlpath;
-
state_was_pending = false;
/* check for leftover pending state from a crashed capture attempt */
- xmlpath = _path;
- xmlpath += snapshot_name;
- xmlpath += _pending_suffix;
+ sys::path xmlpath(_session_dir->root_path());
+ xmlpath /= legalize_for_path (snapshot_name) + pending_suffix;
- if (!access (xmlpath.c_str(), F_OK)) {
+ if (sys::exists (xmlpath)) {
/* there is pending state from a crashed capture attempt */
if (AskAboutPendingState()) {
state_was_pending = true;
- }
- }
+ }
+ }
if (!state_was_pending) {
-
- xmlpath = _path;
- xmlpath += snapshot_name;
- xmlpath += _statefile_suffix;
+ xmlpath = _session_dir->root_path();
+ xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
}
- if (access (xmlpath.c_str(), F_OK)) {
- error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath) << endmsg;
+ if (!sys::exists (xmlpath)) {
+ error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
return 1;
}
set_dirty();
- if (!state_tree->read (xmlpath)) {
- error << string_compose(_("Could not understand ardour file %1"), xmlpath) << endmsg;
+ /* writable() really reflects the whole folder, but if for any
+ reason the session state file can't be written to, still
+ make us unwritable.
+ */
+
+ if (::access (xmlpath.to_string().c_str(), W_OK) != 0) {
+ _writable = false;
+ }
+
+ if (!state_tree->read (xmlpath.to_string())) {
+ error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg;
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;
+ error << string_compose (_("Session file %1 is not an Ardour session"), xmlpath.to_string()) << 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;
+ Stateful::loading_state_version = 1000;
} else {
- int major_version;
- major_version = atoi (prop->value()); // grab just the first number before the period
- if (major_version < 2) {
- is_old = true;
- }
+ int major;
+ int minor;
+ int micro;
+
+ sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, µ);
+ Stateful::loading_state_version = (major * 1000) + minor;
}
+
+ if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
+
+ sys::path backup_path(_session_dir->root_path());
- if (is_old) {
- string backup_path;
+ backup_path /= legalize_for_path (snapshot_name) + "-1" + statefile_suffix;
- backup_path = xmlpath;
- backup_path += ".1";
+ // only create a backup once
+ if (sys::exists (backup_path)) {
+ return 0;
+ }
info << string_compose (_("Copying old session file %1 to %2\nUse %2 with Ardour versions before 2.0 from now on"),
- xmlpath, backup_path)
+ xmlpath.to_string(), backup_path.to_string())
<< endmsg;
- copy_file (xmlpath, backup_path);
-
- /* if it fails, don't worry. right? */
+ try
+ {
+ sys::copy_file (xmlpath, backup_path);
+ }
+ catch(sys::filesystem_error& ex)
+ {
+ error << string_compose (_("Unable to make backup of state file %1 (%2)"),
+ xmlpath.to_string(), ex.what())
+ << endmsg;
+ return -1;
+ }
}
return 0;
int
Session::load_options (const XMLNode& node)
{
- XMLNode* child;
- XMLProperty* prop;
LocaleGuard lg (X_("POSIX"));
- Config->set_variables (node, ConfigVariableBase::Session);
-
- if ((child = find_named_node (node, "end-marker-is-free")) != 0) {
- if ((prop = child->property ("val")) != 0) {
- _end_location_is_free = (prop->value() == "yes");
- }
- }
-
- return 0;
-}
-
-bool
-Session::save_config_options_predicate (ConfigVariableBase::Owner owner) const
-{
- const ConfigVariableBase::Owner modified_by_session_or_user = (ConfigVariableBase::Owner)
- (ConfigVariableBase::Session|ConfigVariableBase::Interface);
-
- return owner & modified_by_session_or_user;
-}
-
-XMLNode&
-Session::get_options () const
-{
- XMLNode* child;
- LocaleGuard lg (X_("POSIX"));
+ config.set_variables (node);
- XMLNode& option_root = Config->get_variables (mem_fun (*this, &Session::save_config_options_predicate));
+ /* now reset MIDI ports because the session can have its own
+ MIDI configuration.
+ */
- child = option_root.add_child ("end-marker-is-free");
- child->add_property ("val", _end_location_is_free ? "yes" : "no");
+ setup_midi ();
- return option_root;
+ return 0;
}
XMLNode&
{
/* if we don't disable rec-enable, diskstreams
will believe they need to store their capture
- sources in their state node.
+ sources in their state node.
*/
-
+
disable_record (false);
return state(false);
// store libardour version, just in case
char buf[16];
- snprintf(buf, sizeof(buf)-1, "%d.%d.%d",
- libardour_major_version, libardour_minor_version, libardour_micro_version);
+ snprintf(buf, sizeof(buf), "%d.%d.%d", libardour3_major_version, libardour3_minor_version, libardour3_micro_version);
node->add_property("version", string(buf));
-
+
/* store configuration settings */
if (full_state) {
-
- /* store the name */
+
node->add_property ("name", _name);
+ snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate);
+ node->add_property ("sample-rate", buf);
if (session_dirs.size() > 1) {
++next;
++i;
}
-
+
child = node->add_child ("Path");
child->add_content (p);
}
}
/* save the ID counter */
-
+
snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
node->add_property ("id-counter", buf);
/* various options */
- node->add_child_nocopy (get_options());
+ node->add_child_nocopy (config.get_variables ());
+
+ node->add_child_nocopy (_metadata->get_state());
child = node->add_child ("Sources");
if (full_state) {
- Glib::Mutex::Lock sl (audio_source_lock);
+ Glib::Mutex::Lock sl (source_lock);
- for (AudioSourceList::iterator siter = audio_sources.begin(); siter != audio_sources.end(); ++siter) {
-
- /* Don't save information about AudioFileSources that are empty */
-
- boost::shared_ptr<AudioFileSource> fs;
-
- if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
+ for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
- /* destructive file sources are OK if they are empty, because
- we will re-use them every time.
- */
+ /* Don't save information about non-destructive file sources that are empty */
+ /* FIXME: MIDI breaks if this is made FileSource like it should be... */
+ boost::shared_ptr<AudioFileSource> fs;
+ if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
if (!fs->destructive()) {
- if (fs->length() == 0) {
+ if (fs->length(fs->timeline_position()) == 0) {
continue;
}
}
}
-
+
child->add_child_nocopy (siter->second->get_state());
}
}
child = node->add_child ("Regions");
- if (full_state) {
+ if (full_state) {
Glib::Mutex::Lock rl (region_lock);
- for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
-
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+
/* only store regions not attached to playlists */
if (i->second->playlist() == 0) {
child = node->add_child ("DiskStreams");
- {
+ {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
loc.add (end);
node->add_child_nocopy (loc.get_state());
}
-
- child = node->add_child ("Connections");
+
+ child = node->add_child ("Bundles");
{
- Glib::Mutex::Lock lm (connection_lock);
- for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); ++i) {
- if (!(*i)->system_dependent()) {
- child->add_child_nocopy ((*i)->get_state());
+ boost::shared_ptr<BundleList> bundles = _bundles.reader ();
+ for (BundleList::iterator i = bundles->begin(); i != bundles->end(); ++i) {
+ boost::shared_ptr<UserBundle> b = boost::dynamic_pointer_cast<UserBundle> (*i);
+ if (b) {
+ child->add_child_nocopy (b->get_state());
}
}
}
child = node->add_child ("Routes");
{
boost::shared_ptr<RouteList> r = routes.reader ();
-
+
RoutePublicOrderSorter cmp;
RouteList public_order (*r);
public_order.sort (cmp);
-
+
for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
- if (!(*i)->hidden()) {
+ if (!(*i)->is_hidden()) {
if (full_state) {
child->add_child_nocopy ((*i)->get_state());
} else {
}
}
-
- child = node->add_child ("EditGroups");
- for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ++i) {
- child->add_child_nocopy ((*i)->get_state());
- }
- child = node->add_child ("MixGroups");
- for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ++i) {
+ child = node->add_child ("RouteGroups");
+ for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
child->add_child_nocopy ((*i)->get_state());
}
}
}
}
-
-
+
+
if (_click_io) {
child = node->add_child ("Click");
child->add_child_nocopy (_click_io->state (full_state));
for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
if (full_state) {
child->add_child_nocopy ((*i)->get_state());
- }
+ }
}
}
}
int
-Session::set_state (const XMLNode& node)
+Session::set_state (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNode* child;
int ret = -1;
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
-
+
if (node.name() != X_("Session")){
fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
return -1;
}
+ if ((prop = node.property ("version")) != 0) {
+ version = atoi (prop->value ()) * 1000;
+ }
+
if ((prop = node.property ("name")) != 0) {
_name = prop->value ();
}
- setup_raid_path(_path);
+ if ((prop = node.property (X_("sample-rate"))) != 0) {
+
+ _nominal_frame_rate = atoi (prop->value());
+
+ if (_nominal_frame_rate != _current_frame_rate) {
+ if (AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate)) {
+ return -1;
+ }
+ }
+ }
+
+ setup_raid_path(_session_dir->root_path().to_string());
if ((prop = node.property (X_("id-counter"))) != 0) {
uint64_t x;
ID::init_counter (now);
}
-
- IO::disable_ports ();
+
IO::disable_connecting ();
/* Object loading order:
- MIDI
Path
- extra
+ Extra
Options/Config
+ MIDI Control // relies on data from Options/Config
+ Metadata
Locations
Sources
AudioRegions
AudioDiskstreams
Connections
Routes
- EditGroups
+ RouteGroups
MixGroups
Click
ControlProtocols
*/
- if (use_config_midi_ports ()) {
- }
-
- if ((child = find_named_node (node, "extra")) != 0) {
- _extra_xml = new XMLNode (*child);
+ if ((child = find_named_node (node, "Extra")) != 0) {
+ _extra_xml = new XMLNode (*child);
}
if (((child = find_named_node (node, "Options")) != 0)) { /* old style */
error << _("Session: XML state has no options section") << endmsg;
}
+ if (use_config_midi_ports ()) {
+ }
+
+ if (version >= 3000) {
+ if ((child = find_named_node (node, "Metadata")) == 0) {
+ warning << _("Session: XML state has no metadata section") << endmsg;
+ } else if (_metadata->set_state (*child, version)) {
+ goto out;
+ }
+ }
+
if ((child = find_named_node (node, "Locations")) == 0) {
error << _("Session: XML state has no locations section") << endmsg;
goto out;
- } else if (_locations.set_state (*child)) {
+ } else if (_locations.set_state (*child, version)) {
goto out;
}
goto out;
}
- if ((child = find_named_node (node, "Connections")) == 0) {
- error << _("Session: XML state has no connections section") << endmsg;
- goto out;
- } else if (load_connections (*child)) {
- goto out;
- }
-
- if ((child = find_named_node (node, "EditGroups")) == 0) {
- error << _("Session: XML state has no edit groups section") << endmsg;
- goto out;
- } else if (load_edit_groups (*child)) {
- goto out;
+ if (version >= 3000) {
+ if ((child = find_named_node (node, "Bundles")) == 0) {
+ warning << _("Session: XML state has no bundles section") << endmsg;
+ //goto out;
+ } else {
+ /* We can't load Bundles yet as they need to be able
+ to convert from port names to Port objects, which can't happen until
+ later */
+ _bundle_xml_node = new XMLNode (*child);
+ }
}
+
+ if (version >= 3000) {
+
+ if ((child = find_named_node (node, "RouteGroups")) == 0) {
+ error << _("Session: XML state has no route groups section") << endmsg;
+ goto out;
+ } else if (load_route_groups (*child, version)) {
+ goto out;
+ }
+
+ } else if (version < 3000) {
+
+ if ((child = find_named_node (node, "EditGroups")) == 0) {
+ error << _("Session: XML state has no edit groups section") << endmsg;
+ goto out;
+ } else if (load_route_groups (*child, version)) {
+ goto out;
+ }
- if ((child = find_named_node (node, "MixGroups")) == 0) {
- error << _("Session: XML state has no mix groups section") << endmsg;
- goto out;
- } else if (load_mix_groups (*child)) {
- goto out;
+ if ((child = find_named_node (node, "MixGroups")) == 0) {
+ error << _("Session: XML state has no mix groups section") << endmsg;
+ goto out;
+ } else if (load_route_groups (*child, version)) {
+ goto out;
+ }
}
if ((child = find_named_node (node, "TempoMap")) == 0) {
error << _("Session: XML state has no Tempo Map section") << endmsg;
goto out;
- } else if (_tempo_map->set_state (*child)) {
+ } else if (_tempo_map->set_state (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "Routes")) == 0) {
error << _("Session: XML state has no routes section") << endmsg;
goto out;
- } else if (load_routes (*child)) {
+ } else if (load_routes (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "Click")) == 0) {
warning << _("Session: XML state has no click section") << endmsg;
} else if (_click_io) {
- _click_io->set_state (*child);
+ _click_io->set_state (*child, version);
}
-
+
if ((child = find_named_node (node, "ControlProtocols")) != 0) {
ControlProtocolManager::instance().set_protocol_states (*child);
}
StateReady (); /* EMIT SIGNAL */
- _state_of_the_state = Clean;
-
- if (state_was_pending) {
- save_state (_current_snapshot_name);
- remove_pending_capture_state ();
- state_was_pending = false;
- }
-
return 0;
out:
}
int
-Session::load_routes (const XMLNode& node)
+Session::load_routes (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- boost::shared_ptr<Route> route (XMLRouteFactory (**niter));
+ boost::shared_ptr<Route> route (XMLRouteFactory (**niter, version));
if (route == 0) {
- error << _("Session: cannot create Route from XML description.") << endmsg;
+ error << _("Session: cannot create Route from XML description.") << endmsg;
return -1;
}
+ BootMessage (string_compose (_("Loaded track/bus %1"), route->name()));
+
new_routes.push_back (route);
}
- add_routes (new_routes);
+ add_routes (new_routes, false);
return 0;
}
boost::shared_ptr<Route>
-Session::XMLRouteFactory (const XMLNode& node)
+Session::XMLRouteFactory (const XMLNode& node, int version)
{
if (node.name() != "Route") {
return boost::shared_ptr<Route> ((Route*) 0);
}
- if (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0) {
- boost::shared_ptr<Route> x (new AudioTrack (*this, node));
- return x;
+ bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
+
+ DataType type = DataType::AUDIO;
+ const XMLProperty* prop = node.property("default-type");
+
+ if (prop) {
+ type = DataType(prop->value());
+ }
+
+ assert(type != DataType::NIL);
+
+ if (has_diskstream) {
+ if (type == DataType::AUDIO) {
+ boost::shared_ptr<Route> ret (new AudioTrack (*this, node, version));
+ return ret;
+ } else {
+ boost::shared_ptr<Route> ret (new MidiTrack (*this, node, version));
+ return ret;
+ }
} else {
- boost::shared_ptr<Route> x (new Route (*this, node));
- return x;
+ boost::shared_ptr<Route> ret (new Route (*this, node));
+ return ret;
}
}
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
- boost::shared_ptr<AudioRegion> region;
+ boost::shared_ptr<Region> region;
nlist = node.children();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if ((region = XMLRegionFactory (**niter, false)) == 0) {
- error << _("Session: cannot create Region from XML description.") << endmsg;
+ error << _("Session: cannot create Region from XML description.");
+ const XMLProperty *name = (**niter).property("name");
+
+ if (name) {
+ error << " " << string_compose (_("Can not load state for region '%1'"), name->value());
+ }
+
+ error << endmsg;
}
}
return 0;
}
-boost::shared_ptr<AudioRegion>
+boost::shared_ptr<Region>
Session::XMLRegionFactory (const XMLNode& node, bool full)
+{
+ const XMLProperty* type = node.property("type");
+
+ try {
+
+ if ( !type || type->value() == "audio" ) {
+
+ return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
+
+ } else if (type->value() == "midi") {
+
+ return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
+
+ }
+
+ } catch (failed_constructor& err) {
+ return boost::shared_ptr<Region> ();
+ }
+
+ return boost::shared_ptr<Region> ();
+}
+
+boost::shared_ptr<AudioRegion>
+Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
{
const XMLProperty* prop;
boost::shared_ptr<Source> source;
boost::shared_ptr<AudioSource> as;
SourceList sources;
+ SourceList master_sources;
uint32_t nchans = 1;
char buf[128];
-
+
if (node.name() != X_("Region")) {
return boost::shared_ptr<AudioRegion>();
}
nchans = atoi (prop->value().c_str());
}
-
if ((prop = node.property ("name")) == 0) {
cerr << "no name for this region\n";
abort ();
}
-
+
if ((prop = node.property (X_("source-0"))) == 0) {
if ((prop = node.property ("source")) == 0) {
error << _("Session: XMLNode describing a AudioRegion is incomplete (no source)") << endmsg;
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
return boost::shared_ptr<AudioRegion>();
}
-
+
as = boost::dynamic_pointer_cast<AudioSource>(source);
if (!as) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
for (uint32_t n=1; n < nchans; ++n) {
snprintf (buf, sizeof(buf), X_("source-%d"), n);
if ((prop = node.property (buf)) != 0) {
-
+
PBD::ID id2 (prop->value());
-
+
if ((source = source_by_id (id2)) == 0) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
return boost::shared_ptr<AudioRegion>();
}
-
+
as = boost::dynamic_pointer_cast<AudioSource>(source);
if (!as) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
sources.push_back (as);
}
}
-
+
+ for (uint32_t n = 0; n < nchans; ++n) {
+ snprintf (buf, sizeof(buf), X_("master-source-%d"), n);
+ if ((prop = node.property (buf)) != 0) {
+
+ PBD::ID id2 (prop->value());
+
+ if ((source = source_by_id (id2)) == 0) {
+ error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
+ return boost::shared_ptr<AudioRegion>();
+ }
+
+ as = boost::dynamic_pointer_cast<AudioSource>(source);
+ if (!as) {
+ error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
+ return boost::shared_ptr<AudioRegion>();
+ }
+ master_sources.push_back (as);
+ }
+ }
+
try {
boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, node)));
}
}
+ if (!master_sources.empty()) {
+ if (master_sources.size() != nchans) {
+ error << _("Session: XMLNode describing an AudioRegion is missing some master sources; ignored") << endmsg;
+ } else {
+ region->set_master_sources (master_sources);
+ }
+ }
return region;
-
+
}
catch (failed_constructor& err) {
}
}
+boost::shared_ptr<MidiRegion>
+Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
+{
+ const XMLProperty* prop;
+ boost::shared_ptr<Source> source;
+ boost::shared_ptr<MidiSource> ms;
+ SourceList sources;
+ uint32_t nchans = 1;
+
+ if (node.name() != X_("Region")) {
+ return boost::shared_ptr<MidiRegion>();
+ }
+
+ if ((prop = node.property (X_("channels"))) != 0) {
+ nchans = atoi (prop->value().c_str());
+ }
+
+ if ((prop = node.property ("name")) == 0) {
+ cerr << "no name for this region\n";
+ abort ();
+ }
+
+ // Multiple midi channels? that's just crazy talk
+ assert(nchans == 1);
+
+ if ((prop = node.property (X_("source-0"))) == 0) {
+ if ((prop = node.property ("source")) == 0) {
+ error << _("Session: XMLNode describing a MidiRegion is incomplete (no source)") << endmsg;
+ return boost::shared_ptr<MidiRegion>();
+ }
+ }
+
+ PBD::ID s_id (prop->value());
+
+ if ((source = source_by_id (s_id)) == 0) {
+ error << string_compose(_("Session: XMLNode describing a MidiRegion references an unknown source id =%1"), s_id) << endmsg;
+ return boost::shared_ptr<MidiRegion>();
+ }
+
+ ms = boost::dynamic_pointer_cast<MidiSource>(source);
+ if (!ms) {
+ error << string_compose(_("Session: XMLNode describing a MidiRegion references a non-midi source id =%1"), s_id) << endmsg;
+ return boost::shared_ptr<MidiRegion>();
+ }
+
+ sources.push_back (ms);
+
+ try {
+ boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion> (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;
+ }
+
+ catch (failed_constructor& err) {
+ return boost::shared_ptr<MidiRegion>();
+ }
+}
+
XMLNode&
Session::get_sources_as_xml ()
{
XMLNode* node = new XMLNode (X_("Sources"));
- Glib::Mutex::Lock lm (audio_source_lock);
+ Glib::Mutex::Lock lm (source_lock);
- for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
node->add_child_nocopy (i->second->get_state());
}
- /* XXX get MIDI and other sources here */
-
return *node;
}
string
-Session::path_from_region_name (string name, string identifier)
+Session::path_from_region_name (DataType type, string name, string identifier)
{
char buf[PATH_MAX+1];
uint32_t n;
- string dir = discover_best_sound_dir ();
+ SessionDirectory sdir(get_best_session_directory_for_new_source());
+ sys::path source_dir = ((type == DataType::AUDIO)
+ ? sdir.sound_path() : sdir.midi_path());
+
+ string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid");
for (n = 0; n < 999999; ++n) {
if (identifier.length()) {
- snprintf (buf, sizeof(buf), "%s/%s%s%" PRIu32 ".wav", dir.c_str(), name.c_str(),
- identifier.c_str(), n);
+ snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
+ identifier.c_str(), n, ext.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s/%s-%" PRIu32 ".wav", dir.c_str(), name.c_str(), n);
+ snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(),
+ n, ext.c_str());
}
- if (!g_file_test (buf, G_FILE_TEST_EXISTS)) {
- return buf;
+ sys::path source_path = source_dir / buf;
+
+ if (!sys::exists (source_path)) {
+ return source_path.to_string();
}
}
return "";
}
-
+
int
Session::load_sources (const XMLNode& node)
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
try {
if ((source = XMLSourceFactory (**niter)) == 0) {
error << _("Session: cannot create Source from XML description.") << endmsg;
}
- }
-
- catch (non_existent_source& err) {
+ } catch (MissingSource& 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);
+ /* note: do peak building in another thread when loading session state */
+ return SourceFactory::create (*this, node, true);
}
catch (failed_constructor& err) {
Session::save_template (string template_name)
{
XMLTree tree;
- string xml_path, bak_path, template_path;
if (_state_of_the_state & CannotSave) {
return -1;
}
- DIR* dp;
- string dir = template_dir();
+ sys::path user_template_dir(user_template_directory());
- if ((dp = opendir (dir.c_str()))) {
- closedir (dp);
- } else {
- if (g_mkdir_with_parents (dir.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
- error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
- return -1;
- }
+ try
+ {
+ sys::create_directories (user_template_dir);
+ }
+ catch(sys::filesystem_error& ex)
+ {
+ error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"),
+ user_template_dir.to_string(), ex.what()) << endmsg;
+ return -1;
}
tree.set_root (&get_template());
- xml_path = dir;
- xml_path += template_name;
- xml_path += _template_suffix;
+ sys::path template_file_path(user_template_dir);
+ template_file_path /= template_name + template_suffix;
- ifstream in(xml_path.c_str());
-
- if (in) {
- warning << string_compose(_("Template \"%1\" already exists - new version not created"), template_name) << endmsg;
+ if (sys::exists (template_file_path))
+ {
+ warning << string_compose(_("Template \"%1\" already exists - new version not created"),
+ template_file_path.to_string()) << endmsg;
return -1;
- } else {
- in.close();
}
- if (!tree.write (xml_path)) {
+ if (!tree.write (template_file_path.to_string())) {
error << _("mix template not saved") << endmsg;
return -1;
}
}
int
-Session::rename_template (string old_name, string new_name)
+Session::rename_template (string old_name, string new_name)
{
- string old_path = template_dir() + old_name + _template_suffix;
- string new_path = template_dir() + new_name + _template_suffix;
+ sys::path old_path (user_template_directory());
+ old_path /= old_name + template_suffix;
+
+ sys::path new_path(user_template_directory());
+ new_path /= new_name + template_suffix;
- return rename (old_path.c_str(), new_path.c_str());
+ if (sys::exists (new_path)) {
+ warning << string_compose(_("Template \"%1\" already exists - template not renamed"),
+ new_path.to_string()) << endmsg;
+ return -1;
+ }
+
+ try {
+ sys::rename (old_path, new_path);
+ return 0;
+ } catch (...) {
+ return -1;
+ }
}
int
-Session::delete_template (string name)
+Session::delete_template (string name)
{
- string template_path = template_dir();
- template_path += name;
- template_path += _template_suffix;
+ sys::path path = user_template_directory();
+ path /= name + template_suffix;
- return remove (template_path.c_str());
+ try {
+ sys::remove (path);
+ return 0;
+ } catch (...) {
+ return -1;
+ }
}
void
/* get freespace on every FS that is part of the session path */
_total_free_4k_blocks = 0;
-
+
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
statfs ((*i).path.c_str(), &statfsbuf);
#endif
}
-int
-Session::ensure_sound_dir (string path, string& result)
-{
- string dead;
- string peak;
-
- /* Ensure that the parent directory exists */
-
- if (g_mkdir_with_parents (path.c_str(), 0775)) {
- error << string_compose(_("cannot create session directory \"%1\"; ignored"), path) << endmsg;
- return -1;
- }
-
- /* Ensure that the sounds directory exists */
-
- result = path;
- result += '/';
- result += sound_dir_name;
-
- if (g_mkdir_with_parents (result.c_str(), 0775)) {
- error << string_compose(_("cannot create sounds directory \"%1\"; ignored"), result) << endmsg;
- return -1;
- }
-
- dead = path;
- dead += '/';
- dead += dead_sound_dir_name;
-
- if (g_mkdir_with_parents (dead.c_str(), 0775)) {
- error << string_compose(_("cannot create dead sounds directory \"%1\"; ignored"), dead) << endmsg;
- return -1;
- }
-
- peak = path;
- peak += '/';
- peak += peak_dir_name;
-
- if (g_mkdir_with_parents (peak.c_str(), 0775)) {
- error << string_compose(_("cannot create peak file directory \"%1\"; ignored"), peak) << endmsg;
- return -1;
- }
-
- /* callers expect this to be terminated ... */
-
- result += '/';
- return 0;
-}
-
string
-Session::discover_best_sound_dir (bool destructive)
+Session::get_best_session_directory_for_new_source ()
{
vector<space_and_path>::iterator i;
- string result;
+ string result = _session_dir->root_path().to_string();
/* handle common case without system calls */
if (session_dirs.size() == 1) {
- return sound_dir();
+ return result;
}
/* OK, here's the algorithm we're following here:
-
- We want to select which directory to use for
+
+ We want to select which directory to use for
the next file source to be created. Ideally,
we'd like to use a round-robin process so as to
get maximum performance benefits from splitting
So, we use a user-configurable space threshold. If
there are at least 2 filesystems with more than this
- much space available, we use RR selection between them.
+ much space available, we use RR selection between them.
If not, then we pick the filesystem with the most space.
This gets a good balance between the two
- approaches.
+ approaches.
*/
-
+
refresh_disk_space ();
-
+
int free_enough = 0;
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
}
if (free_enough >= 2) {
-
- bool found_it = false;
-
/* use RR selection process, ensuring that the one
picked works OK.
*/
}
if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) {
- if (ensure_sound_dir ((*i).path, result) == 0) {
+ if (create_session_directory ((*i).path)) {
+ result = (*i).path;
last_rr_session_dir = i;
- found_it = true;
- break;
+ return result;
}
}
} while (i != last_rr_session_dir);
- if (!found_it) {
- result = sound_dir();
- }
-
} else {
/* pick FS with the most freespace (and that
seems to actually work ...)
*/
-
+
vector<space_and_path> sorted;
space_and_path_ascending_cmp cmp;
sorted = session_dirs;
sort (sorted.begin(), sorted.end(), cmp);
-
+
for (i = sorted.begin(); i != sorted.end(); ++i) {
- if (ensure_sound_dir ((*i).path, result) == 0) {
+ if (create_session_directory ((*i).path)) {
+ result = (*i).path;
last_rr_session_dir = i;
- break;
+ return result;
}
}
-
- /* if the above fails, fall back to the most simplistic solution */
-
- if (i == sorted.end()) {
- return sound_dir();
- }
}
return result;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
error << _("Session: cannot create Playlist from XML description.") << endmsg;
}
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
error << _("Session: cannot create Playlist from XML description.") << endmsg;
continue;
return 0;
}
-
boost::shared_ptr<Playlist>
Session::XMLPlaylistFactory (const XMLNode& node)
{
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((ns = XMLNamedSelectionFactory (**niter)) == 0) {
error << _("Session: cannot create Named Selection from XML description.") << endmsg;
}
}
}
-string
-Session::dead_sound_dir () const
-{
- string res = _path;
- res += dead_sound_dir_name;
-
- return res;
-}
-
-string
-Session::old_sound_dir (bool with_path) const
-{
- string res;
-
- if (with_path) {
- res = _path;
- }
-
- res += old_sound_dir_name;
-
- 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 += '/';
- res += legalize_for_path (_name);
- res += '/';
- res += sound_dir_name;
-
- 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;
-}
-
-string
-Session::peak_dir () const
-{
- string res = _path;
- res += peak_dir_name;
- res += '/';
- return res;
-}
-
string
Session::automation_dir () const
{
- string res = _path;
- res += "automation/";
- return res;
+ return Glib::build_filename (_path, "automation");
}
string
-Session::template_dir ()
+Session::analysis_dir () const
{
- string path = get_user_ardour_path();
- path += "templates/";
-
- 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)
-{
- string path;
-
- path += get_user_ardour_path();
- if (path[path.length()-1] != ':') {
- path += ':';
- }
-
- if (data) {
- path += get_system_data_path();
- } else {
- path += get_system_module_path();
- }
-
- vector<string> split_path;
-
- split (path, split_path, ':');
- path = "";
-
- for (vector<string>::iterator i = split_path.begin(); i != split_path.end(); ++i) {
- path += *i;
- path += suffix;
- path += '/';
-
- if (distance (i, split_path.end()) != 1) {
- path += ':';
- }
- }
-
- return path;
-}
-
-string
-Session::template_path ()
-{
- return suffixed_search_path (X_("templates"), true);
-}
-
-string
-Session::control_protocol_path ()
-{
- return suffixed_search_path (X_("surfaces"), false);
+ return Glib::build_filename (_path, "analysis");
}
int
-Session::load_connections (const XMLNode& node)
+Session::load_bundles (XMLNode const & node)
{
XMLNodeList nlist = node.children();
XMLNodeConstIterator niter;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == "InputConnection") {
- add_connection (new ARDOUR::InputConnection (**niter));
- } else if ((*niter)->name() == "OutputConnection") {
- add_connection (new ARDOUR::OutputConnection (**niter));
+ if ((*niter)->name() == "InputBundle") {
+ add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, true)));
+ } else if ((*niter)->name() == "OutputBundle") {
+ add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
} else {
- error << string_compose(_("Unknown node \"%1\" found in Connections list from state file"), (*niter)->name()) << endmsg;
+ error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg;
return -1;
}
}
return 0;
-}
-
-int
-Session::load_edit_groups (const XMLNode& node)
-{
- return load_route_groups (node, true);
-}
-
-int
-Session::load_mix_groups (const XMLNode& node)
-{
- return load_route_groups (node, false);
}
int
-Session::load_route_groups (const XMLNode& node, bool edit)
+Session::load_route_groups (const XMLNode& node, int version)
{
XMLNodeList nlist = node.children();
XMLNodeConstIterator niter;
- RouteGroup* rg;
- set_dirty();
+ set_dirty ();
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == "RouteGroup") {
- if (edit) {
- rg = add_edit_group ("");
- rg->set_state (**niter);
- } else {
- rg = add_mix_group ("");
- rg->set_state (**niter);
+ if (version >= 3000) {
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "RouteGroup") {
+ RouteGroup* rg = new RouteGroup (*this, "");
+ add_route_group (rg);
+ rg->set_state (**niter, version);
+ }
+ }
+
+ } else if (version < 3000) {
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "EditGroup" || (*niter)->name() == "MixGroup") {
+ RouteGroup* rg = new RouteGroup (*this, "");
+ add_route_group (rg);
+ rg->set_state (**niter, version);
}
}
}
-
+
return 0;
-}
+}
+
+void
+Session::auto_save()
+{
+ save_state (_current_snapshot_name);
+}
static bool
-state_file_filter (const string &str, void *arg)
+state_file_filter (const string &str, void */*arg*/)
{
- return (str.length() > strlen(Session::statefile_suffix()) &&
- str.find (Session::statefile_suffix()) == (str.length() - strlen (Session::statefile_suffix())));
+ return (str.length() > strlen(statefile_suffix) &&
+ str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
}
struct string_cmp {
remove_end(string* state)
{
string statename(*state);
-
+
string::size_type start,end;
if ((start = statename.find_last_of ('/')) != string::npos) {
statename = statename.substr (start+1);
}
-
+
if ((end = statename.rfind(".ardour")) == string::npos) {
end = statename.length();
}
}
vector<string *> *
-Session::possible_states (string path)
+Session::possible_states (string path)
{
PathScanner scanner;
vector<string*>* states = scanner (path, state_file_filter, 0, false, false);
-
+
transform(states->begin(), states->end(), states->begin(), remove_end);
-
+
string_cmp cmp;
sort (states->begin(), states->end(), cmp);
-
+
return states;
}
}
void
-Session::auto_save()
+Session::add_route_group (RouteGroup* g)
{
- save_state (_current_snapshot_name);
-}
-
-RouteGroup *
-Session::add_edit_group (string name)
-{
- RouteGroup* rg = new RouteGroup (*this, name);
- edit_groups.push_back (rg);
- edit_group_added (rg); /* EMIT SIGNAL */
- set_dirty();
- return rg;
-}
-
-RouteGroup *
-Session::add_mix_group (string name)
-{
- RouteGroup* rg = new RouteGroup (*this, name, RouteGroup::Relative);
- mix_groups.push_back (rg);
- mix_group_added (rg); /* EMIT SIGNAL */
- set_dirty();
- return rg;
-}
-
-void
-Session::remove_edit_group (RouteGroup& rg)
-{
- list<RouteGroup*>::iterator i;
-
- if ((i = find (edit_groups.begin(), edit_groups.end(), &rg)) != edit_groups.end()) {
- (*i)->apply (&Route::drop_edit_group, this);
- edit_groups.erase (i);
- edit_group_removed (); /* EMIT SIGNAL */
- }
-
- delete &rg;
+ _route_groups.push_back (g);
+ route_group_added (g); /* EMIT SIGNAL */
+ set_dirty ();
}
void
-Session::remove_mix_group (RouteGroup& rg)
+Session::remove_route_group (RouteGroup& rg)
{
list<RouteGroup*>::iterator i;
- if ((i = find (mix_groups.begin(), mix_groups.end(), &rg)) != mix_groups.end()) {
- (*i)->apply (&Route::drop_mix_group, this);
- mix_groups.erase (i);
- mix_group_removed (); /* EMIT SIGNAL */
- }
-
- delete &rg;
-}
-
-RouteGroup *
-Session::mix_group_by_name (string name)
-{
- list<RouteGroup *>::iterator i;
-
- for (i = mix_groups.begin(); i != mix_groups.end(); ++i) {
- if ((*i)->name() == name) {
- return* i;
- }
+ if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
+ (*i)->apply (&Route::drop_route_group, this);
+ _route_groups.erase (i);
+ route_group_removed (); /* EMIT SIGNAL */
}
- return 0;
+
+ delete &rg;
}
+
RouteGroup *
-Session::edit_group_by_name (string name)
+Session::route_group_by_name (string name)
{
list<RouteGroup *>::iterator i;
- for (i = edit_groups.begin(); i != edit_groups.end(); ++i) {
+ for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
}
void
-Session::begin_reversible_command (string name)
+Session::begin_reversible_command(const string& name)
{
- current_trans = new UndoTransaction;
- current_trans->set_name (name);
+ UndoTransaction* trans = new UndoTransaction();
+ trans->set_name(name);
+
+ if (!_current_trans.empty()) {
+ _current_trans.top()->add_command (trans);
+ } else {
+ _current_trans.push(trans);
+ }
}
void
-Session::commit_reversible_command (Command *cmd)
+Session::commit_reversible_command(Command *cmd)
{
+ assert(!_current_trans.empty());
struct timeval now;
if (cmd) {
- current_trans->add_command (cmd);
+ _current_trans.top()->add_command(cmd);
+ }
+
+ if (_current_trans.top()->empty()) {
+ _current_trans.pop();
+ return;
}
- gettimeofday (&now, 0);
- current_trans->set_timestamp (now);
+ gettimeofday(&now, 0);
+ _current_trans.top()->set_timestamp(now);
- _history.add (current_trans);
+ _history.add(_current_trans.top());
+ _current_trans.pop();
}
-Session::GlobalRouteBooleanState
+Session::GlobalRouteBooleanState
Session::get_global_route_boolean (bool (Route::*method)(void) const)
{
GlobalRouteBooleanState s;
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->hidden()) {
+ if (!(*i)->is_hidden()) {
RouteBooleanState v;
-
+
v.first =* i;
Route* r = (*i).get();
v.second = (r->*method)();
-
+
s.push_back (v);
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->hidden()) {
+ if (!(*i)->is_hidden()) {
RouteMeterState v;
-
+
v.first =* i;
v.second = (*i)->meter_point();
-
+
s.push_back (v);
}
}
}
void
-Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
+Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
{
for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) {
set_global_route_boolean (s, &Route::set_record_enable, src);
}
-#if 0
-UndoAction
-Session::global_mute_memento (void* src)
-{
- return sigc::bind (mem_fun (*this, &Session::set_global_mute), get_global_route_boolean (&Route::muted), src);
-}
-
-UndoAction
-Session::global_metering_memento (void* src)
-{
- return sigc::bind (mem_fun (*this, &Session::set_global_route_metering), get_global_route_metering (), src);
-}
-
-UndoAction
-Session::global_solo_memento (void* src)
-{
- return sigc::bind (mem_fun (*this, &Session::set_global_solo), get_global_route_boolean (&Route::soloed), src);
-}
-
-UndoAction
-Session::global_record_enable_memento (void* src)
-{
- return sigc::bind (mem_fun (*this, &Session::set_global_record_enable), get_global_route_boolean (&Route::record_enabled), src);
-}
-#endif
-
-static bool
-template_filter (const string &str, void *arg)
-{
- return (str.length() > strlen(Session::template_suffix()) &&
- str.find (Session::template_suffix()) == (str.length() - strlen (Session::template_suffix())));
-}
-
-void
-Session::get_template_list (list<string> &template_names)
-{
- vector<string *> *templates;
- PathScanner scanner;
- string path;
-
- path = template_path ();
-
- templates = scanner (path, template_filter, 0, false, true);
-
- vector<string*>::iterator i;
- for (i = templates->begin(); i != templates->end(); ++i) {
- string fullpath = *(*i);
- int start, end;
-
- start = fullpath.find_last_of ('/') + 1;
- if ((end = fullpath.find_last_of ('.')) <0) {
- end = fullpath.length();
- }
-
- template_names.push_back(fullpath.substr(start, (end-start)));
- }
-}
-
-int
-Session::read_favorite_dirs (FavoriteDirs & favs)
-{
- string path = get_user_ardour_path();
- path += "/favorite_dirs";
-
- ifstream fav (path.c_str());
-
- favs.clear();
-
- if (!fav) {
- if (errno != ENOENT) {
- //error << string_compose (_("cannot open favorite file %1 (%2)"), path, strerror (errno)) << endmsg;
- return -1;
- } else {
- return 1;
- }
- }
-
- while (true) {
-
- string newfav;
-
- getline(fav, newfav);
-
- if (!fav.good()) {
- break;
- }
-
- favs.push_back (newfav);
- }
-
- return 0;
-}
-
-int
-Session::write_favorite_dirs (FavoriteDirs & favs)
-{
- string path = get_user_ardour_path();
- path += "/favorite_dirs";
-
- ofstream fav (path.c_str());
-
- if (!fav) {
- return -1;
- }
-
- for (FavoriteDirs::iterator i = favs.begin(); i != favs.end(); ++i) {
- fav << (*i) << endl;
- }
-
- return 0;
-}
-
static bool
-accept_all_non_peak_files (const string& path, void *arg)
+accept_all_non_peak_files (const string& path, void */*arg*/)
{
- return (path.length() > 5 && path.find (".peak") != (path.length() - 5));
+ return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
}
static bool
-accept_all_state_files (const string& path, void *arg)
+accept_all_state_files (const string& path, void */*arg*/)
{
return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
}
-int
+int
Session::find_all_sources (string path, set<string>& result)
{
XMLTree tree;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
XMLProperty* prop;
+ if ((prop = (*niter)->property (X_("type"))) == 0) {
+ continue;
+ }
+
+ DataType type (prop->value());
+
if ((prop = (*niter)->property (X_("name"))) == 0) {
continue;
}
continue;
}
- string path = _path; /* /-terminated */
- path += sound_dir_name;
- path += '/';
- path += prop->value();
+ Glib::ustring found_path;
+ bool is_new;
+ uint16_t chan;
- result.insert (path);
+ if (FileSource::find (type, prop->value(), true, is_new, chan, found_path)) {
+ result.insert (found_path);
+ }
}
return 0;
}
state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true);
-
+
if (state_files == 0) {
/* impossible! */
return 0;
}
this_snapshot_path = _path;
- this_snapshot_path += _current_snapshot_name;
- this_snapshot_path += _statefile_suffix;
+ this_snapshot_path += legalize_for_path (_current_snapshot_name);
+ this_snapshot_path += statefile_suffix;
for (vector<string*>::iterator i = state_files->begin(); i != state_files->end(); ++i) {
AudioSourceList::iterator iter;
boost::shared_ptr<Region> region;
uint32_t count;
-
+
RegionCounter() : count (0) {}
};
int
Session::cleanup_sources (Session::cleanup_report& rep)
{
+ // FIXME: needs adaptation to midi
+
vector<boost::shared_ptr<Source> > dead_sources;
vector<boost::shared_ptr<Playlist> > playlists_tbd;
PathScanner scanner;
bool used;
string spath;
int ret = -1;
-
+
_state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
-
+
+
/* step 1: consider deleting all unused playlists */
for (PlaylistList::iterator x = unused_playlists.begin(); x != unused_playlists.end(); ++x) {
rep.paths.clear ();
rep.space = 0;
- for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
-
- AudioSourceList::iterator tmp;
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
+
+ SourceMap::iterator tmp;
tmp = i;
++tmp;
capture files.
*/
- if (!i->second->used() && i->second->length() > 0) {
+ if (!i->second->used() && i->second->length(i->second->timeline_position()) > 0) {
dead_sources.push_back (i->second);
i->second->GoingAway();
- }
+ }
i = tmp;
}
nexti = i;
++nexti;
- sound_path += (*i).path;
- sound_path += sound_dir (false);
+ SessionDirectory sdir ((*i).path);
+ sound_path += sdir.sound_path().to_string();
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)
+ /* 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.
*/
state file on disk still references sources we may have already
dropped.
*/
-
+
find_all_sources_across_snapshots (all_sources, true);
/* add our current source list
*/
-
- for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
- boost::shared_ptr<AudioFileSource> fs;
-
- if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (i->second)) != 0) {
+
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ boost::shared_ptr<FileSource> fs;
+
+ if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
all_sources.insert (fs->path());
- }
+ }
}
+ 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;
}
}
string newpath;
-
+
/* don't move the file across filesystems, just
stick it in the `dead_sound_dir_name' directory
on whichever filesystem it was already on.
/* old school, go up 1 level */
- newpath = Glib::path_get_dirname (*x); // "sounds"
+ 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 (*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 += 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;
+ error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
return -1;
}
newpath += '/';
newpath += Glib::path_get_basename ((*x));
-
+
if (access (newpath.c_str(), F_OK) == 0) {
-
+
/* the new path already exists, try versioning */
-
+
char buf[PATH_MAX+1];
int version = 1;
string newpath_v;
-
+
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
newpath_v = buf;
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
newpath_v = buf;
}
-
+
if (version == 999) {
error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
newpath)
} else {
newpath = newpath_v;
}
-
+
} else {
-
+
/* it doesn't exist, or we can't read it or something */
-
+
}
if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
*/
string peakpath = (*x).substr (0, (*x).find_last_of ('.'));
- peakpath += ".peak";
+ peakpath += peakfile_suffix;
if (access (peakpath.c_str(), W_OK) == 0) {
if (::unlink (peakpath.c_str()) != 0) {
/* save state so we don't end up a session file
referring to non-existent sources.
*/
-
+
save_state ("");
out:
_state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
+
return ret;
}
int
Session::cleanup_trash_sources (Session::cleanup_report& rep)
{
+ // FIXME: needs adaptation for MIDI
+
vector<space_and_path>::iterator i;
string dead_sound_dir;
struct dirent* dentry;
rep.space = 0;
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
-
+
dead_sound_dir = (*i).path;
dead_sound_dir += dead_sound_dir_name;
while ((dentry = readdir (dead)) != 0) {
/* avoid '.' and '..' */
-
- if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
+
+ if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
(dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
continue;
}
}
closedir (dead);
-
+
}
return 0;
_state_of_the_state = StateOfTheState (_state_of_the_state | Dirty);
+
if (!was_dirty) {
DirtyChanged(); /* EMIT SIGNAL */
}
Session::set_clean ()
{
bool was_dirty = dirty();
-
+
_state_of_the_state = Clean;
+
if (was_dirty) {
DirtyChanged(); /* EMIT SIGNAL */
}
}
void
-Session::add_controllable (Controllable* c)
+Session::clear_deletion_in_progress ()
+{
+ _state_of_the_state = StateOfTheState (_state_of_the_state & (~Deletion));
+}
+
+void
+Session::add_controllable (boost::shared_ptr<Controllable> c)
{
/* this adds a controllable to the list managed by the Session.
this is a subset of those managed by the Controllable class
controllables.insert (c);
}
+struct null_deleter { void operator()(void const *) const {} };
+
void
Session::remove_controllable (Controllable* c)
{
Glib::Mutex::Lock lm (controllables_lock);
- Controllables::iterator x = controllables.find (c);
+ Controllables::iterator x = controllables.find(
+ boost::shared_ptr<Controllable>(c, null_deleter()));
if (x != controllables.end()) {
controllables.erase (x);
}
-}
+}
-Controllable*
+boost::shared_ptr<Controllable>
Session::controllable_by_id (const PBD::ID& id)
{
Glib::Mutex::Lock lm (controllables_lock);
-
+
for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
if ((*i)->id() == id) {
return *i;
}
}
- return 0;
+ return boost::shared_ptr<Controllable>();
}
-void
-Session::add_instant_xml (XMLNode& node, const std::string& dir)
+void
+Session::add_instant_xml (XMLNode& node, bool write_to_config)
{
- Stateful::add_instant_xml (node, dir);
- Config->add_instant_xml (node, get_user_ardour_path());
+ if (_writable) {
+ Stateful::add_instant_xml (node, _path);
+ }
+
+ if (write_to_config) {
+ Config->add_instant_xml (node);
+ }
}
+XMLNode*
+Session::instant_xml (const string& node_name)
+{
+ return Stateful::instant_xml (node_name, _path);
+}
-int
+int
Session::save_history (string snapshot_name)
{
- XMLTree tree;
- string xml_path;
- string bak_path;
+ XMLTree tree;
- tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
+ if (!_writable) {
+ return 0;
+ }
- if (snapshot_name.empty()) {
- snapshot_name = _current_snapshot_name;
- }
+ if (snapshot_name.empty()) {
+ snapshot_name = _current_snapshot_name;
+ }
- xml_path = _path + snapshot_name + ".history";
+ const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
+ const string backup_filename = history_filename + backup_suffix;
+ const sys::path xml_path = _session_dir->root_path() / history_filename;
+ const sys::path backup_path = _session_dir->root_path() / backup_filename;
- bak_path = xml_path + ".bak";
+ if (sys::exists (xml_path)) {
+ try
+ {
+ sys::rename (xml_path, backup_path);
+ }
+ catch (const sys::filesystem_error& err)
+ {
+ error << _("could not backup old history file, current history not saved") << endmsg;
+ return -1;
+ }
+ }
- if ((access (xml_path.c_str(), F_OK) == 0) &&
- (rename (xml_path.c_str(), bak_path.c_str())))
- {
- error << _("could not backup old history file, current history not saved.") << endmsg;
- return -1;
- }
+ if (!Config->get_save_history() || Config->get_saved_history_depth() < 0) {
+ return 0;
+ }
- if (!tree.write (xml_path))
- {
- error << string_compose (_("history could not be saved to %1"), xml_path) << endmsg;
+ tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
- /* don't leave a corrupt file lying around if it is
- * possible to fix.
- */
+ if (!tree.write (xml_path.to_string()))
+ {
+ error << string_compose (_("history could not be saved to %1"), xml_path.to_string()) << endmsg;
- if (unlink (xml_path.c_str())) {
- error << string_compose (_("could not remove corrupt history file %1"), xml_path) << endmsg;
- } else {
- if (rename (bak_path.c_str(), xml_path.c_str()))
+ try
{
- error << string_compose (_("could not restore history file from backup %1"), bak_path) << endmsg;
+ sys::remove (xml_path);
+ sys::rename (backup_path, xml_path);
+ }
+ catch (const sys::filesystem_error& err)
+ {
+ error << string_compose (_("could not restore history file from backup %1 (%2)"),
+ backup_path.to_string(), err.what()) << endmsg;
}
- }
- return -1;
- }
+ return -1;
+ }
- return 0;
+ return 0;
}
int
Session::restore_history (string snapshot_name)
{
- 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 (access (xmlpath.c_str(), F_OK)) {
- info << string_compose (_("%1: no history file \"%2\" for this session."), _name, xmlpath) << endmsg;
- return 1;
- }
-
- if (!tree.read (xmlpath)) {
- error << string_compose (_("Could not understand session history file \"%1\""), xmlpath) << endmsg;
- return -1;
- }
-
- /* replace history */
- _history.clear();
-
- for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
-
- XMLNode *t = *it;
- UndoTransaction* ut = new UndoTransaction ();
- struct timeval tv;
-
- ut->set_name(t->property("name")->value());
- stringstream ss(t->property("tv_sec")->value());
- ss >> tv.tv_sec;
- ss.str(t->property("tv_usec")->value());
- ss >> tv.tv_usec;
- ut->set_timestamp(tv);
-
- for (XMLNodeConstIterator child_it = t->children().begin();
- child_it != t->children().end();
- child_it++)
- {
- XMLNode *n = *child_it;
- Command *c;
-
- if (n->name() == "MementoCommand" ||
- n->name() == "MementoUndoCommand" ||
- n->name() == "MementoRedoCommand") {
+ XMLTree tree;
+
+ if (snapshot_name.empty()) {
+ snapshot_name = _current_snapshot_name;
+ }
+
+ const string xml_filename = legalize_for_path (snapshot_name) + history_suffix;
+ const sys::path xml_path = _session_dir->root_path() / xml_filename;
+
+ info << "Loading history from " << xml_path.to_string() << endmsg;
+
+ if (!sys::exists (xml_path)) {
+ info << string_compose (_("%1: no history file \"%2\" for this session."),
+ _name, xml_path.to_string()) << endmsg;
+ return 1;
+ }
+
+ if (!tree.read (xml_path.to_string())) {
+ error << string_compose (_("Could not understand session history file \"%1\""),
+ xml_path.to_string()) << endmsg;
+ return -1;
+ }
+
+ // replace history
+ _history.clear();
+
+ for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
+
+ XMLNode *t = *it;
+ UndoTransaction* ut = new UndoTransaction ();
+ struct timeval tv;
+
+ ut->set_name(t->property("name")->value());
+ stringstream ss(t->property("tv-sec")->value());
+ ss >> tv.tv_sec;
+ ss.str(t->property("tv-usec")->value());
+ ss >> tv.tv_usec;
+ ut->set_timestamp(tv);
+
+ for (XMLNodeConstIterator child_it = t->children().begin();
+ child_it != t->children().end(); child_it++)
+ {
+ XMLNode *n = *child_it;
+ Command *c;
+
+ 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 = 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);
+ }
- if ((c = global_state_command_factory (*n))) {
- ut->add_command (c);
- }
-
- } else {
+ } else if (n->name() == "DeltaCommand") {
+ PBD::ID id(n->property("midi-source")->value());
+ boost::shared_ptr<MidiSource> midi_source =
+ boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+ if (midi_source) {
+ ut->add_command(new MidiModel::DeltaCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+ }
+
+ } else if (n->name() == "DiffCommand") {
+ PBD::ID id(n->property("midi-source")->value());
+ boost::shared_ptr<MidiSource> midi_source =
+ boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+ if (midi_source) {
+ ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+ }
- error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
- }
- }
+ } else {
+ error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
+ }
+ }
- _history.add (ut);
- }
+ _history.add (ut);
+ }
- return 0;
+ return 0;
}
void
-Session::config_changed (const char* parameter_name)
+Session::config_changed (std::string p, bool ours)
{
-#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+ if (ours) {
+ set_dirty ();
+ }
- if (PARAM_IS ("seamless-loop")) {
-
- } else if (PARAM_IS ("rf-speed")) {
-
- } else if (PARAM_IS ("auto-loop")) {
-
- } else if (PARAM_IS ("auto-input")) {
+ if (p == "seamless-loop") {
+
+ } else if (p == "rf-speed") {
+
+ } else if (p == "auto-loop") {
+
+ } else if (p == "auto-input") {
if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
/* auto-input only makes a difference if we're rolling */
-
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
+
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
- (*i)->monitor_input (!Config->get_auto_input());
+ (*i)->monitor_input (!config.get_auto_input());
}
}
}
- } else if (PARAM_IS ("punch-in")) {
+ } else if (p == "punch-in") {
Location* location;
-
+
if ((location = _locations.auto_punch_location()) != 0) {
-
- if (Config->get_punch_in ()) {
+
+ if (config.get_punch_in ()) {
replace_event (Event::PunchIn, location->start());
} else {
remove_event (location->start(), Event::PunchIn);
}
}
-
- } else if (PARAM_IS ("punch-out")) {
+
+ } else if (p == "punch-out") {
Location* location;
-
+
if ((location = _locations.auto_punch_location()) != 0) {
-
- if (Config->get_punch_out()) {
+
+ if (config.get_punch_out()) {
replace_event (Event::PunchOut, location->end());
} else {
clear_events (Event::PunchOut);
}
}
- } else if (PARAM_IS ("edit-mode")) {
+ } else if (p == "edit-mode") {
Glib::Mutex::Lock lm (playlist_lock);
-
+
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
(*i)->set_edit_mode (Config->get_edit_mode ());
}
- } else if (PARAM_IS ("use-video-sync")) {
+ } else if (p == "use-video-sync") {
- if (transport_stopped()) {
- if (Config->get_use_video_sync()) {
- waiting_for_sync_offset = true;
- }
- }
+ waiting_for_sync_offset = config.get_use_video_sync();
- } else if (PARAM_IS ("mmc-control")) {
+ } else if (p == "mmc-control") {
- poke_midi_thread ();
+ //poke_midi_thread ();
- } else if (PARAM_IS ("mmc-device-id")) {
+ } else if (p == "mmc-device-id" || p == "mmc-receive-id") {
if (mmc) {
- mmc->set_device_id (Config->get_mmc_device_id());
+ mmc->set_receive_device_id (Config->get_mmc_receive_device_id());
}
- } else if (PARAM_IS ("midi-control")) {
-
- poke_midi_thread ();
+ } else if (p == "mmc-send-id") {
+
+ if (mmc) {
+ mmc->set_send_device_id (Config->get_mmc_send_device_id());
+ }
+
+ } else if (p == "midi-control") {
- } else if (PARAM_IS ("raid-path")) {
+ //poke_midi_thread ();
- setup_raid_path (Config->get_raid_path());
+ } else if (p == "raid-path") {
- } else if (PARAM_IS ("smpte-format")) {
+ setup_raid_path (config.get_raid_path());
+
+ } else if (p == "smpte-format") {
sync_time_vars ();
- } else if (PARAM_IS ("video-pullup")) {
+ } else if (p == "video-pullup") {
sync_time_vars ();
- } else if (PARAM_IS ("seamless-loop")) {
+ } else if (p == "seamless-loop") {
if (play_loop && transport_rolling()) {
// to reset diskstreams etc
request_play_loop (true);
}
- } else if (PARAM_IS ("rf-speed")) {
+ } else if (p == "rf-speed") {
cumulative_rf_motion = 0;
reset_rf_scale (0);
- } else if (PARAM_IS ("click-sound")) {
+ } else if (p == "click-sound") {
setup_click_sounds (1);
- } else if (PARAM_IS ("click-emphasis-sound")) {
+ } else if (p == "click-emphasis-sound") {
setup_click_sounds (-1);
- } else if (PARAM_IS ("clicking")) {
+ } else if (p == "clicking") {
if (Config->get_clicking()) {
if (_click_io && click_data) { // don't require emphasis data
_clicking = false;
}
- } else if (PARAM_IS ("send-mtc")) {
-
+ } else if (p == "send-mtc") {
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mtc_port != 0) {
session_send_mtc = Config->get_send_mtc();
if (session_send_mtc) {
session_send_mtc = false;
}
- } else if (PARAM_IS ("send-mmc")) {
-
+ } else if (p == "send-mmc") {
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mmc_port != 0) {
session_send_mmc = Config->get_send_mmc();
} else {
mmc = 0;
- session_send_mmc = false;
+ session_send_mmc = false;
}
- } else if (PARAM_IS ("midi-feedback")) {
-
+ } else if (p == "midi-feedback") {
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mtc_port != 0) {
session_midi_feedback = Config->get_midi_feedback();
}
- } else if (PARAM_IS ("jack-time-master")) {
+ } else if (p == "jack-time-master") {
engine().reset_timebase ();
- } else if (PARAM_IS ("native-file-header-format")) {
+ } else if (p == "native-file-header-format") {
if (!first_file_header_format_reset) {
reset_native_file_format ();
first_file_header_format_reset = false;
- } else if (PARAM_IS ("native-file-data-format")) {
+ } else if (p == "native-file-data-format") {
if (!first_file_data_format_reset) {
reset_native_file_format ();
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")) {
+ } else if (p == "slave-source") {
+ set_slave_source (Config->get_slave_source());
+ } else if (p == "remote-model") {
set_remote_control_ids ();
+ } else if (p == "denormal-model") {
+ setup_fpu ();
+ } else if (p == "history-depth") {
+ set_history_depth (Config->get_history_depth());
+ } else if (p == "sync-all-route-ordering") {
+ sync_order_keys ("session");
+ } else if (p == "initial-program-change") {
+
+ if (_mmc_port && Config->get_initial_program_change() >= 0) {
+ MIDI::byte buf[2];
+
+ buf[0] = MIDI::program; // channel zero by default
+ buf[1] = (Config->get_initial_program_change() & 0x7f);
+
+ _mmc_port->midimsg (buf, sizeof (buf), 0);
+ }
+ } else if (p == "initial-program-change") {
+
+ if (_mmc_port && Config->get_initial_program_change() >= 0) {
+ MIDI::byte* buf = new MIDI::byte[2];
+
+ buf[0] = MIDI::program; // channel zero by default
+ buf[1] = (Config->get_initial_program_change() & 0x7f);
+ // deliver_midi (_mmc_port, buf, 2);
+ }
+ } else if (p == "solo-mute-override") {
+ // catch_up_on_solo_mute_override ();
+ } else if (p == "listen-position") {
+ listen_position_changed ();
+ } else if (p == "solo-control-is-listen-control") {
+ solo_control_mode_changed ();
}
+
set_dirty ();
-
-#undef PARAM_IS
+}
+void
+Session::set_history_depth (uint32_t d)
+{
+ _history.set_depth (d);
}
projects / ardour.git / blobdiff