#include "ardour/butler.h"
#include "ardour/click.h"
#include "ardour/configuration.h"
+#include "ardour/control_protocol_manager.h"
#include "ardour/crossfade.h"
#include "ardour/cycle_timer.h"
#include "ardour/data_type.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
#include "ardour/graph.h"
-#include "ardour/vbap_speakers.h"
+#include "ardour/speakers.h"
+#include "ardour/operations.h"
#include "midi++/port.h"
#include "midi++/mmc.h"
PBD::Signal1<void,std::string> Session::Dialog;
PBD::Signal0<int> Session::AskAboutPendingState;
-PBD::Signal2<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
+PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
PBD::Signal0<void> Session::SendFeedback;
PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
Session::Session (AudioEngine &eng,
- const string& fullpath,
- const string& snapshot_name,
+ const string& fullpath,
+ const string& snapshot_name,
BusProfile* bus_profile,
- string mix_template)
-
+ string mix_template)
: _engine (eng)
, _target_transport_speed (0.0)
, _requested_return_frame (-1)
, _total_free_4k_blocks (0)
, _bundles (new BundleList)
, _bundle_xml_node (0)
+ , _current_trans (0)
, _click_io ((IO*) 0)
, click_data (0)
, click_emphasis_data (0)
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;
+ _is_new = false;
}
Session::~Session ()
delete state_tree;
- /* remove all stubfiles that might still be lurking */
-
- cleanup_stubfiles ();
-
/* reset dynamic state version back to default */
Stateful::loading_state_version = 0;
_butler->drop_references ();
delete _butler;
delete midi_control_ui;
- delete _all_route_group;
+ delete _all_route_group;
if (click_data != default_click) {
delete [] click_data;
}
routes.flush ();
- boost::shared_ptr<RouteList> r = routes.reader ();
-
DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
- DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->path(), i->second.use_count()));
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
i->second->drop_references ();
}
/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
playlists.reset ();
- boost_debug_list_ptrs ();
-
delete _locations;
- delete _speakers;
DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
-}
-void
-Session::set_worst_io_latencies ()
-{
- _worst_output_latency = 0;
- _worst_input_latency = 0;
-
- if (!_engine.connected()) {
- return;
- }
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
- _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
- }
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_list_ptrs ();
+#endif
}
void
BootMessage (_("Compute I/O Latencies"));
- set_worst_io_latencies ();
-
if (_clicking) {
// XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
}
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
- boost::shared_ptr<Bundle> c (new Bundle (buf, true));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, outputs[DataType::AUDIO][np]);
char buf[32];
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
- boost::shared_ptr<Bundle> c (new Bundle (buf, false));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, inputs[DataType::AUDIO][np]);
char buf[32];
snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
- boost::shared_ptr<Bundle> c (new Bundle (buf, false));
+ boost::shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, inputs[DataType::AUDIO][np]);
c->add_channel (_("R"), DataType::AUDIO);
string n = inputs[DataType::MIDI][np];
boost::erase_first (n, X_("alsa_pcm:"));
- boost::shared_ptr<Bundle> c (new Bundle (n, false));
+ boost::shared_ptr<Bundle> c (new Bundle (n, false));
c->add_channel ("", DataType::MIDI);
c->set_port (0, inputs[DataType::MIDI][np]);
add_bundle (c);
string n = outputs[DataType::MIDI][np];
boost::erase_first (n, X_("alsa_pcm:"));
- boost::shared_ptr<Bundle> c (new Bundle (n, true));
+ boost::shared_ptr<Bundle> c (new Bundle (n, true));
c->add_channel ("", DataType::MIDI);
c->set_port (0, outputs[DataType::MIDI][np]);
add_bundle (c);
BootMessage (_("Setup signal flow and plugins"));
+ ControlProtocolManager::instance().set_session (this);
+
+ /* This must be done after the ControlProtocolManager set_session above,
+ as it will set states for ports which the ControlProtocolManager creates.
+ */
+ MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
+
+ /* And this must be done after the MIDI::Manager::set_port_states as
+ * it will try to make connections whose details are loaded by set_port_states.
+ */
+
hookup_io ();
if (_is_new && !no_auto_connect()) {
- Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock());
- /* don't connect the master bus outputs if there is a monitor bus */
+ /* don't connect the master bus outputs if there is a monitor bus */
if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
}
} else {
-
- for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- uint32_t mod = n_physical_outputs.get (*t);
- uint32_t limit = _monitor_out->n_outputs().get(*t);
+ /* Monitor bus is audio only */
+ uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
+ uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
+
+ if (mod != 0) {
+
for (uint32_t n = 0; n < limit; ++n) {
- Port* p = _monitor_out->output()->ports().port(*t, n);
+ Port* p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
string connect_to;
- if (outputs[*t].size() > (n % mod)) {
- connect_to = outputs[*t][n % mod];
+ if (outputs[DataType::AUDIO].size() > (n % mod)) {
+ connect_to = outputs[DataType::AUDIO][n % mod];
}
-
+
if (!connect_to.empty()) {
if (_monitor_out->output()->connect (p, connect_to, this)) {
error << string_compose (
}
}
- /* catch up on send+insert cnts */
-
_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
/* hook us up to the engine */
BootMessage (_("Connect to engine"));
-
_engine.set_session (this);
+
+ update_latency_compensation (true);
}
void
_state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
-
if (!auditioner) {
/* we delay creating the auditioner till now because
*/
try {
- Auditioner* a = new Auditioner (*this);
+ boost::shared_ptr<Auditioner> a (new Auditioner (*this));
if (a->init()) {
- delete a;
- throw failed_constructor();
+ throw failed_constructor ();
}
a->use_new_diskstream ();
- auditioner.reset (a);
+ auditioner = a;
}
catch (failed_constructor& err) {
Delivery::reset_panners ();
- /* Connect tracks to monitor/listen bus if there is one.
- Note that in an existing session, the internal sends will
- already exist, but we want the routes to notice that
- they connect to the control out specifically.
- */
+ /* Connect tracks to monitor/listen bus if there is one. Note that in an
+ existing session, the internal sends will already exist, but we want the
+ routes to notice that they connect to the control out specifically.
+ */
if (_monitor_out) {
boost::shared_ptr<RouteList> r = routes.reader ();
/* relax */
} else {
-
- (*x)->listen_via (_monitor_out,
- (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
- false, false);
+
+ (*x)->listen_via_monitor ();
}
}
}
boost::shared_ptr<Playlist> playlist;
if ((playlist = track->playlist()) != 0) {
- playlist->LengthChanged.connect_same_thread (*this, boost::bind (&Session::update_session_range_location_marker, this));
- playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::update_session_range_location_marker, this));
+ playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
+ playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
+ playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
}
-
- update_session_range_location_marker ();
}
bool
return true;
}
+void
+Session::set_track_monitor_input_status (bool yn)
+{
+ boost::shared_ptr<RouteList> rl = routes.reader ();
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
+ if (tr && tr->record_enabled ()) {
+ //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
+ tr->monitor_input (yn);
+ }
+ }
+}
+
void
Session::reset_input_monitor_state ()
{
if (transport_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 ()) {
- //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- tr->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
- }
- }
-
+ set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
} else {
-
- 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 ()) {
- //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
- tr->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
- }
- }
+ set_track_monitor_input_status (Config->get_monitoring_model() == HardwareMonitoring);
}
}
void
Session::auto_punch_end_changed (Location* location)
{
- nframes_t when_to_stop = location->end();
+ framepos_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (SessionEvent::PunchOut, when_to_stop);
}
void
Session::auto_punch_changed (Location* location)
{
- nframes_t when_to_stop = location->end();
+ framepos_t when_to_stop = location->end();
replace_event (SessionEvent::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
if (Config->get_monitoring_model() == HardwareMonitoring && 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 (true);
- }
- }
+ set_track_monitor_input_status (true);
}
RecordStateChanged ();
}
if (Config->get_monitoring_model() == HardwareMonitoring && 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 (false);
- }
- }
+ set_track_monitor_input_status (false);
}
RecordStateChanged (); /* emit signal */
if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
if (Config->get_monitoring_model() == HardwareMonitoring && 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 ()) {
- //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
- tr->monitor_input (false);
- }
- }
+ set_track_monitor_input_status (false);
}
}
}
{
framepos_t ret;
framepos_t tf;
- nframes_t offset;
+ framecnt_t offset;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
in the absence of any plugin latency compensation
*/
- offset = _worst_output_latency;
+ offset = worst_playback_latency ();
if (offset > current_block_size) {
offset -= current_block_size;
}
void
-Session::set_frame_rate (nframes_t frames_per_second)
+Session::set_frame_rate (framecnt_t frames_per_second)
{
- /** \fn void Session::set_frame_size(nframes_t)
+ /** \fn void Session::set_frame_size(framecnt_t)
the AudioEngine object that calls this guarantees
that it will not be called while we are also in
::process(). Its fine to do things that block
sync_time_vars();
- Automatable::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
+ Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
clear_clicks ();
}
void
-Session::set_block_size (nframes_t nframes)
+Session::set_block_size (pframes_t nframes)
{
/* the AudioEngine guarantees
that it will not be called while we are also in
}
}
-void
-Session::set_default_fade (float /*steepness*/, float /*fade_msecs*/)
-{
-#if 0
- nframes_t fade_frames;
-
- /* Don't allow fade of less 1 frame */
-
- if (fade_msecs < (1000.0 * (1.0/_current_frame_rate))) {
-
- fade_msecs = 0;
- fade_frames = 0;
-
- } else {
-
- fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
-
- }
-
- default_fade_msecs = fade_msecs;
- default_fade_steepness = steepness;
-
- {
- // jlc, WTF is this!
- Glib::RWLock::ReaderLock lm (route_lock);
- AudioRegion::set_default_fade (steepness, fade_frames);
- }
-
- set_dirty();
-
- /* XXX have to do this at some point */
- /* foreach region using default fade, reset, then
- refill_all_diskstream_buffers ();
- */
-#endif
-}
-
struct RouteSorter {
/** @return true to run r1 before r2, otherwise false */
+ bool sort_by_rec_enabled (const boost::shared_ptr<Route>& r1, const boost::shared_ptr<Route>& r2) {
+ if (r1->record_enabled()) {
+ if (r2->record_enabled()) {
+ /* both rec-enabled, just use signal order */
+ return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ } else {
+ /* r1 rec-enabled, r2 not rec-enabled, run r2 early */
+ return false;
+ }
+ } else {
+ if (r2->record_enabled()) {
+ /* r2 rec-enabled, r1 not rec-enabled, run r1 early */
+ return true;
+ } else {
+ /* neither rec-enabled, use signal order */
+ return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ }
+ }
+ }
+
bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
if (r2->feeds (r1)) {
/* r1 fed by r2; run r2 early */
} else {
if (r1->not_fed ()) {
if (r2->not_fed ()) {
- /* no ardour-based connections inbound to either route. just use signal order */
- return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
+ /* no ardour-based connections inbound to either route. */
+ return sort_by_rec_enabled (r1, r2);
} else {
/* r2 has connections, r1 does not; run r1 early */
return true;
static void
trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
{
- boost::shared_ptr<Route> r2;
+ boost::shared_ptr<Route> r2;
if (r1->feeds (rbase) && rbase->feeds (r1)) {
info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> r = writer.get_copy ();
+ boost::shared_ptr<RouteList> r = writer.get_copy ();
resort_routes_using (r);
/* writer goes out of scope and forces update */
}
}
-/** Find the route name starting with \a base with the lowest \a id.
+/** Find a route name starting with \a base, maybe followed by the
+ * lowest \a id. \a id will always be added if \a definitely_add_number
+ * is true on entry; otherwise it will only be added if required
+ * to make the name unique.
*
- * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
- * The available route name with the lowest ID will be used, and \a id
- * will be set to the ID.
+ * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
+ * The available route name with the lowest ID will be used, and \a id
+ * will be set to the ID.
*
- * \return false if a route name could not be found, and \a track_name
- * and \a id do not reflect a free route name.
+ * \return false if a route name could not be found, and \a track_name
+ * and \a id do not reflect a free route name.
*/
bool
-Session::find_route_name (const char* base, uint32_t& id, char* name, size_t name_len)
+Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
{
+ if (!definitely_add_number && route_by_name (base) == 0) {
+ /* juse use the base */
+ snprintf (name, name_len, "%s", base.c_str());
+ return true;
+ }
+
do {
- snprintf (name, name_len, "%s %" PRIu32, base, id);
+ snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
if (route_by_name (name) == 0) {
return true;
return false;
}
-/** Count the total ins and outs of all non-hidden routes in the session and return them in in and out */
+/** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
void
-Session::count_existing_route_channels (ChanCount& in, ChanCount& out)
+Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
{
in = ChanCount::ZERO;
out = ChanCount::ZERO;
- boost::shared_ptr<RouteList> r = routes.reader ();
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden()) {
- in += (*i)->n_inputs();
- out += (*i)->n_outputs();
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr && !tr->is_hidden()) {
+ in += tr->n_inputs();
+ out += tr->n_outputs();
}
}
}
-/** Caller must not hold process lock */
+/** Caller must not hold process lock
+ * @param name_template string to use for the start of the name, or "" to use "Midi".
+ */
list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
{
char track_name[32];
uint32_t track_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList new_routes;
list<boost::shared_ptr<MidiTrack> > ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses();
+ bool const use_number = (how_many != 1);
+
while (how_many) {
- if (!find_route_name ("Midi", ++track_id, track_name, sizeof(track_name))) {
+ if (!find_route_name (name_template.empty() ? _("Midi") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
error << "cannot find name for new midi track" << endmsg;
goto failed;
}
- boost::shared_ptr<MidiTrack> track;
+ boost::shared_ptr<MidiTrack> track;
try {
- MidiTrack* mt = new MidiTrack (*this, track_name, Route::Flag (0), mode);
+ track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
- if (mt->init ()) {
- delete mt;
+ if (track->init ()) {
goto failed;
}
- mt->use_new_diskstream();
-
- boost_debug_shared_ptr_mark_interesting (mt, "Track");
- track = boost::shared_ptr<MidiTrack>(mt);
+ track->use_new_diskstream();
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
}
}
- auto_connect_route (track.get(), existing_inputs, existing_outputs);
-
track->non_realtime_input_change();
if (route_group) {
failed:
if (!new_routes.empty()) {
- add_routes (new_routes, false);
- save_state (_current_snapshot_name);
+ add_routes (new_routes, true, true);
}
return ret;
}
-/** Caller must hold process lock.
- * @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
+void
+Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
+{
+ boost::shared_ptr<Route> midi_track (wmt.lock());
+
+ if (!midi_track) {
+ return;
+ }
+
+ if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
+
+ if (change.after.n_audio() <= change.before.n_audio()) {
+ return;
+ }
+
+ /* new audio ports: make sure the audio goes somewhere useful,
+ unless the user has no-auto-connect selected.
+
+ The existing ChanCounts don't matter for this call as they are only
+ to do with matching input and output indices, and we are only changing
+ outputs here.
+ */
+
+ ChanCount dummy;
+
+ auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
+ }
+}
+
+/** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
* @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
* @param output_start As \a input_start, but for outputs.
*/
void
-Session::auto_connect_route (
- Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs, bool connect_inputs, ChanCount input_start, ChanCount output_start
- )
+Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
+ bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
{
+ if (!IO::connecting_legal) {
+ return;
+ }
+
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::NOT_LOCK);
+
+ if (with_lock) {
+ lm.acquire ();
+ }
+
/* If both inputs and outputs are auto-connected to physical ports,
use the max of input and output offsets to ensure auto-connected
port numbers always match up (e.g. the first audio input and the
offset possible.
*/
+ DEBUG_TRACE (DEBUG::Graph,
+ string_compose("Auto-connect: existing in = %1 out = %2\n",
+ existing_inputs, existing_outputs));
+
const bool in_out_physical =
- (Config->get_input_auto_connect() & AutoConnectPhysical)
+ (Config->get_input_auto_connect() & AutoConnectPhysical)
&& (Config->get_output_auto_connect() & AutoConnectPhysical)
&& connect_inputs;
const ChanCount in_offset = in_out_physical
? ChanCount::max(existing_inputs, existing_outputs)
- : existing_inputs;
+ : existing_inputs;
const ChanCount out_offset = in_out_physical
? ChanCount::max(existing_inputs, existing_outputs)
if (!physinputs.empty() && connect_inputs) {
uint32_t nphysical_in = physinputs.size();
+
+ DEBUG_TRACE (DEBUG::Graph,
+ string_compose("There are %1 physical inputs of type %2\n",
+ nphysical_in, *t));
+
for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
string port;
-
+
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
+ DEBUG_TRACE (DEBUG::Graph,
+ string_compose("Get index %1 + %2 % %3 = %4\n",
+ in_offset.get(*t), i, nphysical_in,
+ (in_offset.get(*t) + i) % nphysical_in));
port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
}
- if (!port.empty() && route->input()->connect (
- route->input()->ports().port(*t, i), port, this)) {
+ DEBUG_TRACE (DEBUG::Graph,
+ string_compose("Connect route %1 IN to %2\n",
+ route->name(), port));
+
+ if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
break;
}
+
+ ChanCount one_added (*t, 1);
+ existing_inputs += one_added;
}
}
for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
string port;
- if (Config->get_output_auto_connect() & AutoConnectPhysical) {
+ if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
- } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
+ } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
+ /* master bus is audio only */
if (_master_out && _master_out->n_inputs().get(*t) > 0) {
port = _master_out->input()->ports().port(*t,
i % _master_out->input()->n_ports().get(*t))->name();
}
}
- if (!port.empty() && route->output()->connect (
- route->output()->ports().port(*t, i), port, this)) {
+ DEBUG_TRACE (DEBUG::Graph,
+ string_compose("Connect route %1 OUT to %2\n",
+ route->name(), port));
+
+ if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
break;
}
+
+ ChanCount one_added (*t, 1);
+ existing_outputs += one_added;
}
}
}
-
- existing_inputs += route->n_inputs();
- existing_outputs += route->n_outputs();
}
-/** Caller must not hold process lock */
+/** Caller must not hold process lock
+ * @param name_template string to use for the start of the name, or "" to use "Audio".
+ */
list< boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+Session::new_audio_track (
+ int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template
+ )
{
char track_name[32];
uint32_t track_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList new_routes;
list<boost::shared_ptr<AudioTrack> > ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses() + 1;
+ bool const use_number = (how_many != 1);
+
while (how_many) {
- if (!find_route_name ("Audio", ++track_id, track_name, sizeof(track_name))) {
+ if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
error << "cannot find name for new audio track" << endmsg;
goto failed;
}
-
boost::shared_ptr<AudioTrack> track;
+ boost::shared_ptr<AudioTrack> track;
try {
- AudioTrack* at = new AudioTrack (*this, track_name, Route::Flag (0), mode);
+ track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
- if (at->init ()) {
- delete at;
+ if (track->init ()) {
goto failed;
}
- at->use_new_diskstream();
-
- boost_debug_shared_ptr_mark_interesting (at, "Track");
- track = boost::shared_ptr<AudioTrack>(at);
+ track->use_new_diskstream();
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
<< endmsg;
goto failed;
}
-
- auto_connect_route (track.get(), existing_inputs, existing_outputs);
}
if (route_group) {
failed:
if (!new_routes.empty()) {
- add_routes (new_routes, true);
+ add_routes (new_routes, true, true);
}
return ret;
RemoteModel m = Config->get_remote_model();
bool emit_signal = false;
- boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (MixerOrdered == m) {
}
}
-/** Caller must not hold process lock */
+/** Caller must not hold process lock.
+ * @param name_template string to use for the start of the name, or "" to use "Bus".
+ */
RouteList
-Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
+Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
{
char bus_name[32];
uint32_t bus_id = 0;
- ChanCount existing_inputs;
- ChanCount existing_outputs;
string port;
RouteList ret;
uint32_t control_id;
- count_existing_route_channels (existing_inputs, existing_outputs);
-
control_id = ntracks() + nbusses() + 1;
+ bool const use_number = (how_many != 1);
while (how_many) {
- if (!find_route_name ("Bus", ++bus_id, bus_name, sizeof(bus_name))) {
+ if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
error << "cannot find name for new audio bus" << endmsg;
goto failure;
}
try {
- Route* rt = new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO);
+ boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
- if (rt->init ()) {
- delete rt;
+ if (bus->init ()) {
goto failure;
}
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
- boost::shared_ptr<Route> bus (rt);
-
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
+#endif
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
<< endmsg;
goto failure;
}
-
- auto_connect_route (bus.get(), existing_inputs, existing_outputs, false);
}
if (route_group) {
bus->set_remote_control_id (control_id);
++control_id;
- if (aux) {
- bus->add_internal_return ();
- }
+ bus->add_internal_return ();
ret.push_back (bus);
}
failure:
if (!ret.empty()) {
- add_routes (ret, true);
+ add_routes (ret, true, true);
}
return ret;
std::string node_name = IO::name_from_state (*node_copy.children().front());
/* generate a new name by adding a number to the end of the template name */
- if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name))) {
+ if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name), true)) {
fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
/*NOTREACHED*/
}
Track::zero_diskstream_id_in_xml (node_copy);
try {
- boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
+ boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
if (route == 0) {
error << _("Session: cannot create track/bus from template description") << endmsg;
picks up the configuration of the route. During session
loading this normally happens in a different way.
*/
+
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
change.after = route->input()->n_ports();
route->input()->changed (change, this);
out:
if (!ret.empty()) {
- add_routes (ret, true);
+ add_routes (ret, true, true);
}
return ret;
}
void
-Session::add_routes (RouteList& new_routes, bool save)
+Session::add_routes (RouteList& new_routes, bool auto_connect, bool save)
{
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
+
+ count_existing_track_channels (existing_inputs, existing_outputs);
+
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> r = writer.get_copy ();
+ boost::shared_ptr<RouteList> r = writer.get_copy ();
r->insert (r->end(), new_routes.begin(), new_routes.end());
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
if (mt) {
mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
+ mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
}
}
+
+ if (auto_connect) {
+ auto_connect_route (r, existing_inputs, existing_outputs, true);
+ }
}
if (_monitor_out && IO::connecting_legal) {
} else if ((*x)->is_master()) {
/* relax */
} else {
- (*x)->listen_via (_monitor_out,
- (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
- false, false);
+ (*x)->listen_via_monitor ();
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value (0.0);
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (0.0);
}
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value (1.0);
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (1.0);
}
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
}
}
}
+/** @param include_buses true to add sends to buses and tracks, false for just tracks */
void
-Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p)
+Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
{
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<RouteList> t (new RouteList);
- /* only send tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
+ if (include_buses || boost::dynamic_pointer_cast<Track>(*i)) {
t->push_back (*i);
}
}
continue;
}
- (*i)->listen_via (dest, p, true, true);
+ (*i)->listen_via (dest, p);
}
graph_reordered ();
{
RCUWriter<RouteList> writer (routes);
- boost::shared_ptr<RouteList> rs = writer.get_copy ();
+ boost::shared_ptr<RouteList> rs = writer.get_copy ();
rs->remove (route);
}
update_route_solo_state ();
- update_session_range_location_marker ();
// We need to disconnect the route's inputs and outputs
}
}
- update_latency_compensation (false, false);
+ update_latency_compensation ();
set_dirty();
/* Re-sort routes to remove the graph's current references to the one that is
return;
}
- if (route->listening()) {
+ if (route->listening_via_monitor ()) {
if (Config->get_exclusive_solo()) {
/* new listen: disable all other listen */
_listen_cnt--;
}
+
+ update_route_solo_state ();
}
void
Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
return;
}
- bool send_changed = false;
-
- if (route->solo_isolated()) {
- if (_solo_isolated_cnt == 0) {
- send_changed = true;
- }
- _solo_isolated_cnt++;
- } else if (_solo_isolated_cnt > 0) {
- _solo_isolated_cnt--;
- if (_solo_isolated_cnt == 0) {
- send_changed = true;
- }
- }
+ bool send_changed = false;
- if (send_changed) {
- IsolatedChanged (); /* EMIT SIGNAL */
- }
+ if (route->solo_isolated()) {
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ _solo_isolated_cnt++;
+ } else if (_solo_isolated_cnt > 0) {
+ _solo_isolated_cnt--;
+ if (_solo_isolated_cnt == 0) {
+ send_changed = true;
+ }
+ }
+
+ if (send_changed) {
+ IsolatedChanged (); /* EMIT SIGNAL */
+ }
}
void
something_soloed = true;
}
- if (!(*i)->is_hidden() && (*i)->listening()) {
+ if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
if (Config->get_solo_control_is_listen_control()) {
listeners++;
} else {
return boost::shared_ptr<Route> ((Route*) 0);
}
-/** If either end of the session range location marker lies inside the current
- * session extent, move it to the corresponding session extent.
+void
+Session::playlist_region_added (boost::weak_ptr<Region> w)
+{
+ boost::shared_ptr<Region> r = w.lock ();
+ if (!r) {
+ return;
+ }
+
+ /* These are the operations that are currently in progress... */
+ list<GQuark> curr = _current_trans_quarks;
+ curr.sort ();
+
+ /* ...and these are the operations during which we want to update
+ the session range location markers.
+ */
+ list<GQuark> ops;
+ ops.push_back (Operations::capture);
+ ops.push_back (Operations::paste);
+ ops.push_back (Operations::duplicate_region);
+ ops.push_back (Operations::insert_file);
+ ops.push_back (Operations::insert_region);
+ ops.push_back (Operations::drag_region_brush);
+ ops.push_back (Operations::region_drag);
+ ops.push_back (Operations::selection_grab);
+ ops.push_back (Operations::region_fill);
+ ops.push_back (Operations::fill_selection);
+ ops.push_back (Operations::create_region);
+ ops.push_back (Operations::region_copy);
+ ops.push_back (Operations::fixed_time_region_copy);
+ ops.sort ();
+
+ /* See if any of the current operations match the ones that we want */
+ list<GQuark> in;
+ set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
+
+ /* If so, update the session range markers */
+ if (!in.empty ()) {
+ maybe_update_session_range (r->position (), r->last_frame ());
+ }
+}
+
+/** Update the session range markers if a is before the current start or
+ * b is after the current end.
*/
void
-Session::update_session_range_location_marker ()
+Session::maybe_update_session_range (framepos_t a, framepos_t b)
{
if (_state_of_the_state & Loading) {
return;
}
- pair<framepos_t, framepos_t> const ext = get_extent ();
-
if (_session_range_location == 0) {
- /* we don't have a session range yet; use this one (provided it is valid) */
- if (ext.first != max_framepos) {
- add_session_range_location (ext.first, ext.second);
- }
+
+ add_session_range_location (a, b);
+
} else {
- /* update the existing session range */
- if (ext.first < _session_range_location->start()) {
- _session_range_location->set_start (ext.first);
- set_dirty ();
- }
- if (ext.second > _session_range_location->end()) {
- _session_range_location->set_end (ext.second);
- set_dirty ();
+ if (a < _session_range_location->start()) {
+ _session_range_location->set_start (a);
}
+ if (b > _session_range_location->end()) {
+ _session_range_location->set_end (b);
+ }
}
}
-/** @return Extent of the session's contents; if the session is empty, the first value of
- * the pair will equal max_framepos.
- */
-pair<framepos_t, framepos_t>
-Session::get_extent () const
+void
+Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
{
- pair<framepos_t, framepos_t> ext (max_framepos, 0);
-
- 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->destructive()) {
- // ignore tape tracks when getting extents
- continue;
- }
-
- pair<framepos_t, framepos_t> e = tr->playlist()->get_extent ();
- if (e.first < ext.first) {
- ext.first = e.first;
- }
- if (e.second > ext.second) {
- ext.second = e.second;
- }
+ for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ maybe_update_session_range (i->to, i->to + i->length);
}
+}
- return ext;
+void
+Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
+{
+ for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ maybe_update_session_range (i->from, i->to);
+ }
}
/* Region management */
RegionFactory::get_regions_using_source (*s, relevant_regions);
}
- cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
-
for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
set<boost::shared_ptr<Region> >::iterator tmp;
tmp = r;
++tmp;
- cerr << "Cleanup " << (*r)->name() << " UC = " << (*r).use_count() << endl;
-
playlists->destroy_region (*r);
RegionFactory::map_remove (*r);
(*r)->drop_sources ();
(*r)->drop_references ();
- cerr << "\tdone UC = " << (*r).use_count() << endl;
-
relevant_regions.erase (r);
r = tmp;
Analyser::queue_source_for_analysis (source, false);
}
}
- }
+
+ source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
+ }
}
void
Session::remove_source (boost::weak_ptr<Source> src)
{
+ if (_state_of_the_state & Deletion) {
+ return;
+ }
+
SourceMap::iterator i;
boost::shared_ptr<Source> source = src.lock();
Glib::Mutex::Lock lm (source_lock);
if ((i = sources.find (source->id())) != sources.end()) {
- cerr << "Removing source " << source->name() << endl;
sources.erase (i);
}
}
* (e.g. as returned by new_*_source_name)
*/
string
-Session::new_source_path_from_name (DataType type, const string& name, bool as_stub)
+Session::new_source_path_from_name (DataType type, const string& name)
{
assert(name.find("/") == string::npos);
sys::path p;
if (type == DataType::AUDIO) {
- p = (as_stub ? sdir.sound_stub_path() : sdir.sound_path());
+ p = sdir.sound_path();
} else if (type == DataType::MIDI) {
- p = (as_stub ? sdir.midi_stub_path() : sdir.midi_path());
+ p = sdir.midi_path();
} else {
error << "Unknown source type, unable to create file path" << endmsg;
return "";
SessionDirectory sdir((*i).path);
string spath = sdir.sound_path().to_string();
- string spath_stubs = sdir.sound_stub_path().to_string();
/* note that we search *without* the extension so that
we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
a file format change.
*/
- if (matching_unsuffixed_filename_exists_in (spath, buf) ||
- matching_unsuffixed_filename_exists_in (spath_stubs, buf)) {
+ if (matching_unsuffixed_filename_exists_in (spath, buf)) {
existing++;
break;
}
/** Create a new within-session audio source */
boost::shared_ptr<AudioFileSource>
-Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive, bool as_stub)
+Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
{
const string name = new_audio_source_name (n, n_chans, chan, destructive);
- const string path = new_source_path_from_name(DataType::AUDIO, name, as_stub);
+ const string path = new_source_path_from_name(DataType::AUDIO, name);
return boost::dynamic_pointer_cast<AudioFileSource> (
SourceFactory::createWritable (DataType::AUDIO, *this, path, string(), destructive, frame_rate()));
/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
-Session::create_midi_source_for_session (Track* track, string const & n, bool as_stub)
+Session::create_midi_source_for_session (Track* track, string const & n)
{
/* try to use the existing write source for the track, to keep numbering sane
*/
}
const string name = new_midi_source_name (n);
- const string path = new_source_path_from_name (DataType::MIDI, name, as_stub);
+ const string path = new_source_path_from_name (DataType::MIDI, name);
return boost::dynamic_pointer_cast<SMFSource> (
SourceFactory::createWritable (
boost::shared_ptr<AudioFileSource> fsource;
uint32_t x;
char buf[PATH_MAX+1];
- ChanCount nchans(track.n_channels());
+ ChanCount diskstream_channels (track.n_channels());
framepos_t position;
framecnt_t this_chunk;
framepos_t to_do;
framepos_t len = end - start;
bool need_block_size_reset = false;
string ext;
+ ChanCount const max_proc = track.max_processor_streams ();
if (end <= start) {
error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
- for (uint32_t chan_n=0; chan_n < nchans.n_audio(); ++chan_n) {
+ for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
for (x = 0; x < 99999; ++x) {
snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
- if (access (buf, F_OK) != 0) {
+ if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
break;
}
}
to_do = len;
/* create a set of reasonably-sized buffers */
- buffers.ensure_buffers(DataType::AUDIO, nchans.n_audio(), chunk_size);
- buffers.set_count(nchans);
+ buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
+ buffers.set_count (max_proc);
- for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
+ for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
if (afs)
afs->prepare_for_peakfile_writes ();
Session::get_silent_buffers (ChanCount count)
{
return ProcessThread::get_silent_buffers (count);
-#if 0
- assert(_silent_buffers->available() >= count);
- _silent_buffers->set_count(count);
-
- for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- for (size_t i= 0; i < count.get(*t); ++i) {
- _silent_buffers->get(*t, i).clear();
- }
- }
-
- return *_silent_buffers;
-#endif
}
BufferSet&
Session::get_scratch_buffers (ChanCount count)
{
return ProcessThread::get_scratch_buffers (count);
-#if 0
- if (count != ChanCount::ZERO) {
- assert(_scratch_buffers->available() >= count);
- _scratch_buffers->set_count(count);
- } else {
- _scratch_buffers->set_count (_scratch_buffers->available());
- }
-
- return *_scratch_buffers;
-#endif
}
BufferSet&
Session::get_mix_buffers (ChanCount count)
{
return ProcessThread::get_mix_buffers (count);
-#if 0
- assert(_mix_buffers->available() >= count);
- _mix_buffers->set_count(count);
- return *_mix_buffers;
-#endif
}
uint32_t
void
Session::listen_position_changed ()
{
- Placement p;
-
- switch (Config->get_listen_position()) {
- case AfterFaderListen:
- p = PostFader;
- break;
-
- case PreFaderListen:
- p = PreFader;
- break;
- }
-
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->put_monitor_send_at (p);
+ (*i)->listen_position_changed ();
}
}
}
void
-Session::add_session_range_location (nframes_t start, nframes_t end)
+Session::add_session_range_location (framepos_t start, framepos_t end)
{
_session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
_locations->add (_session_range_location);
/* Update the auto loop range to match the session range
(unless the auto loop range has been changed by the user)
*/
-
+
Location* s = _locations->session_range_location ();
+ if (s == 0) {
+ return;
+ }
+
Location* l = _locations->auto_loop_location ();
if (l->start() == old) {
*/
Location* s = _locations->session_range_location ();
+ if (s == 0) {
+ return;
+ }
+
Location* l = _locations->auto_loop_location ();
if (l->end() == old) {
}
}
-Speakers&
+boost::shared_ptr<Speakers>
Session::get_speakers()
{
- if (!_speakers) {
- _speakers = new Speakers;
- }
-
- return *_speakers;
+ return _speakers;
}
list<string>
return p;
}
+
+void
+Session::update_latency (bool playback)
+{
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
+
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ framecnt_t max_latency = 0;
+
+ if (playback) {
+ /* reverse the list so that we work backwards from the last route to run to the first */
+ reverse (r->begin(), r->end());
+ }
+
+ /* compute actual latency values for the given direction and store them all in per-port
+ structures. this will also publish the same values (to JACK) so that computation of latency
+ for routes can consistently use public latency values.
+ */
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
+ }
+
+ /* because we latency compensate playback, our published playback latencies should
+ be the same for all output ports - all material played back by ardour has
+ the same latency, whether its caused by plugins or by latency compensation. since
+ these may differ from the values computed above, reset all playback port latencies
+ to the same value.
+ */
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_public_port_latencies (max_latency, playback);
+ }
+
+ if (playback) {
+
+ post_playback_latency ();
+
+ } else {
+
+ post_capture_latency ();
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
+}
+
+void
+Session::post_playback_latency ()
+{
+ set_worst_playback_latency ();
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
+ _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
+ }
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->set_latency_compensation (_worst_track_latency);
+ }
+ }
+}
+
+void
+Session::post_capture_latency ()
+{
+ set_worst_capture_latency ();
+
+ /* reflect any changes in capture latencies into capture offsets
+ */
+
+ 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->set_capture_offset ();
+ }
+ }
+}
+
+void
+Session::set_worst_io_latencies ()
+{
+ set_worst_playback_latency ();
+ set_worst_capture_latency ();
+}
+
+void
+Session::set_worst_playback_latency ()
+{
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ _worst_output_latency = 0;
+
+ if (!_engine.connected()) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
+}
+
+void
+Session::set_worst_capture_latency ()
+{
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ _worst_input_latency = 0;
+
+ if (!_engine.connected()) {
+ return;
+ }
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
+}
+
+void
+Session::update_latency_compensation (bool force_whole_graph)
+{
+ bool some_track_latency_changed = false;
+
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
+ return;
+ }
+
+ DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
+
+ _worst_track_latency = 0;
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
+ framecnt_t tl;
+ if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
+ some_track_latency_changed = true;
+ }
+ _worst_track_latency = max (tl, _worst_track_latency);
+ }
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
+ (some_track_latency_changed ? "yes" : "no")));
+
+ if (force_whole_graph || some_track_latency_changed) {
+ /* trigger a full recompute of latency numbers for the graph.
+ everything else that we need to do will be done in the latency
+ callback.
+ */
+ _engine.update_total_latencies ();
+ return; // everything else will be done in the latency callback
+ }
+
+ DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n")
+}
+
projects / ardour.git / blobdiff