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.
#include "libardour-config.h"
#endif
-#define __STDC_FORMAT_MACROS 1
#include <stdint.h>
#include <algorithm>
#include <signal.h>
#include <sys/mman.h>
#include <sys/time.h>
-#include <dirent.h>
#ifdef HAVE_SYS_VFS_H
#include <sys/vfs.h>
#include "midi++/mmc.h"
#include "midi++/port.h"
+#include "midi++/manager.h"
#include "pbd/boost_debug.h"
+#include "pbd/basename.h"
#include "pbd/controllable_descriptor.h"
#include "pbd/enumwriter.h"
#include "pbd/error.h"
#include "pbd/search_path.h"
#include "pbd/stacktrace.h"
#include "pbd/convert.h"
+#include "pbd/clear_dir.h"
#include "ardour/amp.h"
#include "ardour/audio_diskstream.h"
#include "ardour/audioplaylist.h"
#include "ardour/audioregion.h"
#include "ardour/auditioner.h"
+#include "ardour/automation_control.h"
#include "ardour/buffer.h"
#include "ardour/butler.h"
#include "ardour/configuration.h"
#include "ardour/midi_source.h"
#include "ardour/midi_track.h"
#include "ardour/named_selection.h"
+#include "ardour/pannable.h"
#include "ardour/processor.h"
#include "ardour/port.h"
+#include "ardour/proxy_controllable.h"
#include "ardour/region_factory.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
using namespace ARDOUR;
using namespace PBD;
+
void
Session::first_stage_init (string fullpath, string snapshot_name)
{
_path = string(buf);
- if (_path[_path.length()-1] != '/') {
- _path += '/';
- }
-
- if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
- _writable = false;
- } else {
- _writable = true;
+ if (_path[_path.length()-1] != G_DIR_SEPARATOR) {
+ _path += G_DIR_SEPARATOR;
}
/* these two are just provisional settings. set_state()
_state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
_was_seamless = Config->get_seamless_loop ();
_slave = 0;
- session_send_mmc = false;
- session_send_mtc = false;
+ _send_qf_mtc = false;
+ _pframes_since_last_mtc = 0;
g_atomic_int_set (&_playback_load, 100);
g_atomic_int_set (&_capture_load, 100);
_play_range = false;
first_file_header_format_reset = true;
post_export_sync = false;
midi_control_ui = 0;
+ _step_editors = 0;
+ no_questions_about_missing_files = false;
+ _speakers.reset (new Speakers);
AudioDiskstream::allocate_working_buffers();
/* default short fade = 15ms */
- Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate()));
+ Crossfade::set_short_xfade_length ((framecnt_t) floor (config.get_short_xfade_seconds() * frame_rate()));
SndFileSource::setup_standard_crossfades (*this, frame_rate());
last_mmc_step.tv_sec = 0;
}
last_timecode_when = 0;
- _timecode_offset = 0;
- _timecode_offset_negative = true;
last_timecode_valid = false;
sync_time_vars ();
last_rr_session_dir = session_dirs.begin();
refresh_disk_space ();
- // set_default_fade (0.2, 5.0); /* steepness, millisecs */
+ /* default: assume simple stereo speaker configuration */
+
+ _speakers->setup_default_speakers (2);
/* slave stuff */
delta_accumulator_cnt = 0;
_slave_state = Stopped;
+ _solo_cut_control.reset (new ProxyControllable (_("solo cut control (dB)"), PBD::Controllable::GainLike,
+ boost::bind (&RCConfiguration::set_solo_mute_gain, Config, _1),
+ boost::bind (&RCConfiguration::get_solo_mute_gain, Config)));
+ add_controllable (_solo_cut_control);
+
_engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
/* These are all static "per-class" signals */
if (load_state (_current_snapshot_name)) {
return -1;
}
- remove_empty_sounds ();
}
if (_butler->start_thread()) {
return -1;
}
+ setup_midi_machine_control ();
+
// set_state() will call setup_raid_path(), but if it's a new session we need
// to call setup_raid_path() here.
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
-
- _locations.changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
- _locations.added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));
+ _locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
+ _locations->added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));
setup_click_sounds (0);
setup_midi_control ();
send_full_time_code (0);
_engine.transport_locate (0);
- deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
- deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
+
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset));
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (Timecode::Time ()));
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);
-
_state_of_the_state = Clean;
Port::set_connecting_blocked (false);
midi_search_path += sdir.midi_path ();
}
- // 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();
}
return -1;
}
- dir = session_directory().dead_sound_path().to_string();
+ dir = session_directory().dead_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
+ dir = plugins_dir ();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session plugins folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
+
return 0;
}
+/** Caller must not hold process lock */
int
Session::create (const string& mix_template, BusProfile* bus_profile)
{
-
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;
return -1;
}
+ _writable = exists_and_writable (sys::path (_path));
+
if (!mix_template.empty()) {
std::string in_path = mix_template;
ifstream in(in_path.c_str());
- if (in){
+ if (in) {
string out_path = _path;
out_path += _name;
out_path += statefile_suffix;
ofstream out(out_path.c_str());
- if (out){
+ if (out) {
out << in.rdbuf();
_is_new = false;
return 0;
ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
if (bus_profile->master_out_channels) {
- Route* rt = new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO);
- if (rt->init ()) {
- delete rt;
+ boost::shared_ptr<Route> r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO));
+ if (r->init ()) {
return -1;
}
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
- boost::shared_ptr<Route> r (rt);
- r->input()->ensure_io (count, false, this);
- r->output()->ensure_io (count, false, this);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (rt.get(), "Route");
+#endif
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ r->input()->ensure_io (count, false, this);
+ r->output()->ensure_io (count, false, this);
+ }
r->set_remote_control_id (control_id++);
rl.push_back (r);
if (Config->get_use_monitor_bus()) {
- Route* rt = new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO);
- if (rt->init ()) {
- delete rt;
+ boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
+ if (r->init ()) {
return -1;
}
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
boost_debug_shared_ptr_mark_interesting (rt, "Route");
- boost::shared_ptr<Route> r (rt);
- r->input()->ensure_io (count, false, this);
- r->output()->ensure_io (count, false, this);
+#endif
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ r->input()->ensure_io (count, false, this);
+ r->output()->ensure_io (count, false, this);
+ }
r->set_remote_control_id (control_id);
rl.push_back (r);
}
if (!rl.empty()) {
- add_routes (rl, false);
+ add_routes (rl, false, false);
}
/* this allows the user to override settings with an environment variable.
jack_session_reply (_engine.jack(), event);
if (event->type == JackSessionSaveAndQuit) {
- // TODO: make ardour quit.
+ Quit (); /* EMIT SIGNAL */
}
jack_session_event_free( event );
}
#endif
+/** @param snapshot_name Name to save under, without .ardour / .pending prefix */
int
Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot)
{
set_dirty();
- /* 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;
- }
+ _writable = exists_and_writable (xmlpath);
if (!state_tree->read (xmlpath.to_string())) {
error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg;
if (full_state) {
node->add_property ("name", _name);
- snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate);
+ snprintf (buf, sizeof (buf), "%" PRId64, _nominal_frame_rate);
node->add_property ("sample-rate", buf);
if (session_dirs.size() > 1) {
snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
node->add_property ("id-counter", buf);
+ /* save the event ID counter */
+
+ snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter());
+ node->add_property ("event-counter", buf);
+
/* various options */
node->add_child_nocopy (config.get_variables ());
boost::shared_ptr<Region> r = i->second;
/* only store regions not attached to playlists */
if (r->playlist() == 0) {
- child->add_child_nocopy (r->state (true));
+ child->add_child_nocopy (r->state ());
}
}
}
if (full_state) {
- node->add_child_nocopy (_locations.get_state());
+ node->add_child_nocopy (_locations->get_state());
} else {
// for a template, just create a new Locations, populate it
// with the default start and end, and get the state for that.
- Locations loc;
- Location* range = new Location (0, 0, _("session"), Location::IsSessionRange);
- range->set (max_frames, 0);
+ Locations loc (*this);
+ Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
+ range->set (max_framepos, 0);
loc.add (range);
node->add_child_nocopy (loc.get_state());
}
}
}
+ node->add_child_nocopy (_speakers->get_state());
node->add_child_nocopy (_tempo_map->get_state());
-
node->add_child_nocopy (get_control_protocol_state());
if (_extra_xml) {
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
- if (node.name() != X_("Session")){
+ if (node.name() != X_("Session")) {
fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
return -1;
}
ID::init_counter (now);
}
+ if ((prop = node.property (X_("event-counter"))) != 0) {
+ Evoral::init_event_id_counter (atoi (prop->value()));
+ }
IO::disable_connecting ();
- /* Object loading order:
-
- Path
- Extra
- Options/Config
- MIDI Control // relies on data from Options/Config
- Metadata
- Locations
- Sources
- AudioRegions
- Connections
- Routes
- RouteGroups
- MixGroups
- Click
- ControlProtocols
- */
-
if ((child = find_named_node (node, "Extra")) != 0) {
_extra_xml = new XMLNode (*child);
}
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;
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, version)) {
+ } else if (_locations->set_state (*child, version)) {
goto out;
}
+ if ((child = find_named_node (node, X_("Speakers"))) != 0) {
+ _speakers->set_state (*child, version);
+ }
+
Location* location;
- if ((location = _locations.auto_loop_location()) != 0) {
+ if ((location = _locations->auto_loop_location()) != 0) {
set_auto_loop_location (location);
}
- if ((location = _locations.auto_punch_location()) != 0) {
+ if ((location = _locations->auto_punch_location()) != 0) {
set_auto_punch_location (location);
}
- if ((location = _locations.session_range_location()) != 0) {
+ if ((location = _locations->session_range_location()) != 0) {
delete _session_range_location;
_session_range_location = location;
}
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, version)) {
+ goto out;
+ }
+
if ((child = find_named_node (node, "Regions")) == 0) {
error << _("Session: XML state has no Regions section") << endmsg;
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, version)) {
- goto out;
- }
-
if (version < 3000) {
if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
error << _("Session: XML state has no diskstreams section") << endmsg;
new_routes.push_back (route);
}
- add_routes (new_routes, false);
+ add_routes (new_routes, false, false);
return 0;
}
if (ds_child) {
- Track* track;
+ boost::shared_ptr<Track> track;
if (type == DataType::AUDIO) {
- track = new AudioTrack (*this, X_("toBeResetFroXML"));
-
+ track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
} else {
- track = new MidiTrack (*this, X_("toBeResetFroXML"));
+ track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
}
if (track->init()) {
- delete track;
return ret;
}
if (track->set_state (node, version)) {
- delete track;
return ret;
}
- boost_debug_shared_ptr_mark_interesting (track, "Track");
- ret.reset (track);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
+ ret = track;
} else {
- Route* rt = new Route (*this, X_("toBeResetFroXML"));
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
- if (rt->init () == 0 && rt->set_state (node, version) == 0) {
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
- ret.reset (rt);
- } else {
- delete rt;
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
+#endif
+ ret = r;
}
}
return boost::shared_ptr<Route> ();
}
- Track* track;
-
+ boost::shared_ptr<Track> track;
+
if (type == DataType::AUDIO) {
- track = new AudioTrack (*this, X_("toBeResetFroXML"));
-
+ track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
} else {
- track = new MidiTrack (*this, X_("toBeResetFroXML"));
+ track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
}
if (track->init()) {
- delete track;
return ret;
}
if (track->set_state (node, version)) {
- delete track;
return ret;
}
track->set_diskstream (*i);
- boost_debug_shared_ptr_mark_interesting (track, "Track");
- ret.reset (track);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
+ ret = track;
} else {
- Route* rt = new Route (*this, X_("toBeResetFroXML"));
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
- if (rt->init () == 0 && rt->set_state (node, version) == 0) {
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
boost_debug_shared_ptr_mark_interesting (rt, "Route");
- ret.reset (rt);
- } else {
- delete rt;
+#endif
+ ret = r;
}
}
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));
-
- }
+ 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> ();
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;
sys::path source_dir = ((type == DataType::AUDIO)
? sdir.sound_path() : sdir.midi_path());
- string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid");
+ string ext = native_header_format_extension (config.get_native_file_header_format(), type);
for (n = 0; n < 999999; ++n) {
if (identifier.length()) {
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ retry:
try {
if ((source = XMLSourceFactory (**niter)) == 0) {
error << _("Session: cannot create Source from XML description.") << endmsg;
}
+
} 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);
+
+ int user_choice;
+
+ if (!no_questions_about_missing_files) {
+ user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
+ } else {
+ user_choice = -2;
+ }
+
+ switch (user_choice) {
+ case 0:
+ /* user added a new search location, so try again */
+ goto retry;
+
+
+ case 1:
+ /* user asked to quit the entire session load
+ */
+ return -1;
+
+ case 2:
+ no_questions_about_missing_files = true;
+ goto retry;
+
+ case 3:
+ no_questions_about_missing_files = true;
+ /* fallthru */
+
+ case -1:
+ default:
+ warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
+ source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+ break;
+ }
}
}
}
if (!tree.write (template_file_path.to_string())) {
- error << _("mix template not saved") << endmsg;
+ error << _("template not saved") << endmsg;
return -1;
}
return Glib::build_filename (_path, "analysis");
}
+string
+Session::plugins_dir () const
+{
+ return Glib::build_filename (_path, "plugins");
+}
+
int
Session::load_bundles (XMLNode const & node)
{
string statename(*state);
string::size_type start,end;
- if ((start = statename.find_last_of ('/')) != string::npos) {
+ if ((start = statename.find_last_of (G_DIR_SEPARATOR)) != string::npos) {
statename = statename.substr (start+1);
}
{
_route_groups.push_back (g);
route_group_added (g); /* EMIT SIGNAL */
+
+ g->MembershipChanged.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
+ g->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
+
set_dirty ();
}
route_group_removed (); /* EMIT SIGNAL */
}
+}
+
+/** Set a new order for our route groups, without adding or removing any.
+ * @param groups Route group list in the new order.
+ */
+void
+Session::reorder_route_groups (list<RouteGroup*> groups)
+{
+ _route_groups = groups;
+ route_groups_reordered (); /* EMIT SIGNAL */
+ set_dirty ();
}
+
RouteGroup *
Session::route_group_by_name (string name)
{
return 0;
}
-UndoTransaction*
-Session::start_reversible_command (const string& name)
+RouteGroup&
+Session::all_route_group() const
{
- UndoTransaction* trans = new UndoTransaction();
- trans->set_name(name);
- return trans;
+ return *_all_route_group;
}
void
-Session::finish_reversible_command (UndoTransaction& ut)
+Session::add_commands (vector<Command*> const & cmds)
{
- struct timeval now;
- gettimeofday(&now, 0);
- ut.set_timestamp(now);
- _history.add (&ut);
+ for (vector<Command*>::const_iterator i = cmds.begin(); i != cmds.end(); ++i) {
+ add_command (*i);
+ }
}
void
-Session::begin_reversible_command(const string& name)
+Session::begin_reversible_command (const string& name)
{
- UndoTransaction* trans = new UndoTransaction();
- trans->set_name(name);
+ begin_reversible_command (g_quark_from_string (name.c_str ()));
+}
- if (!_current_trans.empty()) {
- _current_trans.top()->add_command (trans);
- } else {
- _current_trans.push(trans);
+/** Begin a reversible command using a GQuark to identify it.
+ * begin_reversible_command() and commit_reversible_command() calls may be nested,
+ * but there must be as many begin...()s as there are commit...()s.
+ */
+void
+Session::begin_reversible_command (GQuark q)
+{
+ /* If nested begin/commit pairs are used, we create just one UndoTransaction
+ to hold all the commands that are committed. This keeps the order of
+ commands correct in the history.
+ */
+
+ if (_current_trans == 0) {
+ /* start a new transaction */
+ assert (_current_trans_quarks.empty ());
+ _current_trans = new UndoTransaction();
+ _current_trans->set_name (g_quark_to_string (q));
}
+
+ _current_trans_quarks.push_front (q);
}
void
-Session::commit_reversible_command(Command *cmd)
+Session::commit_reversible_command (Command *cmd)
{
- assert(!_current_trans.empty());
+ assert (_current_trans);
+ assert (!_current_trans_quarks.empty ());
+
struct timeval now;
if (cmd) {
- _current_trans.top()->add_command(cmd);
+ _current_trans->add_command (cmd);
}
- if (_current_trans.top()->empty()) {
- _current_trans.pop();
+ _current_trans_quarks.pop_front ();
+
+ if (!_current_trans_quarks.empty ()) {
+ /* the transaction we're committing is not the top-level one */
return;
}
- gettimeofday(&now, 0);
- _current_trans.top()->set_timestamp(now);
+ if (_current_trans->empty()) {
+ /* no commands were added to the transaction, so just get rid of it */
+ delete _current_trans;
+ _current_trans = 0;
+ return;
+ }
- cerr << "add cmd @ " << _current_trans.top() << " to history\n";
+ gettimeofday (&now, 0);
+ _current_trans->set_timestamp (now);
- _history.add(_current_trans.top());
- _current_trans.pop();
+ _history.add (_current_trans);
+ _current_trans = 0;
}
static bool
-accept_all_non_peak_files (const string& path, void */*arg*/)
+accept_all_audio_files (const string& path, void */*arg*/)
+{
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
+ if (!AudioFileSource::safe_audio_file_extension (path)) {
+ return false;
+ }
+
+ return true;
+}
+
+static bool
+accept_all_midi_files (const string& path, void */*arg*/)
{
- return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
+ return ((path.length() > 4 && path.find (".mid") != (path.length() - 4)) ||
+ (path.length() > 4 && path.find (".smf") != (path.length() - 4)) ||
+ (path.length() > 5 && path.find (".midi") != (path.length() - 5)));
}
static bool
accept_all_state_files (const string& path, void */*arg*/)
{
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
}
continue;
}
- if (prop->value()[0] == '/') {
+ if (Glib::path_is_absolute (prop->value())) {
/* external file, ignore */
continue;
}
- Glib::ustring found_path;
+ string found_path;
bool is_new;
uint16_t chan;
- if (FileSource::find (type, prop->value(), true, is_new, chan, found_path)) {
+ if (FileSource::find (*this, type, prop->value(), true, is_new, chan, found_path)) {
result.insert (found_path);
}
}
ripped = _path;
- if (ripped[ripped.length()-1] == '/') {
+ if (ripped[ripped.length()-1] == G_DIR_SEPARATOR) {
ripped = ripped.substr (0, ripped.length() - 1);
}
return r.get_value_or (1);
}
+void
+Session::cleanup_regions ()
+{
+ const RegionFactory::RegionMap& regions (RegionFactory::regions());
+
+ for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ boost::shared_ptr<AudioRegion> audio_region = boost::dynamic_pointer_cast<AudioRegion>( i->second);
+
+ if (!audio_region) {
+ continue;
+ }
+
+ uint32_t used = playlists->region_use_count (audio_region);
+
+ if (used == 0 && !audio_region->automatic()) {
+ RegionFactory::map_remove(i->second);
+ }
+ }
+
+ /* dump the history list */
+ _history.clear ();
+
+ save_state ("");
+}
+
int
Session::cleanup_sources (CleanupReport& rep)
{
vector<boost::shared_ptr<Source> > dead_sources;
PathScanner scanner;
- string sound_path;
+ string audio_path;
+ string midi_path;
vector<space_and_path>::iterator i;
vector<space_and_path>::iterator nexti;
- vector<string*>* soundfiles;
+ vector<string*>* candidates;
+ vector<string*>* candidates2;
vector<string> unused;
set<string> all_sources;
bool used;
_state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
- /* step 1: consider deleting all unused playlists */
+ /* consider deleting all unused playlists */
if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) {
ret = 0;
goto out;
}
- /* step 2: find all un-used sources */
+ /* sync the "all regions" property of each playlist with its current state
+ */
+
+ playlists->sync_all_regions_with_regions ();
+
+ /* find all un-used sources */
rep.paths.clear ();
rep.space = 0;
i = tmp;
}
- /* build a list of all the possible sound directories for the session */
+ /* build a list of all the possible audio directories for the session */
for (i = session_dirs.begin(); i != session_dirs.end(); ) {
++nexti;
SessionDirectory sdir ((*i).path);
- sound_path += sdir.sound_path().to_string();
+ audio_path += sdir.sound_path().to_string();
if (nexti != session_dirs.end()) {
- sound_path += ':';
+ audio_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.
- */
- soundfiles = scanner (sound_path, accept_all_non_peak_files, (void *) 0, false, true);
+ /* build a list of all the possible midi directories for the session */
- if (soundfiles == 0) {
- return 0;
+ for (i = session_dirs.begin(); i != session_dirs.end(); ) {
+
+ nexti = i;
+ ++nexti;
+
+ SessionDirectory sdir ((*i).path);
+ midi_path += sdir.midi_path().to_string();
+
+ if (nexti != session_dirs.end()) {
+ midi_path += ':';
+ }
+
+ i = nexti;
}
+ candidates = scanner (audio_path, accept_all_audio_files, (void *) 0, true, true);
+ candidates2 = scanner (midi_path, accept_all_midi_files, (void *) 0, true, true);
+
+ /* merge them */
+
+ if (candidates) {
+ if (candidates2) {
+ for (vector<string*>::iterator i = candidates2->begin(); i != candidates2->end(); ++i) {
+ candidates->push_back (*i);
+ }
+ delete candidates2;
+ }
+ } else {
+ candidates = candidates2; // might still be null
+ }
+
/* find all sources, but don't use this snapshot because the
state file on disk still references sources we may have already
dropped.
/* add our current source list
*/
- for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
boost::shared_ptr<FileSource> fs;
+ SourceMap::iterator tmp = i;
+ ++tmp;
if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
- all_sources.insert (fs->path());
+ if (playlists->source_use_count (fs) != 0) {
+ all_sources.insert (fs->path());
+ } else {
+
+ /* we might not remove this source from disk, because it may be used
+ by other snapshots, but its not being used in this version
+ so lets get rid of it now, along with any representative regions
+ in the region list.
+ */
+
+ RegionFactory::remove_regions_using_source (i->second);
+ sources.erase (i);
+ }
}
+
+ i = tmp;
}
char tmppath1[PATH_MAX+1];
char tmppath2[PATH_MAX+1];
- for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
-
- used = false;
- spath = **x;
-
- for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
+ if (candidates) {
+ for (vector<string*>::iterator x = candidates->begin(); x != candidates->end(); ++x) {
+
+ used = false;
+ spath = **x;
+
+ for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
+
+ if (realpath(spath.c_str(), tmppath1) == 0) {
+ error << string_compose (_("Cannot expand path %1 (%2)"),
+ spath, strerror (errno)) << endmsg;
+ continue;
+ }
+
+ if (realpath((*i).c_str(), tmppath2) == 0) {
+ error << string_compose (_("Cannot expand path %1 (%2)"),
+ (*i), strerror (errno)) << endmsg;
+ continue;
+ }
- realpath(spath.c_str(), tmppath1);
- realpath((*i).c_str(), tmppath2);
+ if (strcmp(tmppath1, tmppath2) == 0) {
+ used = true;
+ break;
+ }
+ }
+
+ if (!used) {
+ unused.push_back (spath);
+ }
- if (strcmp(tmppath1, tmppath2) == 0) {
- used = true;
- break;
- }
- }
+ delete *x;
+ }
- if (!used) {
- unused.push_back (spath);
- }
- }
+ delete candidates;
+ }
- /* now try to move all unused files into the "dead_sounds" directory(ies) */
+ /* now try to move all unused files into the "dead" directory(ies) */
for (vector<string>::iterator x = unused.begin(); x != unused.end(); ++x) {
struct stat statbuf;
- rep.paths.push_back (*x);
- if (stat ((*x).c_str(), &statbuf) == 0) {
- rep.space += statbuf.st_size;
- }
-
string newpath;
/* don't move the file across filesystems, just
- stick it in the `dead_sound_dir_name' directory
+ stick it in the `dead_dir_name' directory
on whichever filesystem it was already on.
*/
/* new school, go up 4 levels */
- newpath = Glib::path_get_dirname (*x); // "audiofiles"
+ newpath = Glib::path_get_dirname (*x); // "audiofiles" or "midifiles"
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;
+ newpath = Glib::build_filename (newpath, dead_dir_name);
if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create dead file folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
return -1;
}
- newpath += '/';
- newpath += Glib::path_get_basename ((*x));
-
- if (access (newpath.c_str(), F_OK) == 0) {
+ newpath = Glib::build_filename (newpath, Glib::path_get_basename ((*x)));
+
+ if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
/* the new path already exists, try versioning */
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
newpath_v = buf;
- while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
+ while (Glib::file_test (newpath_v.c_str(), Glib::FILE_TEST_EXISTS) && version < 999) {
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
newpath_v = buf;
}
}
+ stat ((*x).c_str(), &statbuf);
+
if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
- error << string_compose (_("cannot rename audio file source from %1 to %2 (%3)"),
+ error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"),
(*x), newpath, strerror (errno))
<< endmsg;
goto out;
/* see if there an easy to find peakfile for this file, and remove it.
*/
- string peakpath = (*x).substr (0, (*x).find_last_of ('.'));
- peakpath += peakfile_suffix;
-
- if (access (peakpath.c_str(), W_OK) == 0) {
+ string base = basename_nosuffix (*x);
+ base += "%A"; /* this is what we add for the channel suffix of all native files,
+ or for the first channel of embedded files. it will miss
+ some peakfiles for other channels
+ */
+ string peakpath = peak_path (base);
+
+ if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
if (::unlink (peakpath.c_str()) != 0) {
error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
- peakpath, _path, strerror (errno))
+ peakpath, _path, strerror (errno))
<< endmsg;
/* try to back out */
rename (newpath.c_str(), _path.c_str());
goto out;
}
}
- }
- ret = 0;
+ rep.paths.push_back (*x);
+ rep.space += statbuf.st_size;
+ }
/* dump the history list */
*/
save_state ("");
+ ret = 0;
out:
_state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
// FIXME: needs adaptation for MIDI
vector<space_and_path>::iterator i;
- string dead_sound_dir;
- struct dirent* dentry;
- struct stat statbuf;
- DIR* dead;
+ string dead_dir;
rep.paths.clear ();
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;
-
- if ((dead = opendir (dead_sound_dir.c_str())) == 0) {
- continue;
- }
-
- while ((dentry = readdir (dead)) != 0) {
-
- /* avoid '.' and '..' */
-
- if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
- (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
- continue;
- }
-
- string fullpath;
-
- fullpath = dead_sound_dir;
- fullpath += '/';
- fullpath += dentry->d_name;
-
- if (stat (fullpath.c_str(), &statbuf)) {
- continue;
- }
-
- if (!S_ISREG (statbuf.st_mode)) {
- continue;
- }
-
- if (unlink (fullpath.c_str())) {
- error << string_compose (_("cannot remove dead sound file %1 (%2)"),
- fullpath, strerror (errno))
- << endmsg;
- }
-
- rep.paths.push_back (dentry->d_name);
- rep.space += statbuf.st_size;
- }
-
- closedir (dead);
+ dead_dir = Glib::build_filename ((*i).path, dead_dir_name);
+ clear_directory (dead_dir, &rep.space, &rep.paths);
}
return 0;
break;
case ControllableDescriptor::Solo:
- c = r->solo_control();
+ c = r->solo_control();
break;
case ControllableDescriptor::Mute:
break;
}
- case ControllableDescriptor::Pan:
- /* XXX pan control */
+ case ControllableDescriptor::PanDirection:
+ {
+ c = r->pannable()->pan_azimuth_control;
break;
+ }
+
+ case ControllableDescriptor::PanWidth:
+ {
+ c = r->pannable()->pan_width_control;
+ break;
+ }
+
+ case ControllableDescriptor::PanElevation:
+ {
+ c = r->pannable()->pan_elevation_control;
+ break;
+ }
case ControllableDescriptor::Balance:
/* XXX simple pan control */
ut->add_command(c);
}
- } else if (n->name() == "DiffCommand") {
- PBD::ID id(n->property("midi-source")->value());
+ } else if (n->name() == "NoteDiffCommand") {
+ 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::NoteDiffCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for NoteDiffCommand") << endmsg;
+ }
+
+ } else if (n->name() == "SysExDiffCommand") {
+
+ 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::SysExDiffCommand (midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for SysExDiffCommand") << endmsg;
+ }
+
+ } else if (n->name() == "PatchChangeDiffCommand") {
+
+ 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));
+ ut->add_command (new MidiModel::PatchChangeDiffCommand (midi_source->model(), *n));
} else {
- error << _("Failed to downcast MidiSource for DiffCommand") << endmsg;
+ error << _("Failed to downcast MidiSource for PatchChangeDiffCommand") << endmsg;
}
} else if (n->name() == "StatefulDiffCommand") {
if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
/* auto-input only makes a difference if we're rolling */
-
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && tr->record_enabled ()) {
- tr->monitor_input (!config.get_auto_input());
- }
- }
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else if (p == "punch-in") {
Location* location;
- if ((location = _locations.auto_punch_location()) != 0) {
+ if ((location = _locations->auto_punch_location()) != 0) {
if (config.get_punch_in ()) {
replace_event (SessionEvent::PunchIn, location->start());
Location* location;
- if ((location = _locations.auto_punch_location()) != 0) {
+ if ((location = _locations->auto_punch_location()) != 0) {
if (config.get_punch_out()) {
replace_event (SessionEvent::PunchOut, location->end());
} else if (p == "mmc-device-id" || p == "mmc-receive-id") {
- if (mmc) {
- mmc->set_receive_device_id (Config->get_mmc_receive_device_id());
- }
+ MIDI::Manager::instance()->mmc()->set_receive_device_id (Config->get_mmc_receive_device_id());
} else if (p == "mmc-send-id") {
- if (mmc) {
- mmc->set_send_device_id (Config->get_mmc_send_device_id());
- }
+ MIDI::Manager::instance()->mmc()->set_send_device_id (Config->get_mmc_send_device_id());
} else if (p == "midi-control") {
} 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) {
- /* mark us ready to send */
- next_quarter_frame_to_send = 0;
- }
- } else {
- session_send_mtc = false;
+ if (Config->get_send_mtc ()) {
+ /* mark us ready to send */
+ next_quarter_frame_to_send = 0;
}
} 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;
- }
+ MIDI::Manager::instance()->mmc()->enable_send (Config->get_send_mmc ());
} 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();
- }
+ session_midi_feedback = Config->get_midi_feedback();
} else if (p == "jack-time-master") {
sync_order_keys ("session");
} else if (p == "initial-program-change") {
- if (_mmc_port && Config->get_initial_program_change() >= 0) {
+ if (MIDI::Manager::instance()->mmc()->output_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);
+ MIDI::Manager::instance()->mmc()->output_port()->midimsg (buf, sizeof (buf), 0);
}
} else if (p == "solo-mute-override") {
// catch_up_on_solo_mute_override ();
- } else if (p == "listen-position") {
+ } else if (p == "listen-position" || p == "pfl-position") {
listen_position_changed ();
} else if (p == "solo-control-is-listen-control") {
solo_control_mode_changed ();
+ } else if (p == "timecode-offset" || p == "timecode-offset-negative") {
+ last_timecode_valid = false;
}
-
set_dirty ();
}
return 0;
}
+
+/** Connect things to the MMC object */
+void
+Session::setup_midi_machine_control ()
+{
+ MIDI::MachineControl* mmc = MIDI::Manager::instance()->mmc ();
+
+ mmc->Play.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
+ mmc->DeferredPlay.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
+ mmc->Stop.connect_same_thread (*this, boost::bind (&Session::mmc_stop, this, _1));
+ mmc->FastForward.connect_same_thread (*this, boost::bind (&Session::mmc_fast_forward, this, _1));
+ mmc->Rewind.connect_same_thread (*this, boost::bind (&Session::mmc_rewind, this, _1));
+ mmc->Pause.connect_same_thread (*this, boost::bind (&Session::mmc_pause, this, _1));
+ mmc->RecordPause.connect_same_thread (*this, boost::bind (&Session::mmc_record_pause, this, _1));
+ mmc->RecordStrobe.connect_same_thread (*this, boost::bind (&Session::mmc_record_strobe, this, _1));
+ mmc->RecordExit.connect_same_thread (*this, boost::bind (&Session::mmc_record_exit, this, _1));
+ mmc->Locate.connect_same_thread (*this, boost::bind (&Session::mmc_locate, this, _1, _2));
+ mmc->Step.connect_same_thread (*this, boost::bind (&Session::mmc_step, this, _1, _2));
+ mmc->Shuttle.connect_same_thread (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3));
+ mmc->TrackRecordStatusChange.connect_same_thread (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3));
+
+ /* also handle MIDI SPP because its so common */
+
+ mmc->SPPStart.connect_same_thread (*this, boost::bind (&Session::spp_start, this, _1, _2));
+ mmc->SPPContinue.connect_same_thread (*this, boost::bind (&Session::spp_continue, this, _1, _2));
+ mmc->SPPStop.connect_same_thread (*this, boost::bind (&Session::spp_stop, this, _1, _2));
+}
+
+boost::shared_ptr<Controllable>
+Session::solo_cut_control() const
+{
+ /* the solo cut control is a bit of an anomaly, at least as of Febrary 2011. There are no other
+ controls in Ardour that currently get presented to the user in the GUI that require
+ access as a Controllable and are also NOT owned by some SessionObject (e.g. Route, or MonitorProcessor).
+
+ its actually an RCConfiguration parameter, so we use a ProxyControllable to wrap
+ it up as a Controllable. Changes to the Controllable will just map back to the RCConfiguration
+ parameter.
+ */
+
+ return _solo_cut_control;
+}
projects / ardour.git / blobdiff