#include <unistd.h>
#include <limits.h>
-#include <sigc++/bind.h>
-#include <sigc++/retype.h>
#include <glibmm/thread.h>
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
+#include <glibmm/thread.h>
#include "pbd/error.h"
-#include <glibmm/thread.h>
+#include "pbd/boost_debug.h"
#include "pbd/pathscanner.h"
#include "pbd/stl_delete.h"
#include "pbd/basename.h"
#include "pbd/stacktrace.h"
#include "pbd/file_utils.h"
+#include "pbd/convert.h"
+#include "ardour/amp.h"
#include "ardour/analyser.h"
#include "ardour/audio_buffer.h"
#include "ardour/audio_diskstream.h"
+#include "ardour/audio_port.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/audiofilesource.h"
#include "ardour/auditioner.h"
#include "ardour/buffer_set.h"
#include "ardour/bundle.h"
+#include "ardour/butler.h"
#include "ardour/click.h"
#include "ardour/configuration.h"
#include "ardour/crossfade.h"
#include "ardour/cycle_timer.h"
#include "ardour/data_type.h"
+#include "ardour/debug.h"
#include "ardour/filename_extensions.h"
+#include "ardour/internal_send.h"
#include "ardour/io_processor.h"
#include "ardour/midi_diskstream.h"
#include "ardour/midi_playlist.h"
#include "ardour/midi_region.h"
#include "ardour/midi_track.h"
+#include "ardour/midi_ui.h"
#include "ardour/named_selection.h"
#include "ardour/playlist.h"
#include "ardour/plugin_insert.h"
#include "ardour/port_insert.h"
#include "ardour/processor.h"
+#include "ardour/rc_configuration.h"
#include "ardour/recent_sessions.h"
#include "ardour/region_factory.h"
#include "ardour/return.h"
#include "ardour/session_directory.h"
#include "ardour/session_directory.h"
#include "ardour/session_metadata.h"
+#include "ardour/session_playlists.h"
#include "ardour/slave.h"
#include "ardour/smf_source.h"
#include "ardour/source_factory.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "midi++/jack.h"
+
#include "i18n.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
using boost::shared_ptr;
+using boost::weak_ptr;
bool Session::_disable_all_loaded_plugins = false;
-sigc::signal<void,std::string> Session::Dialog;
-sigc::signal<int> Session::AskAboutPendingState;
-sigc::signal<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
-sigc::signal<void> Session::SendFeedback;
+PBD::Signal1<void,std::string> Session::Dialog;
+PBD::Signal0<int> Session::AskAboutPendingState;
+PBD::Signal2<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
+PBD::Signal0<void> Session::SendFeedback;
+
+PBD::Signal0<void> Session::TimecodeOffsetChanged;
+PBD::Signal0<void> Session::StartTimeChanged;
+PBD::Signal0<void> Session::EndTimeChanged;
+PBD::Signal0<void> Session::AutoBindingOn;
+PBD::Signal0<void> Session::AutoBindingOff;
+PBD::Signal2<void,std::string, std::string> Session::Exported;
+PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
-sigc::signal<void> Session::SMPTEOffsetChanged;
-sigc::signal<void> Session::StartTimeChanged;
-sigc::signal<void> Session::EndTimeChanged;
-sigc::signal<void> Session::AutoBindingOn;
-sigc::signal<void> Session::AutoBindingOff;
-sigc::signal<void, std::string, std::string> Session::Exported;
+static void clean_up_session_event (SessionEvent* ev) { delete ev; }
+const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
Session::Session (AudioEngine &eng,
const string& fullpath,
string mix_template)
: _engine (eng),
- phi (0),
- target_phi (0),
- phase (0),
+ _target_transport_speed (0.0),
_requested_return_frame (-1),
_scratch_buffers(new BufferSet()),
_silent_buffers(new BufferSet()),
_midi_port (default_midi_port),
_midi_clock_port (default_midi_clock_port),
_session_dir (new SessionDirectory(fullpath)),
- pending_events (2048),
state_tree (0),
- butler_mixdown_buffer (0),
- butler_gain_buffer (0),
- post_transport_work((PostTransportWork)0),
- _send_smpte_update (false),
- midi_thread (pthread_t (0)),
- midi_requests (128), // the size of this should match the midi request pool size
+ _butler (new Butler (*this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
diskstreams (new DiskstreamList),
routes (new RouteList),
_total_free_4k_blocks (0),
_have_rec_enabled_diskstream (false)
{
+ playlists.reset (new SessionPlaylists);
+
bool new_session;
+ interpolation.add_channel_to (0, 0);
+
if (!eng.connected()) {
throw failed_constructor();
}
- cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
+ info << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
n_physical_outputs = _engine.n_physical_outputs(DataType::AUDIO);
n_physical_inputs = _engine.n_physical_inputs(DataType::AUDIO);
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
- config.ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), true));
+ Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
+ config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
nframes_t initial_length)
: _engine (eng),
- phi (0),
- target_phi (0),
- phase (0),
+ _target_transport_speed (0.0),
_requested_return_frame (-1),
_scratch_buffers(new BufferSet()),
_silent_buffers(new BufferSet()),
_midi_port (default_midi_port),
_midi_clock_port (default_midi_clock_port),
_session_dir ( new SessionDirectory(fullpath)),
- pending_events (2048),
state_tree (0),
- butler_mixdown_buffer (0),
- butler_gain_buffer (0),
- post_transport_work((PostTransportWork)0),
- _send_smpte_update (false),
- midi_thread (pthread_t (0)),
- midi_requests (16),
+ _butler (new Butler (*this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
diskstreams (new DiskstreamList),
routes (new RouteList),
_total_free_4k_blocks (0),
_metadata (new SessionMetadata()),
_have_rec_enabled_diskstream (false)
{
+ playlists.reset (new SessionPlaylists);
+
bool new_session;
+ interpolation.add_channel_to (0, 0);
+
if (!eng.connected()) {
throw failed_constructor();
}
- cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
+ info << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
n_physical_outputs = _engine.n_physical_outputs (DataType::AUDIO);
n_physical_inputs = _engine.n_physical_inputs (DataType::AUDIO);
RouteList rl;
int control_id = 1;
- if (control_out_channels) {
- ChanCount count(DataType::AUDIO, control_out_channels);
- shared_ptr<Route> r (new Route (*this, _("monitor"), Route::ControlOut, DataType::AUDIO));
- r->ensure_io (count, count, false, this);
- r->set_remote_control_id (control_id++);
-
- rl.push_back (r);
- }
-
if (master_out_channels) {
ChanCount count(DataType::AUDIO, master_out_channels);
- cerr << "new MO with " << count << endl;
- shared_ptr<Route> r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO));
- r->ensure_io (count, count, false, this);
+ Route* rt = new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO);
+ 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);
output_ac = AutoConnectOption (output_ac & ~AutoConnectMaster);
}
+ if (control_out_channels) {
+ ChanCount count(DataType::AUDIO, control_out_channels);
+ Route* rt = new Route (*this, _("monitor"), Route::ControlOut, DataType::AUDIO);
+ boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ 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 (!rl.empty()) {
add_routes (rl, false);
}
}
+ if (no_auto_connect()) {
+ input_ac = AutoConnectOption (0);
+ output_ac = AutoConnectOption (0);
+ }
+
Config->set_input_auto_connect (input_ac);
Config->set_output_auto_connect (output_ac);
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
- Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
+ Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
}
Session::~Session ()
void
Session::destroy ()
{
+ vector<void*> debug_pointers;
+
/* if we got to here, leaving pending capture state around
is a mistake.
*/
_engine.remove_session ();
- GoingAway (); /* EMIT SIGNAL */
-
- /* do this */
+ /* clear region map. it doesn't hold references, but lets just be sensible here */
- notify_callbacks ();
+ RegionFactory::clear_map ();
/* clear history so that no references to objects are held any more */
delete state_tree;
- terminate_butler_thread ();
- //terminate_midi_thread ();
+ /* reset dynamic state version back to default */
+
+ Stateful::loading_state_version = 0;
+
+ delete _butler;
+ delete midi_control_ui;
if (click_data != default_click) {
delete [] click_data;
delete _silent_buffers;
delete _mix_buffers;
- AudioDiskstream::free_working_buffers();
-
- Route::SyncOrderKeys.clear();
-
-#undef TRACK_DESTRUCTION
-#ifdef TRACK_DESTRUCTION
- cerr << "delete named selections\n";
-#endif /* TRACK_DESTRUCTION */
- for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ) {
- NamedSelectionList::iterator tmp;
-
- tmp = i;
- ++tmp;
+ /* clear out any pending dead wood from RCU managed objects */
- delete *i;
- i = tmp;
- }
-
-#ifdef TRACK_DESTRUCTION
- cerr << "delete playlists\n";
-#endif /* TRACK_DESTRUCTION */
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ) {
- PlaylistList::iterator tmp;
-
- tmp = i;
- ++tmp;
-
- (*i)->drop_references ();
-
- i = tmp;
- }
-
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ) {
- PlaylistList::iterator tmp;
-
- tmp = i;
- ++tmp;
-
- (*i)->drop_references ();
-
- i = tmp;
- }
-
- playlists.clear ();
- unused_playlists.clear ();
+ routes.flush ();
+ diskstreams.flush ();
+ _bundles.flush ();
+
+ AudioDiskstream::free_working_buffers();
-#ifdef TRACK_DESTRUCTION
- cerr << "delete regions\n";
-#endif /* TRACK_DESTRUCTION */
+ /* tell everyone who is still standing that we're about to die */
+ drop_references ();
- for (RegionList::iterator i = regions.begin(); i != regions.end(); ) {
- RegionList::iterator tmp;
+ /* tell everyone to drop references and delete objects as we go */
- tmp = i;
- ++tmp;
+ DEBUG_TRACE (DEBUG::Destruction, "delete named selections\n");
+ named_selections.clear ();
+ DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for region %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
i->second->drop_references ();
-
- i = tmp;
}
-
regions.clear ();
-#ifdef TRACK_DESTRUCTION
- cerr << "delete routes\n";
-#endif /* TRACK_DESTRUCTION */
+ DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
+
+ /* reset these three references to special routes before we do the usual route delete thing */
+
+ auditioner.reset ();
+ _master_out.reset ();
+ _control_out.reset ();
+
{
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> r = writer.get_copy ();
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
(*i)->drop_references ();
}
+
r->clear ();
/* writer goes out of scope and updates master */
}
-
routes.flush ();
-#ifdef TRACK_DESTRUCTION
- cerr << "delete diskstreams\n";
-#endif /* TRACK_DESTRUCTION */
- {
- RCUWriter<DiskstreamList> dwriter (diskstreams);
- boost::shared_ptr<DiskstreamList> dsl = dwriter.get_copy();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->drop_references ();
- }
- dsl->clear ();
- }
- diskstreams.flush ();
-
-#ifdef TRACK_DESTRUCTION
- cerr << "delete audio sources\n";
-#endif /* TRACK_DESTRUCTION */
- for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
- SourceMap::iterator tmp;
-
- tmp = i;
- ++tmp;
+ boost::shared_ptr<RouteList> r = routes.reader ();
- i->second->drop_references ();
+ DEBUG_TRACE (DEBUG::Destruction, "delete diskstreams\n");
+ {
+ RCUWriter<DiskstreamList> dwriter (diskstreams);
+ boost::shared_ptr<DiskstreamList> dsl = dwriter.get_copy();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+ DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for diskstream %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
+ (*i)->drop_references ();
+ }
- i = tmp;
+ dsl->clear ();
}
- sources.clear ();
-
-#ifdef TRACK_DESTRUCTION
- cerr << "delete mix groups\n";
-#endif /* TRACK_DESTRUCTION */
- for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ) {
- list<RouteGroup*>::iterator tmp;
+ diskstreams.flush ();
- tmp = i;
- ++tmp;
-
- delete *i;
-
- i = tmp;
+ 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()));
+ i->second->drop_references ();
}
-#ifdef TRACK_DESTRUCTION
- cerr << "delete edit groups\n";
-#endif /* TRACK_DESTRUCTION */
- for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
- list<RouteGroup*>::iterator tmp;
-
- tmp = i;
- ++tmp;
+ sources.clear ();
+ DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
+ for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
+
delete *i;
-
- i = tmp;
}
- delete [] butler_mixdown_buffer;
- delete [] butler_gain_buffer;
-
Crossfade::set_buffer_size (0);
delete mmc;
+
+ /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
+ playlists.reset ();
+
+ boost_debug_list_ptrs ();
+
+ DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
}
void
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());
+ _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
+ _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
}
}
BootMessage (_("Using configuration"));
- Config->map_parameters (bind (mem_fun (*this, &Session::config_changed), false));
+ boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
+ boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
+
+ Config->map_parameters (ff);
+ config.map_parameters (ft);
/* every time we reconnect, recompute worst case output latencies */
- _engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
+ _engine.Running.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies, this));
if (synced_to_jack()) {
_engine.transport_stop ();
if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
/* existing state for Click */
+ int c;
- if (_click_io->set_state (*child->children().front()) == 0) {
+ if (Stateful::loading_state_version < 3000) {
+ c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
+ } else {
+ c = _click_io->set_state (*child->children().front(), Stateful::loading_state_version);
+ }
+
+ if (c == 0) {
_clicking = Config->get_clicking ();
-
+
} else {
-
+
error << _("could not setup Click I/O") << endmsg;
_clicking = false;
}
+
} else {
/* default state for Click: dual-mono to first 2 physical outputs */
string physical_output = _engine.get_nth_physical_output (DataType::AUDIO, physport);
if (physical_output.length()) {
- if (_click_io->add_output_port (physical_output, this)) {
+ if (_click_io->add_port (physical_output, this)) {
// relax, even though its an error
}
}
}
-
- if (_click_io->n_outputs () > ChanCount::ZERO) {
+
+ if (_click_io->n_ports () > ChanCount::ZERO) {
_clicking = Config->get_clicking ();
}
}
mono and stereo bundles, so that the common cases of mono
and stereo tracks get bundles to put in their mixer strip
in / out menus. There may be a nicer way of achieving that;
- it doesn't really scale that well to higher channel counts
+ it doesn't really scale that well to higher channel counts
*/
+ /* mono output bundles */
+
for (uint32_t np = 0; np < n_physical_outputs; ++np) {
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
- shared_ptr<Bundle> c (new Bundle (buf, true));
+ shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("mono"));
- c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+ c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
- add_bundle (c);
+ add_bundle (c);
}
+ /* stereo output bundles */
+
for (uint32_t np = 0; np < n_physical_outputs; np += 2) {
if (np + 1 < n_physical_outputs) {
char buf[32];
}
}
+ /* mono input bundles */
+
for (uint32_t np = 0; np < n_physical_inputs; ++np) {
char buf[32];
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
- shared_ptr<Bundle> c (new Bundle (buf, false));
+ shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("mono"));
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
- add_bundle (c);
+ add_bundle (c);
}
+ /* stereo input bundles */
+
for (uint32_t np = 0; np < n_physical_inputs; np += 2) {
if (np + 1 < n_physical_inputs) {
char buf[32];
}
}
- /* create master/control ports */
-
- if (_master_out) {
+ BootMessage (_("Setup signal flow and plugins"));
- /* force the master to ignore any later call to this
- */
- if (_master_out->pending_state_node) {
- _master_out->ports_became_legal();
- }
-
- /* if requested auto-connect the outputs to the first N physical ports.
- */
+ hookup_io ();
+
+ if (!no_auto_connect()) {
+
+ if (_master_out && Config->get_auto_connect_standard_busses()) {
+
+ /* if requested auto-connect the outputs to the first N physical ports.
+ */
- if (Config->get_auto_connect_master()) {
uint32_t limit = _master_out->n_outputs().n_total();
for (uint32_t n = 0; n < limit; ++n) {
- Port* p = _master_out->output (n);
+ Port* p = _master_out->output()->nth (n);
string connect_to = _engine.get_nth_physical_output (DataType (p->type()), n);
- if (!connect_to.empty()) {
- if (_master_out->connect_output (p, connect_to, this)) {
- error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
+ if (!connect_to.empty() && p->connected_to (connect_to) == false) {
+ if (_master_out->output()->connect (p, connect_to, this)) {
+ error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
<< endmsg;
break;
}
}
}
}
- }
-
- BootMessage (_("Setup signal flow and plugins"));
- hookup_io ();
+ if (_control_out) {
- /* catch up on send+insert cnts */
+ /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
+ are undefined, at best.
+ */
- BootMessage (_("Catch up with send/insert state"));
+ /* control out listens to master bus (but ignores it
+ under some conditions)
+ */
- insert_cnt = 0;
+ uint32_t limit = _control_out->n_inputs().n_audio();
- for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
- uint32_t id;
+ if (_master_out) {
+ for (uint32_t n = 0; n < limit; ++n) {
+ AudioPort* p = _control_out->input()->ports().nth_audio_port (n);
+ AudioPort* o = _master_out->output()->ports().nth_audio_port (n);
- if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
- if (id > insert_cnt) {
- insert_cnt = id;
+ if (o) {
+ string connect_to = o->name();
+ if (_control_out->input()->connect (p, connect_to, this)) {
+ error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
+ << endmsg;
+ break;
+ }
+ }
+ }
}
- }
- }
- send_cnt = 0;
+ /* if control out is not connected,
+ connect control out to physical outs, but use ones after the master if possible
+ */
+
+ if (!_control_out->output()->connected_to (boost::shared_ptr<IO>())) {
+
+ if (!Config->get_monitor_bus_preferred_bundle().empty()) {
+
+ boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
+
+ if (b) {
+ _control_out->output()->connect_ports_to_bundle (b, this);
+ } else {
+ warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
+ Config->get_monitor_bus_preferred_bundle())
+ << endmsg;
+ }
+
+ } else {
+
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ uint32_t shift = _master_out->n_outputs().get(*t);
+ uint32_t mod = _engine.n_physical_outputs (*t);
+ limit = _control_out->n_outputs().get(*t);
+
+ cerr << "Connecting " << limit << " control out ports, shift is " << shift
+ << " mod is " << mod << endl;
- for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
- uint32_t id;
+ for (uint32_t n = 0; n < limit; ++n) {
- if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
- if (id > send_cnt) {
- send_cnt = id;
+ Port* p = _control_out->output()->ports().port(*t, n);
+ string connect_to = _engine.get_nth_physical_output (*t, (n+shift) % mod);
+
+ if (!connect_to.empty()) {
+ if (_control_out->output()->connect (p, connect_to, this)) {
+ error << string_compose (
+ _("cannot connect control output %1 to %2"),
+ n, connect_to)
+ << endmsg;
+ break;
+ }
+ }
+ }
+ }
+ }
}
}
}
+ /* catch up on send+insert cnts */
_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
}
}
- /* Tell all IO objects to create their ports */
-
- IO::enable_ports ();
-
- /* Connect track to listen/solo etc. busses XXX generalize this beyond control_out */
-
- if (_control_out) {
-
- // _control_out->ensure_io (_control_out->input_minimum(), _control_out->output_minimum(), false, this);
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
-
- boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*x);
-
- if (t) {
- t->listen_via (_control_out, X_("listen"));
- }
- }
- }
-
/* load bundles, which we may have postponed earlier on */
if (_bundle_xml_node) {
load_bundles (*_bundle_xml_node);
/* Tell all IO objects to connect themselves together */
IO::enable_connecting ();
+ MIDI::JACK_MidiPort::MakeConnections ();
/* Now reset all panners */
- IO::reset_panners ();
+ Delivery::reset_panners ();
+
+ /* Connect tracks to listen/solo etc. busses XXX generalize this beyond control_out */
+
+ if (_control_out) {
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
+
+ if ((*x)->is_control() || (*x)->is_master()) {
+ continue;
+ }
+
+ (*x)->listen_via (_control_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
+ }
+ }
/* Anyone who cares about input state, wake up and do something */
_state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
-
/* now handle the whole enchilada as if it was one
graph reorder event.
*/
graph_reordered ();
- /* update mixer solo state */
+ /* update the full solo state, which can't be
+ correctly determined on a per-route basis, but
+ needs the global overview that only the session
+ has.
+ */
- catch_up_on_solo();
+ update_route_solo_state ();
}
void
}
void
-Session::diskstream_playlist_changed (boost::shared_ptr<Diskstream> dstream)
+Session::diskstream_playlist_changed (boost::weak_ptr<Diskstream> wp)
{
+ boost::shared_ptr<Diskstream> dstream = wp.lock ();
+ if (!dstream) {
+ return;
+ }
+
boost::shared_ptr<Playlist> playlist;
if ((playlist = dstream->playlist()) != 0) {
- playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
+ playlist->LengthChanged.connect_same_thread (*this, boost::bind (&Session::playlist_length_changed, this));
}
/* see comment in playlist_length_changed () */
Session::record_enabling_legal () const
{
/* this used to be in here, but survey says.... we don't need to restrict it */
- // if (record_status() == Recording) {
- // return false;
- // }
+ // if (record_status() == Recording) {
+ // return false;
+ // }
if (Config->get_all_safe()) {
return false;
void
Session::auto_punch_start_changed (Location* location)
{
- replace_event (Event::PunchIn, location->start());
+ replace_event (SessionEvent::PunchIn, location->start());
if (get_record_enabled() && config.get_punch_in()) {
/* capture start has been changed, so save new pending state */
{
nframes_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
- replace_event (Event::PunchOut, when_to_stop);
+ replace_event (SessionEvent::PunchOut, when_to_stop);
}
void
{
nframes_t when_to_stop = location->end();
- replace_event (Event::PunchIn, location->start());
+ replace_event (SessionEvent::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
- replace_event (Event::PunchOut, when_to_stop);
+ replace_event (SessionEvent::PunchOut, when_to_stop);
}
void
Session::auto_loop_changed (Location* location)
{
- replace_event (Event::AutoLoop, location->end(), location->start());
+ replace_event (SessionEvent::AutoLoop, location->end(), location->start());
if (transport_rolling() && play_loop) {
- //if (_transport_frame < location->start() || _transport_frame > location->end()) {
- if (_transport_frame > location->end()) {
+ // if (_transport_frame > location->end()) {
+
+ if (_transport_frame < location->start() || _transport_frame > location->end()) {
// relocate to beginning of loop
- clear_events (Event::LocateRoll);
+ clear_events (SessionEvent::LocateRoll);
request_locate (location->start(), true);
loop_changing = true;
if (location->end() > last_loopend) {
- clear_events (Event::LocateRoll);
- Event *ev = new Event (Event::LocateRoll, Event::Add, last_loopend, last_loopend, 0, true);
+ clear_events (SessionEvent::LocateRoll);
+ SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
queue_event (ev);
}
Location* existing;
if ((existing = _locations.auto_punch_location()) != 0 && existing != location) {
- auto_punch_start_changed_connection.disconnect();
- auto_punch_end_changed_connection.disconnect();
- auto_punch_changed_connection.disconnect();
+ punch_connections.drop_connections();
existing->set_auto_punch (false, this);
- remove_event (existing->start(), Event::PunchIn);
- clear_events (Event::PunchOut);
+ remove_event (existing->start(), SessionEvent::PunchIn);
+ clear_events (SessionEvent::PunchOut);
auto_punch_location_changed (0);
}
return;
}
- auto_punch_start_changed_connection.disconnect();
- auto_punch_end_changed_connection.disconnect();
- auto_punch_changed_connection.disconnect();
+ punch_connections.drop_connections ();
- auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
- auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
- auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
+ location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
+ location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
+ location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
location->set_auto_punch (true, this);
-
auto_punch_changed (location);
auto_punch_location_changed (location);
Location* existing;
if ((existing = _locations.auto_loop_location()) != 0 && existing != location) {
- auto_loop_start_changed_connection.disconnect();
- auto_loop_end_changed_connection.disconnect();
- auto_loop_changed_connection.disconnect();
+ loop_connections.drop_connections ();
existing->set_auto_loop (false, this);
- remove_event (existing->end(), Event::AutoLoop);
+ remove_event (existing->end(), SessionEvent::AutoLoop);
auto_loop_location_changed (0);
}
last_loopend = location->end();
- auto_loop_start_changed_connection.disconnect();
- auto_loop_end_changed_connection.disconnect();
- auto_loop_changed_connection.disconnect();
+ loop_connections.drop_connections ();
- auto_loop_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_loop_changed));
- auto_loop_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_loop_changed));
- auto_loop_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_loop_changed));
+ location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
+ location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
+ location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
location->set_auto_loop (true, this);
}
void
-Session::locations_added (Location* ignored)
+Session::locations_added (Location *)
{
set_dirty ();
}
// FIXME: timestamp correct? [DR]
// FIXME FIXME FIXME: rt_context? this must be called in the process thread.
// does this /need/ to be sent in all cases?
- if (rt_context)
+ if (rt_context) {
deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
+ }
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
set_dirty();
}
-nframes_t
+nframes64_t
Session::audible_frame () const
{
- nframes_t ret;
+ nframes64_t ret;
+ nframes64_t tf;
nframes_t offset;
- nframes_t tf;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
} else {
tf = _transport_frame;
}
-
+
ret = tf;
if (!non_realtime_work_pending()) {
if (tf < _last_roll_location + offset) {
return _last_roll_location;
}
- }
-
+ }
+
/* forwards */
ret -= offset;
}
void
-Session::set_default_fade (float steepness, float fade_msecs)
+Session::set_default_fade (float /*steepness*/, float /*fade_msecs*/)
{
#if 0
nframes_t fade_frames;
/* make a copy of the existing list of routes that feed r1 */
- set<shared_ptr<Route> > existing = r1->fed_by;
+ set<weak_ptr<Route> > existing = r1->fed_by;
/* for each route that feeds r1, recurse, marking it as feeding
rbase as well.
*/
- for (set<shared_ptr<Route> >::iterator i = existing.begin(); i != existing.end(); ++i) {
- r2 =* i;
-
+ for (set<weak_ptr<Route> >::iterator i = existing.begin(); i != existing.end(); ++i) {
+ if (!(r2 = (*i).lock ())) {
+ /* (*i) went away, ignore it */
+ continue;
+ }
+
/* r2 is a route that feeds r1 which somehow feeds base. mark
base as being fed by r2
*/
/* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
stop here.
- */
+ */
if ((r1->fed_by.find (r2) != r1->fed_by.end()) && (r2->fed_by.find (r1) != r2->fed_by.end())) {
continue;
}
-list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (TrackMode mode, uint32_t how_many)
+/** Find the route name starting with \a base with the lowest \a 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.
+ */
+bool
+Session::find_route_name (const char* base, uint32_t& id, char* name, size_t name_len)
{
- char track_name[32];
- uint32_t track_id = 0;
- uint32_t n = 0;
- string port;
- RouteList new_routes;
- list<boost::shared_ptr<MidiTrack> > ret;
- //uint32_t control_id;
+ do {
+ snprintf (name, name_len, "%s %" PRIu32, base, id);
- // FIXME: need physical I/O and autoconnect stuff for MIDI
+ if (route_by_name (name) == 0) {
+ return true;
+ }
- /* count existing midi tracks */
+ ++id;
- {
- shared_ptr<RouteList> r = routes.reader ();
+ } while (id < (UINT_MAX-1));
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<MidiTrack>(*i) != 0) {
- if (!(*i)->is_hidden()) {
- n++;
- //channels_used += (*i)->n_inputs().n_midi();
- }
- }
+ return false;
+}
+
+void
+Session::count_existing_route_channels (ChanCount& in, ChanCount& out)
+{
+ in = ChanCount::ZERO;
+ out = ChanCount::ZERO;
+ 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();
}
}
+}
- vector<string> physinputs;
- vector<string> physoutputs;
+list<boost::shared_ptr<MidiTrack> >
+Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+{
+ char track_name[32];
+ uint32_t track_id = 1;
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
+ string port;
+ RouteList new_routes;
+ list<boost::shared_ptr<MidiTrack> > ret;
+ uint32_t control_id;
- _engine.get_physical_outputs (DataType::MIDI, physoutputs);
- _engine.get_physical_inputs (DataType::MIDI, physinputs);
+ count_existing_route_channels (existing_inputs, existing_outputs);
- // control_id = ntracks() + nbusses();
+ control_id = ntracks() + nbusses();
while (how_many) {
-
- /* check for duplicate route names, since we might have pre-existing
- routes with this name (e.g. create Audio1, Audio2, delete Audio1,
- save, close,restart,add new route - first named route is now
- Audio2)
- */
-
-
- do {
- ++track_id;
-
- snprintf (track_name, sizeof(track_name), "Midi %" PRIu32, track_id);
-
- if (route_by_name (track_name) == 0) {
- break;
- }
-
- } while (track_id < (UINT_MAX-1));
+ if (!find_route_name ("Midi", track_id, track_name, sizeof(track_name))) {
+ error << "cannot find name for new midi track" << endmsg;
+ goto failed;
+ }
shared_ptr<MidiTrack> track;
try {
- track = boost::shared_ptr<MidiTrack>((new MidiTrack (*this, track_name, Route::Flag (0), mode)));
+ MidiTrack* mt = new MidiTrack (*this, track_name, Route::Flag (0), mode);
+ boost_debug_shared_ptr_mark_interesting (mt, "Track");
+ track = boost::shared_ptr<MidiTrack>(mt);
- if (track->ensure_io (ChanCount(DataType::MIDI, 1), ChanCount(DataType::AUDIO, 1), false, this)) {
+ if (track->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
goto failed;
}
- /*
- if (nphysical_in) {
- for (uint32_t x = 0; x < track->n_inputs().n_midi() && x < nphysical_in; ++x) {
-
- port = "";
-
- if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- port = physinputs[(channels_used+x)%nphysical_in];
- }
-
- if (port.length() && track->connect_input (track->input (x), port, this)) {
- break;
- }
- }
- }
-
- for (uint32_t x = 0; x < track->n_outputs().n_midi(); ++x) {
-
- port = "";
-
- if (nphysical_out && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
- port = physoutputs[(channels_used+x)%nphysical_out];
- } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
- if (_master_out) {
- port = _master_out->input (x%_master_out->n_inputs().n_midi())->name();
- }
- }
- if (port.length() && track->connect_output (track->output (x), port, this)) {
- break;
- }
+ if (track->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
+ error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
+ goto failed;
}
- channels_used += track->n_inputs ().n_midi();
-
- */
+ auto_connect_route (track, existing_inputs, existing_outputs);
track->midi_diskstream()->non_realtime_input_change();
+ if (route_group) {
+ route_group->add (track);
+ }
- track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
- //track->set_remote_control_id (control_id);
+ track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
+ track->set_remote_control_id (control_id);
new_routes.push_back (track);
ret.push_back (track);
return ret;
}
-list<boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
-{
- char track_name[32];
- uint32_t track_id = 0;
- uint32_t n = 0;
- uint32_t channels_used = 0;
- string port;
- RouteList new_routes;
- list<boost::shared_ptr<AudioTrack> > ret;
- uint32_t control_id;
+void
+Session::auto_connect_route (boost::shared_ptr<Route> route,
+ ChanCount& existing_inputs, ChanCount& existing_outputs)
+{
+ /* 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
+ first audio output of the route will have the same physical
+ port number). Otherwise just use the lowest input or output
+ offset possible.
+ */
+ const bool in_out_physical =
+ (Config->get_input_auto_connect() & AutoConnectPhysical)
+ && (Config->get_output_auto_connect() & AutoConnectPhysical);
- /* count existing audio tracks */
+ const ChanCount in_offset = in_out_physical
+ ? ChanCount::max(existing_inputs, existing_outputs)
+ : existing_inputs;
- {
- shared_ptr<RouteList> r = routes.reader ();
+ const ChanCount out_offset = in_out_physical
+ ? ChanCount::max(existing_inputs, existing_outputs)
+ : existing_outputs;
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<AudioTrack>(*i) != 0) {
- if (!(*i)->is_hidden()) {
- n++;
- channels_used += (*i)->n_inputs().n_audio();
- }
- }
- }
- }
+ static string empty_string;
+ string& port = empty_string;
- vector<string> physinputs;
- vector<string> physoutputs;
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ vector<string> physinputs;
+ vector<string> physoutputs;
- _engine.get_physical_outputs (DataType::AUDIO, physoutputs);
- _engine.get_physical_inputs (DataType::AUDIO, physinputs);
+ _engine.get_physical_outputs (*t, physoutputs);
+ _engine.get_physical_inputs (*t, physinputs);
- control_id = ntracks() + nbusses() + 1;
-
- while (how_many) {
+ if (!physinputs.empty()) {
+ uint32_t nphysical_in = physinputs.size();
+ for (uint32_t i = 0; i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
+ port = empty_string;
- /* check for duplicate route names, since we might have pre-existing
- routes with this name (e.g. create Audio1, Audio2, delete Audio1,
- save, close,restart,add new route - first named route is now
- Audio2)
- */
+ if (Config->get_input_auto_connect() & AutoConnectPhysical) {
+ port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
+ }
+ if (!port.empty() && route->input()->connect (
+ route->input()->ports().port(*t, i), port, this)) {
+ break;
+ }
+ }
+ }
- do {
- ++track_id;
+ if (!physoutputs.empty()) {
+ uint32_t nphysical_out = physoutputs.size();
+ for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
+ port = empty_string;
- snprintf (track_name, sizeof(track_name), "Audio %" PRIu32, track_id);
+ if (Config->get_output_auto_connect() & AutoConnectPhysical) {
+ port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
+ } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
+ 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 (route_by_name (track_name) == 0) {
- break;
+ if (!port.empty() && route->output()->connect (
+ route->output()->ports().port(*t, i), port, this)) {
+ break;
+ }
}
+ }
+ }
- } while (track_id < (UINT_MAX-1));
+ existing_inputs += route->n_inputs();
+ existing_outputs += route->n_outputs();
+}
+
+list<boost::shared_ptr<AudioTrack> >
+Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+{
+ char track_name[32];
+ uint32_t track_id = 1;
+ 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;
+
+ while (how_many) {
+ if (!find_route_name ("Audio", track_id, track_name, sizeof(track_name))) {
+ error << "cannot find name for new audio track" << endmsg;
+ goto failed;
+ }
shared_ptr<AudioTrack> track;
try {
- track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
+ AudioTrack* at = new AudioTrack (*this, track_name, Route::Flag (0), mode);
+ boost_debug_shared_ptr_mark_interesting (at, "Track");
+ track = boost::shared_ptr<AudioTrack>(at);
- if (track->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
- error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
+ if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
+ error << string_compose (
+ _("cannot configure %1 in/%2 out configuration for new audio track"),
input_channels, output_channels)
<< endmsg;
goto failed;
}
- if (!physinputs.empty()) {
- uint32_t nphysical_in = physinputs.size();
-
- for (uint32_t x = 0; x < track->n_inputs().n_audio() && x < nphysical_in; ++x) {
-
- port = "";
-
- if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- port = physinputs[(channels_used+x)%nphysical_in];
- }
-
- if (port.length() && track->connect_input (track->input (x), port, this)) {
- break;
- }
- }
+ if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
+ error << string_compose (
+ _("cannot configure %1 in/%2 out configuration for new audio track"),
+ input_channels, output_channels)
+ << endmsg;
+ goto failed;
}
- if (!physoutputs.empty()) {
- uint32_t nphysical_out = physoutputs.size();
+ auto_connect_route (track, existing_inputs, existing_outputs);
- for (uint32_t x = 0; x < track->n_outputs().n_audio(); ++x) {
- port = "";
-
- if (Config->get_output_auto_connect() & AutoConnectPhysical) {
- port = physoutputs[(channels_used+x)%nphysical_out];
- } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
- if (_master_out && _master_out->n_inputs().n_audio() > 0) {
- port = _master_out->input (x % _master_out->n_inputs().n_audio())->name();
- }
- }
-
- if (port.length() && track->connect_output (track->output (x), port, this)) {
- break;
- }
- }
+ if (route_group) {
+ route_group->add (track);
}
- channels_used += track->n_inputs ().n_audio();
-
track->audio_diskstream()->non_realtime_input_change();
- track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
+ track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
track->set_remote_control_id (control_id);
++control_id;
Session::set_remote_control_ids ()
{
RemoteModel m = Config->get_remote_model();
+ bool emit_signal = false;
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ( MixerOrdered == m) {
+ if (MixerOrdered == m) {
long order = (*i)->order_key(N_("signal"));
- (*i)->set_remote_control_id( order+1 );
- } else if ( EditorOrdered == m) {
+ (*i)->set_remote_control_id (order+1, false);
+ emit_signal = true;
+ } else if (EditorOrdered == m) {
long order = (*i)->order_key(N_("editor"));
- (*i)->set_remote_control_id( order+1 );
- } else if ( UserOrdered == m) {
+ (*i)->set_remote_control_id (order+1, false);
+ emit_signal = true;
+ } else if (UserOrdered == m) {
//do nothing ... only changes to remote id's are initiated by user
}
}
+
+ if (emit_signal) {
+ Route::RemoteControlIDChange();
+ }
}
RouteList
-Session::new_audio_route (int input_channels, int output_channels, uint32_t how_many)
+Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
{
char bus_name[32];
uint32_t bus_id = 1;
- uint32_t n = 0;
- uint32_t channels_used = 0;
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
string port;
RouteList ret;
uint32_t control_id;
- /* count existing audio busses */
-
- {
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
- /* its a bus ? */
- if (!(*i)->is_hidden() && (*i)->name() != _("master")) {
- bus_id++;
- n++;
- channels_used += (*i)->n_inputs().n_audio();
- }
- }
- }
- }
-
- vector<string> physinputs;
- vector<string> physoutputs;
-
- _engine.get_physical_outputs (DataType::AUDIO, physoutputs);
- _engine.get_physical_inputs (DataType::AUDIO, physinputs);
-
- n_physical_audio_outputs = physoutputs.size();
- n_physical_audio_inputs = physinputs.size();
+ count_existing_route_channels (existing_inputs, existing_outputs);
control_id = ntracks() + nbusses() + 1;
while (how_many) {
-
- do {
- snprintf (bus_name, sizeof(bus_name), "Bus %" PRIu32, bus_id);
-
- bus_id++;
-
- if (route_by_name (bus_name) == 0) {
- break;
- }
-
- } while (bus_id < (UINT_MAX-1));
+ if (!find_route_name ("Bus", bus_id, bus_name, sizeof(bus_name))) {
+ error << "cannot find name for new audio bus" << endmsg;
+ goto failure;
+ }
try {
- shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
+ Route* rt = new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO);
+ boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ shared_ptr<Route> bus (rt);
- if (bus->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
+ if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
input_channels, output_channels)
<< endmsg;
}
-
- /*
- for (uint32_t x = 0; n_physical_audio_inputs && x < bus->n_inputs(); ++x) {
-
- port = "";
-
- if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- port = physinputs[((n+x)%n_physical_audio_inputs)];
- }
-
- if (port.length() && bus->connect_input (bus->input (x), port, this)) {
- break;
- }
+ if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
+ error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
+ input_channels, output_channels)
+ << endmsg;
+ goto failure;
}
- */
- for (uint32_t x = 0; n_physical_audio_outputs && x < bus->n_outputs().n_audio(); ++x) {
- port = "";
+ auto_connect_route (bus, existing_inputs, existing_outputs);
- if (Config->get_output_auto_connect() & AutoConnectPhysical) {
- port = physoutputs[((n+x)%n_physical_outputs)];
- } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
- if (_master_out) {
- port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
- }
- }
-
- if (port.length() && bus->connect_output (bus->output (x), port, this)) {
- break;
- }
+ if (route_group) {
+ route_group->add (bus);
}
-
- channels_used += bus->n_inputs ().n_audio();
-
bus->set_remote_control_id (control_id);
++control_id;
+ if (aux) {
+ bus->add_internal_return ();
+ }
+
ret.push_back (bus);
}
RouteList ret;
uint32_t control_id;
XMLTree tree;
+ uint32_t number = 1;
if (!tree.read (template_path.c_str())) {
return ret;
while (how_many) {
XMLNode node_copy (*node); // make a copy so we can change the name if we need to
-
- std::string node_name = IO::name_from_state (*node_copy.children().front());
- if (route_by_name (node_name) != 0) {
-
- /* generate a new name by adding a number to the end of the template name */
-
- uint32_t number = 1;
-
- do {
- snprintf (name, sizeof (name), "%s %" PRIu32, node_name.c_str(), number);
-
- number++;
-
- if (route_by_name (name) == 0) {
- break;
- }
-
- } while (number < UINT_MAX);
-
- if (number == UINT_MAX) {
- fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
- /*NOTREACHED*/
- }
+ std::string node_name = IO::name_from_state (*node_copy.children().front());
- IO::set_name_in_state (*node_copy.children().front(), name);
+ /* 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))) {
+ fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
+ /*NOTREACHED*/
}
+ IO::set_name_in_state (*node_copy.children().front(), name);
+
Track::zero_diskstream_id_in_xml (node_copy);
try {
- shared_ptr<Route> route (XMLRouteFactory (node_copy));
+ 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.
*/
- route->input_changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
- route->output_changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
+ route->input()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
+ route->output()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
}
-
+
route->set_remote_control_id (control_id);
++control_id;
-
+
ret.push_back (route);
}
-
+
catch (failed_constructor &err) {
error << _("Session: could not create new route from template") << endmsg;
goto out;
}
-
+
catch (AudioEngine::PortRegistrationFailure& pfe) {
error << pfe.what() << endmsg;
goto out;
}
-
+
--how_many;
}
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> r = writer.get_copy ();
r->insert (r->end(), new_routes.begin(), new_routes.end());
- resort_routes_using (r);
+
+
+ /* if there is no control out and we're not in the middle of loading,
+ resort the graph here. if there is a control out, we will resort
+ toward the end of this method. if we are in the middle of loading,
+ we will resort when done.
+ */
+
+ if (!_control_out && IO::connecting_legal) {
+ resort_routes_using (r);
+ }
}
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
boost::weak_ptr<Route> wpr (*x);
+ boost::shared_ptr<Route> r (*x);
- (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
- (*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
- (*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
- (*x)->processors_changed.connect (bind (mem_fun (*this, &Session::update_latency_compensation), false, false));
+ r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
+ r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, wpr));
+ r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
+ 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->route_group_changed.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
- if ((*x)->is_master()) {
- _master_out = (*x);
+ if (r->is_master()) {
+ _master_out = r;
}
- if ((*x)->is_control()) {
- _control_out = (*x);
+ if (r->is_control()) {
+ _control_out = r;
}
}
if (_control_out && IO::connecting_legal) {
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- (*x)->listen_via (_control_out, "control");
+ if ((*x)->is_control() || (*x)->is_master()) {
+ continue;
+ }
+ (*x)->listen_via (_control_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
}
+
+ resort_routes ();
}
set_dirty();
}
RouteAdded (new_routes); /* EMIT SIGNAL */
+ Route::RemoteControlIDChange (); /* EMIT SIGNAL */
+}
+
+void
+Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
+{
+ 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);
+ }
+ }
+ }
+}
+
+void
+Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
+{
+ 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);
+ }
+ }
+ }
+}
+
+void
+Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
+{
+ 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());
+ }
+ }
+ }
+}
+
+void
+Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p)
+{
+ 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)) {
+ t->push_back (*i);
+ }
+ }
+
+ add_internal_sends (dest, p, t);
+}
+
+void
+Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
+{
+ if (dest->is_control() || dest->is_master()) {
+ return;
+ }
+
+ if (!dest->internal_return()) {
+ dest->add_internal_return();
+ }
+
+ for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
+
+ if ((*i)->is_control() || (*i)->is_master() || (*i) == dest) {
+ continue;
+ }
+
+ (*i)->listen_via (dest, p, true, true);
+ }
+
+ graph_reordered ();
}
void
/* writer goes out of scope, copies ds back to main */
}
- dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
+ dstream->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::diskstream_playlist_changed, this, boost::weak_ptr<Diskstream> (dstream)));
/* this will connect to future changes, and check the current length */
- diskstream_playlist_changed (dstream);
+ diskstream_playlist_changed (boost::weak_ptr<Diskstream> (dstream));
- dstream->RecordEnableChanged.connect (mem_fun (*this, &Session::update_have_rec_enabled_diskstream));
+ dstream->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_diskstream, this));
dstream->prepare ();
}
if (route == _control_out) {
+
/* cancel control outs for all routes */
for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
(*r)->drop_listen (_control_out);
}
- _control_out = shared_ptr<Route> ();
+ _control_out.reset ();
}
update_route_solo_state ();
// We need to disconnect the routes inputs and outputs
- route->disconnect_inputs (0);
- route->disconnect_outputs (0);
+ route->input()->disconnect (0);
+ route->output()->disconnect (0);
+
+ /* if the route had internal sends sending to it, remove them */
+ if (route->internal_return()) {
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
+ if (s) {
+ (*i)->remove_processor (s);
+ }
+ }
+ }
update_latency_compensation (false, false);
set_dirty();
sync_order_keys (N_("session"));
+ Route::RemoteControlIDChange(); /* EMIT SIGNAL */
+
/* save the new state of the world */
if (save_state (_current_snapshot_name)) {
}
void
-Session::route_mute_changed (void* src)
+Session::route_mute_changed (void* /*src*/)
{
set_dirty ();
}
void
-Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
+Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
- if (solo_update_disabled) {
- // We know already
- return;
- }
-
- bool is_track;
- boost::shared_ptr<Route> route = wpr.lock ();
-
+ boost::shared_ptr<Route> route = wpr.lock();
if (!route) {
- /* should not happen */
error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
return;
}
- is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
-
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
- /* soloing a track mutes all other tracks, soloing a bus mutes all other busses */
-
- if (is_track) {
-
- /* don't mess with busses */
-
- if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
- continue;
- }
-
- } else {
-
- /* don't mess with tracks */
-
- if (boost::dynamic_pointer_cast<Track>(*i) != 0) {
- continue;
- }
- }
-
- if ((*i) != route &&
- ((*i)->mix_group () == 0 ||
- (*i)->mix_group () != route->mix_group () ||
- !route->mix_group ()->is_active())) {
-
- if ((*i)->soloed()) {
-
- /* if its already soloed, and solo latching is enabled,
- then leave it as it is.
- */
-
- if (Config->get_solo_latched()) {
- continue;
- }
- }
-
- /* do it */
-
- solo_update_disabled = true;
- (*i)->set_solo (false, src);
- solo_update_disabled = false;
- }
- }
-
- bool something_soloed = false;
- bool same_thing_soloed = false;
- bool signal = false;
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ((*i)->soloed()) {
- something_soloed = true;
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if (is_track) {
- same_thing_soloed = true;
- break;
- }
- } else {
- if (!is_track) {
- same_thing_soloed = true;
- break;
- }
- }
- break;
- }
- }
-
- if (something_soloed != currently_soloing) {
- signal = true;
- currently_soloing = something_soloed;
+ if (route->listening()) {
+ _listen_cnt++;
+ } else if (_listen_cnt > 0) {
+ _listen_cnt--;
}
-
- modify_solo_mute (is_track, same_thing_soloed);
-
- if (signal) {
- SoloActive (currently_soloing); /* EMIT SIGNAL */
- }
-
- SoloChanged (); /* EMIT SIGNAL */
-
- set_dirty();
}
void
-Session::update_route_solo_state ()
+Session::route_solo_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
- bool mute = false;
- bool is_track = false;
- bool signal = false;
-
- /* this is where we actually implement solo by changing
- the solo mute setting of each track.
- */
-
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ((*i)->soloed()) {
- mute = true;
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- is_track = true;
- }
- break;
- }
- }
-
- if (mute != currently_soloing) {
- signal = true;
- currently_soloing = mute;
- }
-
- if (!is_track && !mute) {
-
- /* nothing is soloed */
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_solo_mute (false);
- }
-
- if (signal) {
- SoloActive (false);
- }
-
+ if (solo_update_disabled) {
+ // We know already
return;
}
- modify_solo_mute (is_track, mute);
+ boost::shared_ptr<Route> route = wpr.lock ();
- if (signal) {
- SoloActive (currently_soloing);
+ if (!route) {
+ /* should not happen */
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ return;
}
-}
-void
-Session::modify_solo_mute (bool is_track, bool mute)
-{
shared_ptr<RouteList> r = routes.reader ();
+ int32_t delta;
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
- if (is_track) {
-
- /* only alter track solo mute */
-
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((*i)->soloed()) {
- (*i)->set_solo_mute (!mute);
- } else {
- (*i)->set_solo_mute (mute);
- }
- }
-
- } else {
-
- /* only alter bus solo mute */
+ if (route->self_soloed()) {
+ delta = 1;
+ } else {
+ delta = -1;
+ }
- if (!boost::dynamic_pointer_cast<Track>(*i)) {
+ /* now mod the solo level of all other routes except master & control outs
+ so that they will be silent if appropriate.
+ */
- if ((*i)->soloed()) {
+ solo_update_disabled = true;
- (*i)->set_solo_mute (false);
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ bool via_sends_only;
- } else {
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_control() || (*i)->is_hidden()) {
+ continue;
+ } else if ((*i)->feeds (route, &via_sends_only)) {
+ if (!via_sends_only) {
+ (*i)->mod_solo_by_others (delta);
+ }
+ }
+ }
- /* don't mute master or control outs
- in response to another bus solo
- */
+ /* make sure master is never muted by solo */
- if ((*i) != _master_out &&
- (*i) != _control_out) {
- (*i)->set_solo_mute (mute);
- }
- }
- }
+ if (_master_out && route != _master_out && _master_out->soloed_by_others() == 0 && !_master_out->soloed()) {
+ _master_out->mod_solo_by_others (1);
+ }
+
+ /* ditto for control outs make sure master is never muted by solo */
- }
+ if (_control_out && route != _control_out && _control_out && _control_out->soloed_by_others() == 0) {
+ _control_out->mod_solo_by_others (1);
}
-}
+ solo_update_disabled = false;
+ update_route_solo_state (r);
+ SoloChanged (); /* EMIT SIGNAL */
+ set_dirty();
+}
void
-Session::catch_up_on_solo ()
+Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
{
- /* this is called after set_state() to catch the full solo
- state, which can't be correctly determined on a per-route
- basis, but needs the global overview that only the session
- has.
- */
- update_route_solo_state();
-}
+ /* now figure out if anything that matters is soloed */
-void
-Session::catch_up_on_solo_mute_override ()
-{
- if (Config->get_solo_model() != InverseMute) {
- return;
+ bool something_soloed = false;
+
+ if (!r) {
+ r = routes.reader();
}
- /* this is called whenever the param solo-mute-override is
- changed.
- */
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_master() && !(*i)->is_control() && !(*i)->is_hidden() && (*i)->self_soloed()) {
+ something_soloed = true;
+ break;
+ }
+ }
+
+ if (something_soloed != _non_soloed_outs_muted) {
+ _non_soloed_outs_muted = something_soloed;
+ SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
+ }
+}
+
+boost::shared_ptr<RouteList>
+Session::get_routes_with_internal_returns() const
+{
shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> rl (new RouteList);
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->catch_up_on_solo_mute_override ();
+ if ((*i)->internal_return ()) {
+ rl->push_back (*i);
+ }
}
-}
+ return rl;
+}
shared_ptr<Route>
Session::route_by_name (string name)
}
}
- region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
- region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
-
+ region->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
update_region_name_map (region);
}
Session::update_region_name_map (boost::shared_ptr<Region> region)
{
string::size_type last_period = region->name().find_last_of ('.');
-
+
if (last_period != string::npos && last_period < region->name().length() - 1) {
-
+
string base = region->name().substr (0, last_period);
string number = region->name().substr (last_period+1);
map<string,uint32_t>::iterator x;
-
+
/* note that if there is no number, we get zero from atoi,
which is just fine
*/
-
+
region_name_map[base] = atoi (number);
}
}
void
-Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
+Session::region_changed (const PropertyChange& what_changed, boost::weak_ptr<Region> weak_region)
{
boost::shared_ptr<Region> region (weak_region.lock ());
return;
}
- if (what_changed & Region::HiddenChanged) {
+ if (what_changed.contains (Properties::hidden)) {
/* relay hidden changes */
RegionHiddenChange (region);
}
- if (what_changed & NameChanged) {
+ if (what_changed.contains (Properties::name)) {
update_region_name_map (region);
}
}
return boost::shared_ptr<Region> ();
}
-void
-Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
-{
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i)
- (*i)->get_region_list_equivalent_regions (region, result);
-}
-
int
Session::destroy_region (boost::shared_ptr<Region> region)
{
}
}
+ for (list<boost::shared_ptr<Region> >::iterator i = r.begin(); i != r.end(); ++i) {
+ remove_region (*i);
+ }
+
destroy_regions (r);
save_state (_current_snapshot_name);
}
if (result.second) {
- source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
set_dirty();
}
return path;
}
-/** Return the full path (in some session directory) for a new embedded source.
+/** Return the full path (in some session directory) for a new within-session source.
* \a name must be a session-unique name that does not contain slashes
* (e.g. as returned by new_*_source_name)
*/
return Glib::path_get_basename(buf);
}
-/** Create a new embedded audio source */
+/** Create a new within-session audio source */
boost::shared_ptr<AudioFileSource>
Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
{
const size_t n_chans = ds.n_channels().n_audio();
const string name = new_audio_source_name (ds.name(), n_chans, chan, destructive);
const string path = new_source_path_from_name(DataType::AUDIO, name);
+
return boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (
- DataType::AUDIO, *this, path, true, destructive, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
}
/** Return a unique name based on \a base for a new internal MIDI source */
}
-/** Create a new embedded MIDI source */
+/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
Session::create_midi_source_for_session (MidiDiskstream& ds)
{
return boost::dynamic_pointer_cast<SMFSource> (
SourceFactory::createWritable (
- DataType::MIDI, *this, path, true, false, frame_rate()));
-}
-
-
-/* Playlist management */
-
-boost::shared_ptr<Playlist>
-Session::playlist_by_name (string name)
-{
- Glib::Mutex::Lock lm (playlist_lock);
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- if ((*i)->name() == name) {
- return* i;
- }
- }
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
- if ((*i)->name() == name) {
- return* i;
- }
- }
-
- return boost::shared_ptr<Playlist>();
+ DataType::MIDI, *this, path, false, frame_rate()));
}
-void
-Session::unassigned_playlists (std::list<boost::shared_ptr<Playlist> > & list)
-{
- Glib::Mutex::Lock lm (playlist_lock);
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- if (!(*i)->get_orig_diskstream_id().to_s().compare ("0")) {
- list.push_back (*i);
- }
- }
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
- if (!(*i)->get_orig_diskstream_id().to_s().compare ("0")) {
- list.push_back (*i);
- }
- }
-}
void
Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
return;
}
- {
- Glib::Mutex::Lock lm (playlist_lock);
- if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
- playlists.insert (playlists.begin(), playlist);
- playlist->InUse.connect (sigc::bind (mem_fun (*this, &Session::track_playlist), boost::weak_ptr<Playlist>(playlist)));
- playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
- }
- }
+ playlists->add (playlist);
if (unused) {
playlist->release();
}
set_dirty();
-
- PlaylistAdded (playlist); /* EMIT SIGNAL */
-}
-
-void
-Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
-{
- {
- Glib::Mutex::Lock lm (playlist_lock);
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- s.push_back (*i);
- }
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
- s.push_back (*i);
- }
- }
-}
-
-void
-Session::track_playlist (bool inuse, boost::weak_ptr<Playlist> wpl)
-{
- boost::shared_ptr<Playlist> pl(wpl.lock());
-
- if (!pl) {
- return;
- }
-
- PlaylistList::iterator x;
-
- if (pl->hidden()) {
- /* its not supposed to be visible */
- return;
- }
-
- {
- Glib::Mutex::Lock lm (playlist_lock);
-
- if (!inuse) {
-
- unused_playlists.insert (pl);
-
- if ((x = playlists.find (pl)) != playlists.end()) {
- playlists.erase (x);
- }
-
-
- } else {
-
- playlists.insert (pl);
-
- if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
- unused_playlists.erase (x);
- }
- }
- }
}
void
return;
}
- {
- Glib::Mutex::Lock lm (playlist_lock);
-
- PlaylistList::iterator i;
-
- i = find (playlists.begin(), playlists.end(), playlist);
- if (i != playlists.end()) {
- playlists.erase (i);
- }
-
- i = find (unused_playlists.begin(), unused_playlists.end(), playlist);
- if (i != unused_playlists.end()) {
- unused_playlists.erase (i);
- }
-
- }
+ playlists->remove (playlist);
set_dirty();
-
- PlaylistRemoved (playlist); /* EMIT SIGNAL */
}
void
Session::set_audition (boost::shared_ptr<Region> r)
{
pending_audition_region = r;
- post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
- schedule_butler_transport_work ();
+ add_post_transport_work (PostTransportAudition);
+ _butler->schedule_transport_work ();
}
void
Session::audition_playlist ()
{
- Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
+ SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
ev->region.reset ();
queue_event (ev);
}
void
Session::audition_region (boost::shared_ptr<Region> r)
{
- Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
+ SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
ev->region = r;
queue_event (ev);
}
TapeFileMatcher tape_file_matcher;
remove_if (audio_filenames.begin(), audio_filenames.end(),
- sigc::mem_fun (tape_file_matcher, &TapeFileMatcher::matches));
-
+ boost::bind (&TapeFileMatcher::matches, &tape_file_matcher, _1));
+
for (vector<string>::iterator i = audio_filenames.begin(); i != audio_filenames.end(); ++i) {
sys::path audio_file_path (_session_dir->sound_path());
}
}
-void
-Session::set_all_solo (bool yn)
-{
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden()) {
- (*i)->set_solo (yn, this);
- }
- }
-
- set_dirty();
-}
-
-void
-Session::set_all_mute (bool yn)
-{
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden()) {
- (*i)->set_mute (yn, this);
- }
- }
-
- set_dirty();
-}
-
uint32_t
Session::n_diskstreams () const
{
Session::graph_reordered ()
{
/* don't do this stuff if we are setting up connections
- from a set_state() call or creating new tracks.
+ from a set_state() call or creating new tracks. Ditto for deletion.
*/
- if (_state_of_the_state & InitialConnecting) {
+ if (_state_of_the_state & (InitialConnecting|Deletion)) {
return;
}
}
}
-void
-Session::record_disenable_all ()
-{
- record_enable_change_all (false);
-}
-
-void
-Session::record_enable_all ()
-{
- record_enable_change_all (true);
-}
-
-void
-Session::record_enable_change_all (bool yn)
-{
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- boost::shared_ptr<Track> t;
-
- if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
- t->set_record_enable (yn, this);
- }
- }
-
- /* since we don't keep rec-enable state, don't mark session dirty */
-}
-
void
Session::add_processor (Processor* processor)
{
- Send* send;
- Return* retrn;
- PortInsert* port_insert;
- PluginInsert* plugin_insert;
-
- if ((port_insert = dynamic_cast<PortInsert *> (processor)) != 0) {
- _port_inserts.insert (_port_inserts.begin(), port_insert);
- } else if ((plugin_insert = dynamic_cast<PluginInsert *> (processor)) != 0) {
- _plugin_inserts.insert (_plugin_inserts.begin(), plugin_insert);
- } else if ((send = dynamic_cast<Send *> (processor)) != 0) {
- _sends.insert (_sends.begin(), send);
- } else if ((retrn = dynamic_cast<Return *> (processor)) != 0) {
- _returns.insert (_returns.begin(), retrn);
- } else {
- fatal << _("programming error: unknown type of Insert created!") << endmsg;
- /*NOTREACHED*/
- }
-
- processor->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_processor), processor));
-
+ /* Session does not own Processors (they belong to a Route) but we do want to track
+ the arrival and departure of port inserts, sends and returns for naming
+ purposes.
+ */
+ processor->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_processor, this, processor));
set_dirty();
}
Send* send;
Return* retrn;
PortInsert* port_insert;
- PluginInsert* plugin_insert;
if ((port_insert = dynamic_cast<PortInsert *> (processor)) != 0) {
- list<PortInsert*>::iterator x = find (_port_inserts.begin(), _port_inserts.end(), port_insert);
- if (x != _port_inserts.end()) {
- insert_bitset[port_insert->bit_slot()] = false;
- _port_inserts.erase (x);
- }
- } else if ((plugin_insert = dynamic_cast<PluginInsert *> (processor)) != 0) {
- _plugin_inserts.remove (plugin_insert);
+ insert_bitset[port_insert->bit_slot()] = false;
} else if ((send = dynamic_cast<Send *> (processor)) != 0) {
- list<Send*>::iterator x = find (_sends.begin(), _sends.end(), send);
- if (x != _sends.end()) {
- send_bitset[send->bit_slot()] = false;
- _sends.erase (x);
- }
+ send_bitset[send->bit_slot()] = false;
} else if ((retrn = dynamic_cast<Return *> (processor)) != 0) {
- list<Return*>::iterator x = find (_returns.begin(), _returns.end(), retrn);
- if (x != _returns.end()) {
- return_bitset[send->bit_slot()] = false;
- _returns.erase (x);
- }
- } else {
- fatal << _("programming error: unknown type of Insert deleted!") << endmsg;
- /*NOTREACHED*/
+ return_bitset[retrn->bit_slot()] = false;
}
set_dirty();
Session::bundle_by_name (string name) const
{
boost::shared_ptr<BundleList> b = _bundles.reader ();
-
+
for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
void
-Session::tempo_map_changed (Change ignored)
+Session::tempo_map_changed (const PropertyChange&)
{
clear_clicks ();
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- (*i)->update_after_tempo_map_change ();
- }
-
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
- (*i)->update_after_tempo_map_change ();
- }
+ playlists->update_after_tempo_map_change ();
set_dirty ();
}
/* Named Selection management */
-NamedSelection *
+boost::shared_ptr<NamedSelection>
Session::named_selection_by_name (string name)
{
Glib::Mutex::Lock lm (named_selection_lock);
for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
if ((*i)->name == name) {
- return* i;
+ return *i;
}
}
- return 0;
+ return boost::shared_ptr<NamedSelection>();
}
void
-Session::add_named_selection (NamedSelection* named_selection)
+Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
{
{
Glib::Mutex::Lock lm (named_selection_lock);
named_selections.insert (named_selections.begin(), named_selection);
}
- for (list<boost::shared_ptr<Playlist> >::iterator i = named_selection->playlists.begin(); i != named_selection->playlists.end(); ++i) {
- add_playlist (*i);
- }
-
set_dirty();
NamedSelectionAdded (); /* EMIT SIGNAL */
}
void
-Session::remove_named_selection (NamedSelection* named_selection)
+Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
{
bool removed = false;
NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
if (i != named_selections.end()) {
- delete (*i);
named_selections.erase (i);
set_dirty();
removed = true;
return false;
}
-uint32_t
-Session::n_playlists () const
-{
- Glib::Mutex::Lock lm (playlist_lock);
- return playlists.size();
-}
-
void
Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
{
}
boost::shared_ptr<Region>
-Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
- bool overwrite, vector<boost::shared_ptr<Source> >& srcs,
+Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
+ bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
InterThreadInfo& itt, bool enable_processing)
{
boost::shared_ptr<Region> result;
return result;
}
- // any bigger than this seems to cause stack overflows in called functions
- const nframes_t chunk_size = (128 * 1024)/4;
+ const nframes_t chunk_size = (256 * 1024)/4;
// block all process callback handling
try {
fsource = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, buf, true, false, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
}
catch (failed_constructor& err) {
/* construct a region to represent the bounced material */
- result = RegionFactory::create (srcs, 0,
- srcs.front()->length(srcs.front()->timeline_position()),
- region_name_from_path (srcs.front()->name(), true));
+ PropertyList plist;
+
+ plist.add (Properties::start, 0);
+ plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
+ plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
+
+ result = RegionFactory::create (srcs, plist);
+
}
out:
if (afs) {
afs->mark_for_remove ();
}
-
+
(*src)->drop_references ();
}
}
void
-Session::sync_order_keys (const char* base)
+Session::sync_order_keys (std::string const & base)
{
+ if (deletion_in_progress()) {
+ return;
+ }
+
if (!Config->get_sync_all_route_ordering()) {
/* leave order keys as they are */
return;
}
Route::SyncOrderKeys (base); // EMIT SIGNAL
-}
+ /* this might not do anything */
+
+ set_remote_control_ids ();
+}
/** @return true if there is at least one record-enabled diskstream, otherwise false */
bool
RecordStateChanged (); /* EMIT SIGNAL */
}
}
+
+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_control_outs_at (p);
+ }
+}
+
+void
+Session::solo_control_mode_changed ()
+{
+ /* cancel all solo or all listen when solo control mode changes */
+
+ if (Config->get_solo_control_is_listen_control()) {
+ set_solo (routes.reader(), false);
+ } else {
+ set_listen (routes.reader(), false);
+ }
+}
+
+void
+Session::route_group_changed ()
+{
+ RouteGroupChanged (); /* EMIT SIGNAL */
+}
+
+vector<SyncSource>
+Session::get_available_sync_options () const
+{
+ vector<SyncSource> ret;
+
+ ret.push_back (JACK);
+
+ if (mtc_port()) {
+ ret.push_back (MTC);
+ }
+
+ if (midi_clock_port()) {
+ ret.push_back (MIDIClock);
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<RouteList>
+Session::get_routes_with_regions_at (nframes64_t const p) const
+{
+ shared_ptr<RouteList> r = routes.reader ();
+ shared_ptr<RouteList> rl (new RouteList);
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (!tr) {
+ continue;
+ }
+
+ boost::shared_ptr<Diskstream> ds = tr->diskstream ();
+ if (!ds) {
+ continue;
+ }
+
+ boost::shared_ptr<Playlist> pl = ds->playlist ();
+ if (!pl) {
+ continue;
+ }
+
+ if (pl->has_region_at (p)) {
+ rl->push_back (*i);
+ }
+ }
+
+ return rl;
+}
projects / ardour.git / blobdiff