#include "i18n.h"
+#include <glibmm/checksum.h>
+
namespace ARDOUR {
class MidiSource;
class Processor;
using namespace PBD;
bool Session::_disable_all_loaded_plugins = false;
+bool Session::_bypass_all_loaded_plugins = false;
PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
PBD::Signal1<void,std::string> Session::Dialog;
PBD::Signal0<void> Session::SuccessfulGraphSort;
PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
-const framecnt_t Session::bounce_chunk_size = 65536;
+const framecnt_t Session::bounce_chunk_size = 8192;
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
+// seconds should be added after the region exceeds end marker
+#ifdef USE_TRACKS_CODE_FEATURES
+const uint32_t Session::session_end_shift = 5;
+#else
+const uint32_t Session::session_end_shift = 0;
+#endif
+
/** @param snapshot_name Snapshot name, without .ardour suffix */
Session::Session (AudioEngine &eng,
const string& fullpath,
, average_dir (0)
, have_first_delta_accumulator (false)
, _slave_state (Stopped)
- , _mtc_active (false)
+ , _mtc_active (false)
+ , _ltc_active (false)
, post_export_sync (false)
, post_export_position (0)
, _exporting (false)
if (_is_new) {
+ Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
+
#ifdef USE_TRACKS_CODE_FEATURES
sr = EngineStateController::instance()->get_current_sample_rate();
#endif
if (ensure_engine (sr)) {
destroy ();
- throw failed_constructor ();
+ throw SessionException (_("Cannot connect to audio/midi engine"));
}
if (create (mix_template, bus_profile)) {
destroy ();
- throw failed_constructor ();
+ throw SessionException (_("Session initialization failed"));
}
/* if a mix template was provided, then ::create() will
if (!mix_template.empty()) {
if (load_state (_current_snapshot_name)) {
- throw failed_constructor ();
+ throw SessionException (_("Failed to load template/snapshot state"));
}
store_recent_templates (mix_template);
}
} else {
if (load_state (_current_snapshot_name)) {
- throw failed_constructor ();
+ throw SessionException (_("Failed to load state"));
}
/* try to get sample rate from XML state so that we
if (ensure_engine (sr)) {
destroy ();
- throw failed_constructor ();
+ throw SessionException (_("Cannot connect to audio/midi engine"));
}
}
if (post_engine_init ()) {
destroy ();
- throw failed_constructor ();
+ throw SessionException (_("Cannot configure audio/midi engine with session parameters"));
}
store_recent_sessions (_name, _path);
StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
- _is_new = false;
-
emit_thread_start ();
/* hook us up to the engine since we are now completely constructed */
/* mono output bundles */
for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
- char buf[32];
+ char buf[64];
std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
if (!pn.empty()) {
- snprintf (buf, sizeof (buf), _("out %s"), pn.substr(0,12).c_str());
+ snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
} else {
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
}
/* mono input bundles */
for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
- char buf[32];
+ char buf[64];
std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
if (!pn.empty()) {
- snprintf (buf, sizeof (buf), _("in %s"), pn.substr(0,12).c_str());
+ snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
} else {
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
}
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
// boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
- {
+ try {
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
+ } catch (...) {
+ error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
+ return;
}
rl.push_back (r);
bool
Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
{
+ /* it is unfortunate that we need to include reserved names here that
+ refer to control surfaces. But there's no way to ensure a complete
+ lack of collisions without doing this, since the control surface
+ support may not even be active. Without adding an API to control
+ surface support that would list their port names, we do have to
+ list them here.
+ */
+
+ char const * const reserved[] = {
+ _("Monitor"),
+ _("Master"),
+ _("Control"),
+ _("Click"),
+ _("Mackie"),
+ 0
+ };
+
+ /* the base may conflict with ports that do not belong to existing
+ routes, but hidden objects like the click track. So check port names
+ before anything else.
+ */
+
+ for (int n = 0; reserved[n]; ++n) {
+ if (base == reserved[n]) {
+ definitely_add_number = true;
+ if (id < 1) {
+ id = 1;
+ }
+ break;
+ }
+ }
+
if (!definitely_add_number && route_by_name (base) == 0) {
/* juse use the base */
name = base;
}
}
+string
+Session::default_track_name_pattern (DataType t)
+{
+ switch (t) {
+ case DataType::AUDIO:
+ if (Profile->get_trx()) {
+ return _("Track ");
+ } else {
+ return _("Audio ");
+ }
+ break;
+
+ case DataType::MIDI:
+ return _("MIDI ");
+ }
+
+ return "";
+}
+
/** Caller must not hold process lock
* @param name_template string to use for the start of the name, or "" to use "MIDI".
* @param instrument plugin info for the instrument to insert pre-fader, if any
RouteList new_routes;
list<boost::shared_ptr<MidiTrack> > ret;
- bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
+ const string name_pattern = default_track_name_pattern (DataType::MIDI);
+ bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
while (how_many) {
if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
RouteList new_routes;
list<boost::shared_ptr<AudioTrack> > ret;
- string name_pattern;
-
- if (Profile->get_trx() ) {
- name_pattern = "Track ";
- } else {
- name_pattern = "Audio ";
- }
-
- bool const use_number = (how_many != 1) || name_template.empty () || name_template == _(name_pattern.c_str() );
+ const string name_pattern = default_track_name_pattern (DataType::AUDIO);
+ bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
while (how_many) {
void
Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
{
+ PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
+
{ // RCU Writer scope
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> rs = writer.get_copy ();
_monitor_out.reset ();
}
- update_route_solo_state ();
-
// We need to disconnect the route's inputs and outputs
(*iter)->input()->disconnect (0);
_step_editors--;
}
}
-
- RouteAddedOrRemoved (false); /* EMIT SIGNAL */
}
/* writer goes out of scope, forces route list update */
} // end of RCU Writer scope
+ update_route_solo_state ();
+ RouteAddedOrRemoved (false); /* EMIT SIGNAL */
update_latency_compensation ();
set_dirty();
#ifdef USE_TRACKS_CODE_FEATURES
reconnect_existing_routes(true, false);
#else
+ routes.flush (); // maybe unsafe, see below.
resort_routes ();
#endif
/* try to cause everyone to drop their references
* and unregister ports from the backend
*/
- PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
(*iter)->drop_references ();
}
}
+void
+Session::routes_solo_changed (boost::shared_ptr<RouteList> solo_change_routes)
+{
+ if (solo_update_disabled) {
+ // We know already
+ DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
+ return;
+ }
+
+ if (solo_change_routes->empty() ) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> non_solo_change_routes (new RouteList);
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ int32_t delta;
+
+ std::set_difference (r->begin(), r->end(),
+ solo_change_routes->begin(), solo_change_routes->end(),
+ std::back_inserter(*non_solo_change_routes) );
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
+
+ solo_update_disabled = true;
+ RouteList uninvolved;
+
+ for (RouteList::iterator route = solo_change_routes->begin(); route != solo_change_routes->end(); ++route) {
+
+ if ((*route)->self_soloed() ) {
+ delta = 1;
+ } else {
+ delta = -1;
+ }
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", (*route)->name()));
+
+ for (RouteList::iterator i = non_solo_change_routes->begin(); i != non_solo_change_routes->end(); ++i) {
+ bool via_sends_only;
+ bool in_signal_flow;
+
+ if ((*i) == *route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ) {
+ continue;
+ }
+
+ in_signal_flow = false;
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
+
+ if ((*i)->feeds (*route, &via_sends_only)) {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
+ if (!via_sends_only) {
+ if (!(*route)->soloed_by_others_upstream()) {
+ (*i)->mod_solo_by_others_downstream (delta);
+ }
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
+ }
+ in_signal_flow = true;
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
+ }
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
+
+ if ((*route)->feeds (*i, &via_sends_only)) {
+ /* propagate solo upstream only if routing other than
+ sends is involved, but do consider the other route
+ (*i) to be part of the signal flow even if only
+ sends are involved.
+ */
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
+ (*route)->name(),
+ (*i)->name(),
+ via_sends_only,
+ (*route)->soloed_by_others_downstream(),
+ (*route)->soloed_by_others_upstream()));
+ if (!via_sends_only) {
+ if (!(*route)->soloed_by_others_downstream()) {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
+ (*i)->mod_solo_by_others_upstream (delta);
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
+ }
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
+ }
+ in_signal_flow = true;
+ } else {
+ DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
+ }
+
+ if (!in_signal_flow) {
+ uninvolved.push_back (*i);
+ }
+ }
+ }
+ solo_update_disabled = false;
+ DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
+
+ update_route_solo_state ();
+
+ /* now notify that the mute state of the routes not involved in the signal
+ pathway of the just-solo-changed route may have altered.
+ */
+
+ for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1\n", (*i)->name() ));
+ (*i)->mute_changed (this);
+ }
+
+ SoloChanged (); /* EMIT SIGNAL */
+ set_dirty();
+}
+
void
Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
{
return;
}
+ framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
+
if (_session_range_location == 0) {
- set_session_range_location (a, b);
+ set_session_range_location (a, b + session_end_marker_shift_samples);
} else {
return cnt;
}
+static string
+peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
+ if (hash) {
+ std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
+ return Glib::build_filename (peak_path, checksum + peakfile_suffix);
+ } else {
+ return Glib::build_filename (peak_path, file_base + peakfile_suffix);
+ }
+}
+
string
-Session::peak_path (string base) const
+Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
{
- if (Glib::path_is_absolute (base)) {
+ string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
+
+ if (Glib::path_is_absolute (filepath)) {
/* rip the session dir from the audiofile source */
string session_path;
- string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
bool in_another_session = true;
- if (base.find (interchange_dir_string) != string::npos) {
+ if (filepath.find (interchange_dir_string) != string::npos) {
- session_path = Glib::path_get_dirname (base); /* now ends in audiofiles */
+ session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
session_path = Glib::path_get_dirname (session_path); /* now has session path */
if (in_another_session) {
SessionDirectory sd (session_path);
- return Glib::build_filename (sd.peak_path(), Glib::path_get_basename (base) + peakfile_suffix);
+ return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
}
}
- base = Glib::path_get_basename (base);
- return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
+ /* 1) if file belongs to this session
+ * it may be a relative path (interchange/...)
+ * or just basename (session_state, remove source)
+ * -> just use the basename
+ */
+ std::string filename = Glib::path_get_basename (filepath);
+ std::string path;
+
+ /* 2) if the file is outside our session dir:
+ * (imported but not copied) add the path for check-summming */
+ if (!in_session) {
+ path = Glib::path_get_dirname (filepath);
+ }
+
+ return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
}
string
if (!path.empty()) {
return boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
} else {
throw failed_constructor ();
}
from a set_state() call or creating new tracks. Ditto for deletion.
*/
- if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress) {
+ if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
return;
}
if (src != _("None") && !src.empty()) {
_ltc_input->nth (0)->connect (src);
}
+
+ if ( ARDOUR::Profile->get_trx () ) {
+ // Tracks need this signal to update timecode_source_dropdown
+ MtcOrLtcInputPortChanged (); //emit signal
+ }
}
}
{
if (_ltc_output) {
-#if 0
- string src = Config->get_ltc_sink_port();
+ string src = Config->get_ltc_output_port();
_ltc_output->disconnect (this);
if (src != _("None") && !src.empty()) {
_ltc_output->nth (0)->connect (src);
}
-#endif
}
}
Session::set_range_selection (framepos_t start, framepos_t end)
{
_range_selection = Evoral::Range<framepos_t> (start, end);
+#ifdef USE_TRACKS_CODE_FEATURES
follow_playhead_priority ();
+#endif
}
void
Session::set_object_selection (framepos_t start, framepos_t end)
{
_object_selection = Evoral::Range<framepos_t> (start, end);
+#ifdef USE_TRACKS_CODE_FEATURES
follow_playhead_priority ();
+#endif
}
void
Session::clear_range_selection ()
{
_range_selection = Evoral::Range<framepos_t> (-1,-1);
+#ifdef USE_TRACKS_CODE_FEATURES
follow_playhead_priority ();
+#endif
}
void
Session::clear_object_selection ()
{
_object_selection = Evoral::Range<framepos_t> (-1,-1);
+#ifdef USE_TRACKS_CODE_FEATURES
follow_playhead_priority ();
+#endif
}