#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/controllable_descriptor.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/midi_track.h"
#include "ardour/named_selection.h"
#include "ardour/processor.h"
+#include "ardour/port.h"
#include "ardour/region_factory.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
_path = string(buf);
if (_path[_path.length()-1] != '/') {
- _path += '/';
+ _path += G_DIR_SEPARATOR;
}
if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
_non_soloed_outs_muted = false;
_listen_cnt = 0;
+ _solo_isolated_cnt = 0;
g_atomic_int_set (&processing_prohibited, 0);
_transport_speed = 0;
_last_transport_speed = 0;
transport_sub_state = 0;
_transport_frame = 0;
_requested_return_frame = -1;
- 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)));
+ _session_range_location = 0;
g_atomic_int_set (&_record_status, Disabled);
loop_changing = false;
play_loop = false;
have_looped = false;
_last_roll_location = 0;
+ _last_roll_or_reversal_location = 0;
_last_record_location = 0;
pending_locate_frame = 0;
pending_locate_roll = false;
_state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
_was_seamless = Config->get_seamless_loop ();
_slave = 0;
- session_send_mmc = false;
session_send_mtc = false;
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;
_exporting = false;
- _gain_automation_buffer = 0;
- _pan_automation_buffer = 0;
- _npan_buffers = 0;
pending_abort = false;
destructive_index = 0;
first_file_data_format_reset = true;
first_file_header_format_reset = true;
post_export_sync = false;
midi_control_ui = 0;
+ _step_editors = 0;
+ no_questions_about_missing_files = false;
+ _speakers = 0;
AudioDiskstream::allocate_working_buffers();
/* These are all static "per-class" signals */
- RegionFactory::CheckNewRegion.connect_same_thread (*this, boost::bind (&Session::add_region, this, _1));
SourceFactory::SourceCreated.connect_same_thread (*this, boost::bind (&Session::add_source, this, _1));
PlaylistFactory::PlaylistCreated.connect_same_thread (*this, boost::bind (&Session::add_playlist, this, _1, _2));
- Processor::ProcessorCreated.connect_same_thread (*this, boost::bind (&Session::add_processor, this, _1));
AutomationList::AutomationListCreated.connect_same_thread (*this, boost::bind (&Session::add_automation_list, this, _1));
Controllable::Destroyed.connect_same_thread (*this, boost::bind (&Session::remove_controllable, this, _1));
IO::PortCountChanged.connect_same_thread (*this, boost::bind (&Session::ensure_buffers, this, _1));
}
int
-Session::second_stage_init (bool new_session)
+Session::second_stage_init ()
{
AudioFileSource::set_peak_dir (_session_dir->peak_path().to_string());
- if (!new_session) {
+ if (!_is_new) {
if (load_state (_current_snapshot_name)) {
return -1;
}
- remove_empty_sounds ();
+ cleanup_stubfiles ();
}
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 ();
_engine.Xrun.connect_same_thread (*this, boost::bind (&Session::xrun_recovery, this));
try {
- when_engine_running (new_session);
+ when_engine_running ();
}
/* handle this one in a different way than all others, so that its clear what happened */
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);
ControlProtocolManager::instance().set_session (this);
- config.set_end_marker_is_free (new_session);
-
_state_of_the_state = Clean;
+ Port::set_connecting_blocked (false);
+
DirtyChanged (); /* EMIT SIGNAL */
if (state_was_pending) {
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().sound_stub_path().to_string();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session stub sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
+
dir = session_directory().midi_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
return -1;
}
+ dir = session_directory().midi_stub_path().to_string();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session stub midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
+
dir = session_directory().dead_sound_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
}
int
-Session::create (bool& new_session, const string& mix_template, nframes_t initial_length)
+Session::create (const string& mix_template, BusProfile* bus_profile)
{
if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
return -1;
}
- /* check new_session so we don't overwrite an existing one */
-
if (!mix_template.empty()) {
std::string in_path = mix_template;
if (out){
out << in.rdbuf();
-
- // okay, session is set up. Treat like normal saved
- // session from now on.
-
- new_session = false;
+ _is_new = false;
return 0;
} else {
/* set initial start + end point */
- start_location->set_end (0);
- _locations.add (start_location);
-
- end_location->set_end (initial_length);
- _locations.add (end_location);
-
_state_of_the_state = Clean;
+
+ /* set up Master Out and Control Out if necessary */
- save_state ("");
+ if (bus_profile) {
- return 0;
-}
+ RouteList rl;
+ int control_id = 1;
+ 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;
+ 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);
+ 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;
+ 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);
+ r->set_remote_control_id (control_id);
+
+ rl.push_back (r);
+ }
-int
-Session::load_diskstreams (const XMLNode& node)
-{
- XMLNodeList clist;
- XMLNodeConstIterator citer;
+ } else {
+ /* prohibit auto-connect to master, because there isn't one */
+ bus_profile->output_ac = AutoConnectOption (bus_profile->output_ac & ~AutoConnectMaster);
+ }
- clist = node.children();
+ if (!rl.empty()) {
+ add_routes (rl, false);
+ }
- for (citer = clist.begin(); citer != clist.end(); ++citer) {
+ /* this allows the user to override settings with an environment variable.
+ */
- try {
- /* diskstreams added automatically by DiskstreamCreated handler */
- if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
- AudioDiskstream* dsp (new AudioDiskstream (*this, **citer));
- boost::shared_ptr<AudioDiskstream> dstream (dsp);
- 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;
- }
- }
+ if (no_auto_connect()) {
+ bus_profile->input_ac = AutoConnectOption (0);
+ bus_profile->output_ac = AutoConnectOption (0);
+ }
+
+ Config->set_input_auto_connect (bus_profile->input_ac);
+ Config->set_output_auto_connect (bus_profile->output_ac);
+ }
- catch (failed_constructor& err) {
- error << _("Session: could not load diskstream via XML state") << endmsg;
- return -1;
- }
- }
+ save_state ("");
return 0;
}
sys::remove (xml_path);
}
+#ifdef HAVE_JACK_SESSION
+void
+Session::jack_session_event (jack_session_event_t * event)
+{
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
+
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "JS_%FT%T", &local_time);
+
+ if (event->type == JackSessionSaveTemplate)
+ {
+ if (save_template( timebuf )) {
+ event->flags = JackSessionSaveError;
+ } else {
+ string cmd ("ardour3 -P -U ");
+ cmd += event->client_uuid;
+ cmd += " -T ";
+ cmd += timebuf;
+
+ event->command_line = strdup (cmd.c_str());
+ }
+ }
+ else
+ {
+ if (save_state (timebuf)) {
+ event->flags = JackSessionSaveError;
+ } else {
+ sys::path xml_path (_session_dir->root_path());
+ xml_path /= legalize_for_path (timebuf) + statefile_suffix;
+
+ string cmd ("ardour3 -P -U ");
+ cmd += event->client_uuid;
+ cmd += " \"";
+ cmd += xml_path.to_string();
+ cmd += '\"';
+
+ event->command_line = strdup (cmd.c_str());
+ }
+ }
+
+ jack_session_reply (_engine.jack(), event);
+
+ if (event->type == JackSessionSaveAndQuit) {
+ Quit (); /* EMIT SIGNAL */
+ }
+
+ jack_session_event_free( event );
+}
+#endif
+
int
-Session::save_state (string snapshot_name, bool pending)
+Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot)
{
XMLTree tree;
sys::path xml_path(_session_dir->root_path());
/* 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)
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
i->second->session_saved();
+ }
tree.set_root (&get_state());
if (snapshot_name.empty()) {
snapshot_name = _current_snapshot_name;
- }
+ } else if (switch_to_snapshot) {
+ _current_snapshot_name = snapshot_name;
+ }
if (!pending) {
/* there is pending state from a crashed capture attempt */
- if (*AskAboutPendingState()) {
+ boost::optional<int> r = AskAboutPendingState();
+ if (r.get_value_or (1)) {
state_was_pending = true;
}
}
if (!state_was_pending) {
xmlpath = _session_dir->root_path();
- xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
+ xmlpath /= snapshot_name;
}
- if (!sys::exists (xmlpath)) {
- error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
- return 1;
- }
+ if (!sys::exists (xmlpath)) {
+ xmlpath = _session_dir->root_path();
+ xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
+ if (!sys::exists (xmlpath)) {
+ error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
+ return 1;
+ }
+ }
state_tree = new XMLTree;
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 ());
for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
- /* Don't save information about non-destructive file sources that are empty */
- /* FIXME: MIDI breaks if this is made FileSource like it should be... */
+ /* Don't save information about non-destructive file sources that are empty
+ and unused by any regions.
+ */
- boost::shared_ptr<AudioFileSource> fs;
- if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
+ boost::shared_ptr<FileSource> fs;
+ if ((fs = boost::dynamic_pointer_cast<FileSource> (siter->second)) != 0) {
if (!fs->destructive()) {
- if (fs->length(fs->timeline_position()) == 0) {
+ if (fs->empty() && !fs->used()) {
continue;
}
}
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 ());
}
}
}
- 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()) {
- child->add_child_nocopy ((*i)->get_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* start = new Location(0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
- Location* end = new Location(0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
- start->set_end(0);
- loc.add (start);
- end->set_end(compute_initial_length());
- loc.add (end);
+ 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());
}
/* the sort should have put control outs first */
- if (_control_out) {
- assert (_control_out == public_order.front());
+ if (_monitor_out) {
+ assert (_monitor_out == public_order.front());
}
for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
_nominal_frame_rate = atoi (prop->value());
if (_nominal_frame_rate != _current_frame_rate) {
- if (*AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate)) {
+ boost::optional<int> r = AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate);
+ if (r.get_value_or (0)) {
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 ();
Locations
Sources
AudioRegions
- AudioDiskstreams
Connections
Routes
RouteGroups
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;
}
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.end_location()) == 0) {
- _locations.add (end_location);
- } else {
- delete end_location;
- end_location = location;
+ if ((location = _locations->session_range_location()) != 0) {
+ delete _session_range_location;
+ _session_range_location = location;
}
- if ((location = _locations.start_location()) == 0) {
- _locations.add (start_location);
- } else {
- delete start_location;
- start_location = location;
+ if (_session_range_location) {
+ AudioFileSource::set_header_position_offset (_session_range_location->start());
}
- AudioFileSource::set_header_position_offset (start_location->start());
-
if ((child = find_named_node (node, "Sources")) == 0) {
error << _("Session: XML state has no sources section") << endmsg;
goto out;
}
}
- if ((child = find_named_node (node, "DiskStreams")) == 0) {
- error << _("Session: XML state has no diskstreams section") << endmsg;
- goto out;
- } else if (load_diskstreams (*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;
}
+ if (version < 3000) {
+ if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
+ error << _("Session: XML state has no diskstreams section") << endmsg;
+ goto out;
+ } else if (load_diskstreams_2X (*child, version)) {
+ goto out;
+ }
+ }
+
if ((child = find_named_node (node, "Routes")) == 0) {
error << _("Session: XML state has no routes section") << endmsg;
goto out;
goto out;
}
+ /* our diskstreams list is no longer needed as they are now all owned by their Route */
+ _diskstreams_2X.clear ();
+
if (version >= 3000) {
if ((child = find_named_node (node, "RouteGroups")) == 0) {
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- boost::shared_ptr<Route> route (XMLRouteFactory (**niter, version));
-
+ boost::shared_ptr<Route> route;
+ if (version < 3000) {
+ route = XMLRouteFactory_2X (**niter, version);
+ } else {
+ route = XMLRouteFactory (**niter, version);
+ }
+
if (route == 0) {
error << _("Session: cannot create Route from XML description.") << endmsg;
return -1;
boost::shared_ptr<Route>
Session::XMLRouteFactory (const XMLNode& node, int version)
{
+ boost::shared_ptr<Route> ret;
+
if (node.name() != "Route") {
- return boost::shared_ptr<Route> ((Route*) 0);
+ return ret;
}
- bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
+ XMLNode* ds_child = find_named_node (node, X_("Diskstream"));
DataType type = DataType::AUDIO;
const XMLProperty* prop = node.property("default-type");
+
+ if (prop) {
+ type = DataType (prop->value());
+ }
+
+ assert (type != DataType::NIL);
+
+ if (ds_child) {
+
+ Track* track;
+
+ if (type == DataType::AUDIO) {
+ track = new AudioTrack (*this, X_("toBeResetFroXML"));
+
+ } else {
+ track = 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);
+
+ } else {
+ Route* rt = 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;
+ }
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<Route>
+Session::XMLRouteFactory_2X (const XMLNode& node, int version)
+{
boost::shared_ptr<Route> ret;
+ if (node.name() != "Route") {
+ return ret;
+ }
+
+ XMLProperty const * ds_prop = node.property (X_("diskstream-id"));
+ if (!ds_prop) {
+ ds_prop = node.property (X_("diskstream"));
+ }
+
+ DataType type = DataType::AUDIO;
+ const XMLProperty* prop = node.property("default-type");
+
if (prop) {
- type = DataType(prop->value());
+ type = DataType (prop->value());
}
- assert(type != DataType::NIL);
+ assert (type != DataType::NIL);
- if (has_diskstream) {
- if (type == DataType::AUDIO) {
- AudioTrack* at = new AudioTrack (*this, node, version);
- boost_debug_shared_ptr_mark_interesting (at, "Track");
- ret.reset (at);
-
- } else {
- ret.reset (new MidiTrack (*this, node, version));
+ if (ds_prop) {
+
+ list<boost::shared_ptr<Diskstream> >::iterator i = _diskstreams_2X.begin ();
+ while (i != _diskstreams_2X.end() && (*i)->id() != ds_prop->value()) {
+ ++i;
}
+
+ if (i == _diskstreams_2X.end()) {
+ error << _("Could not find diskstream for route") << endmsg;
+ return boost::shared_ptr<Route> ();
+ }
+
+ Track* track;
+
+ if (type == DataType::AUDIO) {
+ track = new AudioTrack (*this, X_("toBeResetFroXML"));
+
+ } else {
+ track = 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);
+
} else {
- Route* rt = new Route (*this, node);
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
- ret.reset (rt);
+ Route* rt = 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;
+ }
}
return ret;
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;
+ }
}
}
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 ();
}
return 0;
}
+RouteGroup&
+Session::all_route_group() const
+{
+ return *_all_route_group;
+}
+
UndoTransaction*
Session::start_reversible_command (const string& name)
{
_history.add (&ut);
}
+void
+Session::add_commands (vector<Command*> const & cmds)
+{
+ for (vector<Command*>::const_iterator i = cmds.begin(); i != cmds.end(); ++i) {
+ add_command (*i);
+ }
+}
+
void
Session::begin_reversible_command(const string& name)
{
static bool
accept_all_non_peak_files (const string& path, void */*arg*/)
{
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
}
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);
}
int
Session::ask_about_playlist_deletion (boost::shared_ptr<Playlist> p)
{
- return *AskAboutPlaylistDeletion (p);
+ boost::optional<int> r = AskAboutPlaylistDeletion (p);
+ return r.get_value_or (1);
}
int
capture files.
*/
- if (!playlists->source_use_count(i->second) && i->second->length(i->second->timeline_position()) > 0) {
+ if (!i->second->used() && (i->second->length(i->second->timeline_position() > 0))) {
dead_sources.push_back (i->second);
i->second->drop_references ();
}
for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
- realpath(spath.c_str(), tmppath1);
- realpath((*i).c_str(), tmppath2);
+ 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;
+ }
if (strcmp(tmppath1, tmppath2) == 0) {
used = true;
newpath = Glib::path_get_dirname (newpath); // "session-dir"
}
- newpath += '/';
- newpath += dead_sound_dir_name;
+ newpath = Glib::build_filename (newpath, dead_sound_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;
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 */
vector<space_and_path>::iterator i;
string dead_sound_dir;
- struct dirent* dentry;
- struct stat statbuf;
- DIR* dead;
rep.paths.clear ();
rep.space = 0;
dead_sound_dir = (*i).path;
dead_sound_dir += dead_sound_dir_name;
- if ((dead = opendir (dead_sound_dir.c_str())) == 0) {
- continue;
- }
+ clear_directory (dead_sound_dir, &rep.space, &rep.paths);
+ }
- while ((dentry = readdir (dead)) != 0) {
+ return 0;
+}
- /* avoid '.' and '..' */
+void
+Session::cleanup_stubfiles ()
+{
+ vector<space_and_path>::iterator i;
- if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
- (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
- continue;
- }
+ for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
- string fullpath;
+ string dir;
+ string lname = legalize_for_path (_name);
- fullpath = dead_sound_dir;
- fullpath += '/';
- fullpath += dentry->d_name;
+ vector<string> v;
- if (stat (fullpath.c_str(), &statbuf)) {
- continue;
- }
+ /* XXX this is a hack caused by semantic conflicts
+ between space_and_path and the SessionDirectory concept.
+ */
- if (!S_ISREG (statbuf.st_mode)) {
- continue;
- }
+ v.push_back ((*i).path);
+ v.push_back ("interchange");
+ v.push_back (lname);
+ v.push_back ("audiofiles");
+ v.push_back (stub_dir_name);
- if (unlink (fullpath.c_str())) {
- error << string_compose (_("cannot remove dead sound file %1 (%2)"),
- fullpath, strerror (errno))
- << endmsg;
- }
+ dir = Glib::build_filename (v);
+
+ clear_directory (dir);
- rep.paths.push_back (dentry->d_name);
- rep.space += statbuf.st_size;
- }
+ v.clear ();
+ v.push_back ((*i).path);
+ v.push_back ("interchange");
+ v.push_back (lname);
+ v.push_back ("midifiles");
+ v.push_back (stub_dir_name);
- closedir (dead);
+ dir = Glib::build_filename (v);
+ clear_directory (dir);
}
-
- return 0;
}
void
if (str == "master") {
r = _master_out;
} else if (str == "control" || str == "listen") {
- r = _control_out;
+ r = _monitor_out;
} else {
r = route_by_name (desc.top_level_name());
}
ut->add_command(c);
}
- } 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 =
if (midi_source) {
ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
} else {
- error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+ error << _("Failed to downcast MidiSource for DiffCommand") << 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<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());
+ 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());
}
}
}
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;
+ session_send_mtc = Config->get_send_mtc();
+ if (session_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 ();
{
_history.set_depth (d);
}
+
+int
+Session::load_diskstreams_2X (XMLNode const & node, int)
+{
+ XMLNodeList clist;
+ XMLNodeConstIterator citer;
+
+ clist = node.children();
+
+ for (citer = clist.begin(); citer != clist.end(); ++citer) {
+
+ try {
+ /* diskstreams added automatically by DiskstreamCreated handler */
+ if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
+ boost::shared_ptr<AudioDiskstream> dsp (new AudioDiskstream (*this, **citer));
+ _diskstreams_2X.push_back (dsp);
+ } else {
+ error << _("Session: unknown diskstream type in XML") << endmsg;
+ }
+ }
+
+ catch (failed_constructor& err) {
+ error << _("Session: could not load diskstream via XML state") << endmsg;
+ return -1;
+ }
+ }
+
+ 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));
+}