#include "pbd/basename.h"
#include "pbd/convert.h"
-#include "pbd/convert.h"
#include "pbd/error.h"
#include "pbd/file_utils.h"
#include "pbd/md5.h"
#include "LuaBridge/LuaBridge.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#include <glibmm/checksum.h>
, _record_status (Disabled)
, _transport_frame (0)
, _session_range_location (0)
+ , _session_range_end_is_free (true)
, _slave (0)
, _silent (false)
, _transport_speed (0)
, post_export_position (0)
, _exporting (false)
, _export_rolling (false)
+ , _realtime_export (false)
, _export_preroll (0)
+ , _export_latency (0)
, _pre_export_mmc_enabled (false)
, _name (snapshot_name)
, _is_new (true)
, pending_locate_flush (false)
, pending_abort (false)
, pending_auto_loop (false)
- , _mempool ("Session", 1048576)
+ , _mempool ("Session", 2097152)
, lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
, _n_lua_scripts (0)
, _butler (new Butler (*this))
, _rt_thread_active (false)
, _rt_emit_pending (false)
, _ac_thread_active (false)
+ , _latency_recompute_pending (0)
, step_speed (0)
, outbound_mtc_timecode_frame (0)
, next_quarter_frame_to_send (-1)
}
}
+void
+Session::get_physical_ports (vector<string>& inputs, vector<string>& outputs, DataType type, bool excluding)
+{
+ _engine.get_physical_inputs (type, inputs);
+
+ if (excluding) {
+ /* rip out ControlOnly ports, and ALSA MIDI Through ports */
+
+ for (vector<string>::iterator si = inputs.begin(); si != inputs.end(); ) {
+ if (PortManager::port_is_control_only (*si)) {
+ si = inputs.erase (si);
+ } else if ((*si).find (X_("Midi Through")) != string::npos || (*si).find (X_("Midi-Through")) != string::npos) {
+ si = inputs.erase (si);
+ } else {
+ ++si;
+ }
+ }
+ }
+ _engine.get_physical_outputs (type, outputs);
+
+ if (excluding) {
+ /* rip out ControlOnly ports, and ALSA MIDI Through ports */
+
+ for (vector<string>::iterator si = outputs.begin(); si != outputs.end(); ) {
+ if (PortManager::port_is_control_only (*si)) {
+ si = outputs.erase (si);
+ } else if ((*si).find (X_("Midi Through")) != string::npos || (*si).find (X_("Midi-Through")) != string::npos) {
+ si = outputs.erase (si);
+ } else {
+ ++si;
+ }
+ }
+ }
+}
+
void
Session::setup_bundles ()
{
vector<string> inputs[DataType::num_types];
vector<string> outputs[DataType::num_types];
+
for (uint32_t i = 0; i < DataType::num_types; ++i) {
- _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
- _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
+ get_physical_ports (inputs[i], outputs[i], DataType (DataType::Symbol (i)), true);
}
/* Create a set of Bundle objects that map
_master_out->output()->disconnect (this);
_monitor_out->output()->disconnect (this);
- _monitor_out->input()->ensure_io (_master_out->output()->n_ports(), false, this);
- _monitor_out->output()->ensure_io (_master_out->output()->n_ports(), false, this);
+ // monitor section follow master bus - except midi
+ ChanCount mon_chn (_master_out->output()->n_ports());
+ mon_chn.set_midi (0);
+
+ _monitor_out->input()->ensure_io (mon_chn, false, this);
+ _monitor_out->output()->ensure_io (mon_chn, false, this);
for (uint32_t n = 0; n < limit; ++n) {
boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
Session::audible_frame () const
{
framepos_t ret;
- framepos_t tf;
- framecnt_t offset;
- offset = worst_playback_latency ();
+ frameoffset_t offset = worst_playback_latency (); // - _engine.samples_since_cycle_start ();
+ offset *= transport_speed ();
if (synced_to_engine()) {
/* Note: this is basically just sync-to-JACK */
- tf = _engine.transport_frame();
+ ret = _engine.transport_frame();
} else {
- tf = _transport_frame;
+ ret = _transport_frame;
}
- ret = tf;
-
- if (!non_realtime_work_pending()) {
-
- /* MOVING */
+ if (transport_rolling()) {
+ ret -= offset;
/* Check to see if we have passed the first guaranteed
- audible frame past our last start position. if not,
- return that last start point because in terms
- of audible frames, we have not moved yet.
-
- `Start position' in this context means the time we last
- either started, located, or changed transport direction.
- */
+ * audible frame past our last start position. if not,
+ * return that last start point because in terms
+ * of audible frames, we have not moved yet.
+ *
+ * `Start position' in this context means the time we last
+ * either started, located, or changed transport direction.
+ */
if (_transport_speed > 0.0f) {
if (!play_loop || !have_looped) {
- if (tf < _last_roll_or_reversal_location + offset) {
+ if (ret < _last_roll_or_reversal_location) {
return _last_roll_or_reversal_location;
}
+ } else {
+ // latent loops
+ Location *location = _locations->auto_loop_location();
+ frameoffset_t lo = location->start() - ret;
+ if (lo > 0) {
+ ret = location->end () - lo;
+ }
}
-
- /* forwards */
- ret -= offset;
-
} else if (_transport_speed < 0.0f) {
/* XXX wot? no backward looping? */
- if (tf > _last_roll_or_reversal_location - offset) {
+ if (ret > _last_roll_or_reversal_location) {
return _last_roll_or_reversal_location;
- } else {
- /* backwards */
- ret += offset;
}
}
}
- return ret;
+ return std::max ((framepos_t)0, ret);
}
void
#ifndef NDEBUG
DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().global_order()));
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 presentation order %2\n", (*i)->name(), (*i)->presentation_info().order()));
}
#endif
route_group->add (bus);
}
+ bus->add_internal_return ();
ret.push_back (bus);
}
/* create a gap in the presentation info to accomodate @param how_many
* new objects.
*/
- boost::shared_ptr <RouteList> rd = routes.reader();
+ StripableList sl;
+ get_stripables (sl);
- for (RouteList::iterator ri = rd->begin(); ri != rd->end(); ++ri) {
- boost::shared_ptr<Route> rt (*ri);
+ for (StripableList::iterator si = sl.begin(); si != sl.end(); ++si) {
+ boost::shared_ptr<Stripable> s (*si);
- if (rt->presentation_info().special()) {
+ if (s->is_monitor() || s->is_auditioner()) {
continue;
}
- if (rt->presentation_info().group_order () >= first_new_order) {
- rt->set_presentation_group_order (rt->presentation_info().group_order () + how_many);
+ if (s->presentation_info().order () >= first_new_order) {
+ s->set_presentation_order (s->presentation_info().order () + how_many);
}
}
}
}
RouteList
-Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base, PlaylistDisposition pd)
+Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name_base,
+ PlaylistDisposition pd)
{
XMLTree tree;
return RouteList();
}
- return new_route_from_template (how_many, *tree.root(), name_base, pd);
+ return new_route_from_template (how_many, insert_at, *tree.root(), name_base, pd);
}
RouteList
-Session::new_route_from_template (uint32_t how_many, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
+Session::new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
{
RouteList ret;
uint32_t number = 0;
if (!ret.empty()) {
StateProtector sp (this);
if (Profile->get_trx()) {
- add_routes (ret, false, false, false, PresentationInfo::max_order);
+ add_routes (ret, false, false, false, insert_at);
} else {
- add_routes (ret, true, true, false, PresentationInfo::max_order);
+ add_routes (ret, true, true, false, insert_at);
}
IO::enable_connecting ();
}
r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
+ r->processor_latency_changed.connect_same_thread (*this, boost::bind (&Session::queue_latency_recompute, this));
if (r->is_master()) {
_master_out = r;
/* presentation info order may already have been set from XML */
- if (r->presentation_info().unordered()) {
+ if (!r->presentation_info().order_set()) {
if (order == PresentationInfo::max_order) {
/* just add to the end */
- r->set_presentation_group_order_explicit (n_routes + added);
+ r->set_presentation_order (n_routes + added, false);
DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to NR %1 + %2 = %3\n", n_routes, added, n_routes + added));
} else {
- r->set_presentation_group_order_explicit (order + added);
+ r->set_presentation_order (order + added);
DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order not set, set to %1 + %2 = %3\n", order, added, order + added));
}
} else {
- DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().group_order()));
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("group order already set to %1\n", r->presentation_info().order()));
}
}
- DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 global order %3 type %4 (summary: %5)\n",
+#if !defined(__APPLE__) && !defined(__FreeBSD__)
+ /* clang complains: 'operator<<' should be declared prior to the call site or in an associated namespace of one of its
+ * arguments std::ostream& operator<<(std::ostream& o, ARDOUR::PresentationInfo const& rid)"
+ */
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("added route %1, group order %2 type %3 (summary: %4)\n",
r->name(),
- r->presentation_info().group_order(),
- r->presentation_info().global_order(),
+ r->presentation_info().order(),
enum_2_string (r->presentation_info().flags()),
- r->presentation_info().to_string()));
+ r->presentation_info()));
+#endif
if (input_auto_connect || output_auto_connect) {
return;
}
- Stripable::PresentationInfoChange(); /* EMIT SIGNAL */
+ PresentationInfo::Change(); /* EMIT SIGNAL */
/* save the new state of the world */
if ((*i)->solo_isolate_control()->solo_isolated() || !(*i)->can_solo()) {
/* route does not get solo propagated to it */
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 excluded from solo because iso = %2 can_solo = %3\n", (*i)->name(), (*i)->solo_isolate_control()->solo_isolated(),
+ (*i)->can_solo()));
continue;
}
return boost::dynamic_pointer_cast<Route> (get_remote_nth_stripable (n, PresentationInfo::Route));
}
-struct GlobalPresentationOrderSorter {
- bool operator() (boost::shared_ptr<Stripable> a, boost::shared_ptr<Stripable> b) {
- return a->presentation_info() < b->presentation_info();
- }
-};
-
boost::shared_ptr<Stripable>
Session::get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag flags) const
{
StripableList sl;
PresentationInfo::order_t match_cnt = 0;
- /* API is one-based, so adjust n */
-
- if (n) {
- --n;
- }
-
get_stripables (sl);
- GlobalPresentationOrderSorter cmp;
- sl.sort (cmp);
+ sl.sort (Stripable::PresentationOrderSorter());
for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+
+ if ((*s)->presentation_info().hidden()) {
+ /* if the caller didn't explicitly ask for hidden
+ stripables, ignore hidden ones. This matches
+ the semantics of the pre-PresentationOrder
+ "get by RID" logic of Ardour 4.x and earlier.
+
+ XXX at some point we should likely reverse
+ the logic of the flags, because asking for "the
+ hidden stripables" is not going to be common,
+ whereas asking for visible ones is normal.
+ */
+
+ if (! (flags & PresentationInfo::Hidden)) {
+ continue;
+ }
+ }
+
if ((*s)->presentation_info().flag_match (flags)) {
if (match_cnt++ == n) {
return *s;
if (a->presentation_info().special() && !b->presentation_info().special()) {
/* a is not ordered, b is; b comes before a */
return false;
- } else if (b->presentation_info().unordered() && !a->presentation_info().unordered()) {
+ } else if (!b->presentation_info().order_set() && a->presentation_info().order_set()) {
/* b is not ordered, a is; a comes before b */
return true;
} else {
- return a->presentation_info().global_order() < b->presentation_info().global_order();
+ return a->presentation_info().order() < b->presentation_info().order();
}
}
};
_session_range_location->set_start (a);
}
- if (b > _session_range_location->end()) {
+ if (_session_range_end_is_free && (b > _session_range_location->end())) {
_session_range_location->set_end (b);
}
}
}
+void
+Session::set_end_is_free (bool yn)
+{
+ _session_range_end_is_free = yn;
+}
+
void
Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
{
Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
if (tm.locked ()) {
try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
+ lua.collect_garbage_step ();
}
}
#ifndef NDEBUG
lua.Print.connect (&_lua_print);
#endif
+ lua.tweak_rt_gc ();
lua.do_command (
"function ArdourSession ()"
" local self = { scripts = {}, instances = {} }"
if (b->is_monitor()) {
return false;
}
- return a->presentation_info() < b->presentation_info();
+ return a->presentation_info().order() < b->presentation_info().order();
}
bool
}
void
-Session::goto_start ()
+Session::goto_start (bool and_roll)
{
if (_session_range_location) {
- request_locate (_session_range_location->start(), false);
+ request_locate (_session_range_location->start(), and_roll);
} else {
- request_locate (0, false);
+ request_locate (0, and_roll);
}
}
if (l && l->start() == old) {
l->set_start (s->start(), true);
}
+ set_dirty ();
}
void
if (l && l->end() == old) {
l->set_end (s->end(), true);
}
+ set_dirty ();
}
std::vector<std::string>
return;
}
- Stripable::PresentationInfoChange (); /* EMIT SIGNAL */
+ PresentationInfo::Change (); /* EMIT SIGNAL */
reassign_track_numbers();
#ifdef USE_TRACKS_CODE_FEATURES
}
}
+void
+Session::queue_latency_recompute ()
+{
+ g_atomic_int_inc (&_latency_recompute_pending);
+ if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
+ pthread_cond_signal (&_auto_connect_cond);
+ pthread_mutex_unlock (&_auto_connect_mutex);
+ }
+}
+
void
Session::auto_connect (const AutoConnectRequest& ar)
{
vector<string> physinputs;
vector<string> physoutputs;
- _engine.get_physical_outputs (*t, physoutputs);
- _engine.get_physical_inputs (*t, physinputs);
+ get_physical_ports (physinputs, physoutputs, *t, true);
if (!physinputs.empty() && ar.connect_inputs) {
uint32_t nphysical_in = physinputs.size();
}
}
+ if (!actively_recording ()) { // might not be needed,
+ /* this is only used for updating plugin latencies, the
+ * graph does not change. so it's safe in general.
+ * BUT..
+ * .. update_latency_compensation () entails set_capture_offset()
+ * which calls Diskstream::set_capture_offset () which
+ * modifies the capture offset... which can be a proplem
+ * in "prepare_to_stop"
+ */
+ while (g_atomic_int_and (&_latency_recompute_pending, 0)) {
+ update_latency_compensation ();
+ }
+ }
+
pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
}
pthread_mutex_unlock (&_auto_connect_mutex);
}
+
+void
+Session::cancel_all_solo ()
+{
+ StripableList sl;
+
+ get_stripables (sl);
+
+ set_controls (stripable_list_to_control_list (sl, &Stripable::solo_control), 0.0, Controllable::NoGroup);
+ clear_all_solo_state (routes.reader());
+}