#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
-#include <pbd/error.h>
+#include "pbd/error.h"
#include <glibmm/thread.h>
-#include <pbd/pathscanner.h>
-#include <pbd/stl_delete.h>
-#include <pbd/basename.h>
-#include <pbd/stacktrace.h>
-#include <pbd/file_utils.h>
-
-#include <ardour/audioengine.h>
-#include <ardour/configuration.h>
-#include <ardour/session.h>
-#include <ardour/session_directory.h>
-#include <ardour/session_metadata.h>
-#include <ardour/utils.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/audioregion.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/midi_diskstream.h>
-#include <ardour/midi_playlist.h>
-#include <ardour/midi_region.h>
-#include <ardour/smf_source.h>
-#include <ardour/auditioner.h>
-#include <ardour/recent_sessions.h>
-#include <ardour/io_processor.h>
-#include <ardour/send.h>
-#include <ardour/processor.h>
-#include <ardour/plugin_insert.h>
-#include <ardour/port_insert.h>
-#include <ardour/slave.h>
-#include <ardour/tempo.h>
-#include <ardour/audio_track.h>
-#include <ardour/midi_track.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/named_selection.h>
-#include <ardour/crossfade.h>
-#include <ardour/playlist.h>
-#include <ardour/internal_send.h>
-#include <ardour/click.h>
-#include <ardour/data_type.h>
-#include <ardour/buffer_set.h>
-#include <ardour/source_factory.h>
-#include <ardour/region_factory.h>
-#include <ardour/filename_extensions.h>
-#include <ardour/session_directory.h>
-#include <ardour/tape_file_matcher.h>
-#include <ardour/analyser.h>
-#include <ardour/audio_buffer.h>
-#include <ardour/bundle.h>
+#include "pbd/pathscanner.h"
+#include "pbd/stl_delete.h"
+#include "pbd/basename.h"
+#include "pbd/stacktrace.h"
+#include "pbd/file_utils.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/audioplaylist.h"
+#include "ardour/audioregion.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/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/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/route_group.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_metadata.h"
+#include "ardour/slave.h"
+#include "ardour/smf_source.h"
+#include "ardour/source_factory.h"
+#include "ardour/tape_file_matcher.h"
+#include "ardour/tempo.h"
+#include "ardour/utils.h"
#include "i18n.h"
using namespace PBD;
using boost::shared_ptr;
-#ifdef __x86_64__
-static const int CPU_CACHE_ALIGN = 64;
-#else
-static const int CPU_CACHE_ALIGN = 16; /* arguably 32 on most arches, but it matters less */
-#endif
-
bool Session::_disable_all_loaded_plugins = false;
sigc::signal<void,std::string> Session::Dialog;
sigc::signal<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
sigc::signal<void> Session::SendFeedback;
-sigc::signal<void> Session::SMPTEOffsetChanged;
+sigc::signal<void> Session::TimecodeOffsetChanged;
sigc::signal<void> Session::StartTimeChanged;
sigc::signal<void> Session::EndTimeChanged;
sigc::signal<void> Session::AutoBindingOn;
string mix_template)
: _engine (eng),
+ _target_transport_speed (0.0),
+ _requested_return_frame (-1),
_scratch_buffers(new BufferSet()),
_silent_buffers(new BufferSet()),
_mix_buffers(new BufferSet()),
_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),
+ _butler (new Butler (this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
midi_thread (pthread_t (0)),
midi_requests (128), // the size of this should match the midi request pool size
diskstreams (new DiskstreamList),
routes (new RouteList),
- auditioner ((Auditioner*) 0),
_total_free_4k_blocks (0),
_bundles (new BundleList),
_bundle_xml_node (0),
click_data (0),
click_emphasis_data (0),
main_outs (0),
- _metadata (new SessionMetadata())
+ _metadata (new SessionMetadata()),
+ _have_rec_enabled_diskstream (false)
{
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 (mem_fun (*this, &Session::config_changed));
+ Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
+ config.ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), true));
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
nframes_t initial_length)
: _engine (eng),
+ _target_transport_speed (0.0),
+ _requested_return_frame (-1),
_scratch_buffers(new BufferSet()),
_silent_buffers(new BufferSet()),
_mix_buffers(new BufferSet()),
_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),
+ _butler (new Butler (this)),
+ _post_transport_work (0),
+ _send_timecode_update (false),
midi_thread (pthread_t (0)),
midi_requests (16),
diskstreams (new DiskstreamList),
routes (new RouteList),
- auditioner ((Auditioner *) 0),
_total_free_4k_blocks (0),
_bundles (new BundleList),
_bundle_xml_node (0),
click_data (0),
click_emphasis_data (0),
main_outs (0),
- _metadata (new SessionMetadata())
+ _metadata (new SessionMetadata()),
+ _have_rec_enabled_diskstream (false)
{
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) {
- shared_ptr<Route> r (new Route (*this, _("monitor"), -1, control_out_channels, -1, control_out_channels, Route::ControlOut));
- r->set_remote_control_id (control_id++);
-
- rl.push_back (r);
- }
-
if (master_out_channels) {
- shared_ptr<Route> r (new Route (*this, _("master"), -1, master_out_channels, -1, master_out_channels, Route::MasterOut));
+ ChanCount count(DataType::AUDIO, master_out_channels);
+ shared_ptr<Route> r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO));
+ 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);
+ shared_ptr<Route> r (new Route (*this, _("monitor"), Route::ControlOut, DataType::AUDIO));
+ 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 (mem_fun (*this, &Session::config_changed));
+ Config->ParameterChanged.connect (bind (mem_fun (*this, &Session::config_changed), false));
}
Session::~Session ()
delete state_tree;
- terminate_butler_thread ();
+ /* reset dynamic state version back to default */
+
+ Stateful::loading_state_version = 0;
+
+ _butler->terminate_thread ();
//terminate_midi_thread ();
if (click_data != default_click) {
}
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;
-
- tmp = i;
- ++tmp;
-
- delete *i;
-
- i = tmp;
- }
#ifdef TRACK_DESTRUCTION
- cerr << "delete edit groups\n";
+ cerr << "delete route groups\n";
#endif /* TRACK_DESTRUCTION */
- for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
- list<RouteGroup*>::iterator tmp;
-
- tmp = i;
- ++tmp;
-
+ 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;
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());
}
}
{
string first_physical_output;
- /* we don't want to run execute this again */
-
BootMessage (_("Set block size and sample rate"));
set_block_size (_engine.frames_per_cycle());
BootMessage (_("Using configuration"));
- Config->map_parameters (mem_fun (*this, &Session::config_changed));
+ Config->map_parameters (bind (mem_fun (*this, &Session::config_changed), false));
/* every time we reconnect, recompute worst case output latencies */
_engine.transport_stop ();
}
- if (Config->get_jack_time_master()) {
+ if (config.get_jack_time_master()) {
_engine.transport_locate (_transport_frame);
}
try {
XMLNode* child = 0;
- _click_io.reset (new ClickIO (*this, "click", 0, 0, -1, -1));
+ _click_io.reset (new ClickIO (*this, "click"));
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 */
+ /* default state for Click: dual-mono to first 2 physical outputs */
- first_physical_output = _engine.get_nth_physical_output (DataType::AUDIO, 0);
+ for (int physport = 0; physport < 2; ++physport) {
+ string physical_output = _engine.get_nth_physical_output (DataType::AUDIO, physport);
- if (first_physical_output.length()) {
- if (_click_io->add_output_port (first_physical_output, this)) {
- // relax, even though its an error
- } else {
- _clicking = Config->get_clicking ();
- }
- }
+ if (physical_output.length()) {
+ if (_click_io->add_port (physical_output, this)) {
+ // relax, even though its an error
+ }
+ }
+ }
+
+ if (_click_io->n_ports () > ChanCount::ZERO) {
+ _clicking = Config->get_clicking ();
+ }
}
}
BootMessage (_("Set up standard connections"));
/* Create a set of Bundle objects that map
- to the physical I/O currently available */
+ to the physical I/O currently available. We create both
+ 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
+ */
+
+ /* 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);
+ }
+
+ /* stereo output bundles */
+
+ for (uint32_t np = 0; np < n_physical_outputs; np += 2) {
+ if (np + 1 < n_physical_outputs) {
+ char buf[32];
+ snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
+ shared_ptr<Bundle> c (new Bundle (buf, true));
+ c->add_channel (_("L"));
+ c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+ c->add_channel (_("R"));
+ c->set_port (1, _engine.get_nth_physical_output (DataType::AUDIO, np + 1));
- add_bundle (c);
+ add_bundle (c);
+ }
}
+ /* 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);
}
- if (_master_out) {
+ /* stereo input bundles */
- /* create master/control ports */
+ for (uint32_t np = 0; np < n_physical_inputs; np += 2) {
+ if (np + 1 < n_physical_inputs) {
+ char buf[32];
+ snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
- if (_master_out) {
- uint32_t n;
+ shared_ptr<Bundle> c (new Bundle (buf, false));
+ c->add_channel (_("L"));
+ c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ c->add_channel (_("R"));
+ c->set_port (1, _engine.get_nth_physical_input (DataType::AUDIO, np + 1));
- /* force the master to ignore any later call to this */
+ add_bundle (c);
+ }
+ }
- if (_master_out->pending_state_node) {
- _master_out->ports_became_legal();
- }
+ BootMessage (_("Setup signal flow and plugins"));
- /* no panner resets till we are through */
+ hookup_io ();
- _master_out->defer_pan_reset ();
+ if (!no_auto_connect()) {
- while (_master_out->n_inputs().n_audio()
- < _master_out->input_maximum().n_audio()) {
- if (_master_out->add_input_port ("", this, DataType::AUDIO)) {
- error << _("cannot setup master inputs")
- << endmsg;
- break;
+ if (_master_out && Config->get_auto_connect_standard_busses()) {
+
+ /* if requested auto-connect the outputs to the first N physical ports.
+ */
+
+ uint32_t limit = _master_out->n_outputs().n_total();
+
+ for (uint32_t n = 0; n < limit; ++n) {
+ Port* p = _master_out->output()->nth (n);
+ string connect_to = _engine.get_nth_physical_output (DataType (p->type()), n);
+
+ 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;
+ }
}
}
- n = 0;
- while (_master_out->n_outputs().n_audio()
- < _master_out->output_maximum().n_audio()) {
- if (_master_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this, DataType::AUDIO)) {
- error << _("cannot setup master outputs")
- << endmsg;
- break;
+ }
+
+ if (_control_out) {
+
+ /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
+ are undefined, at best.
+ */
+
+ /* control out listens to master bus (but ignores it
+ under some conditions)
+ */
+
+ uint32_t limit = _control_out->n_inputs().n_audio();
+
+ 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 (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;
+ }
+ }
}
- n++;
}
- _master_out->allow_pan_reset ();
+ /* 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>())) {
- BootMessage (_("Setup signal flow and plugins"));
+ if (!Config->get_monitor_bus_preferred_bundle().empty()) {
- hookup_io ();
+ boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
- /* catch up on send+insert cnts */
+ 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;
+ }
- BootMessage (_("Catch up with send/insert state"));
+ } else {
- insert_cnt = 0;
+ /* XXX this logic is wrong for mixed port types */
- for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
- uint32_t id;
+ uint32_t shift = _master_out->n_outputs().n_audio();
+ uint32_t mod = _engine.n_physical_outputs (DataType::AUDIO);
+ limit = _control_out->n_outputs().n_audio();
- if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
- if (id > insert_cnt) {
- insert_cnt = id;
- }
- }
- }
+ cerr << "Connecting " << limit << " control out ports, shift is " << shift << " mod is " << mod << endl;
- send_cnt = 0;
+ for (uint32_t n = 0; n < limit; ++n) {
- for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
- uint32_t id;
+ Port* p = _control_out->output()->nth (n);
+ string connect_to = _engine.get_nth_physical_output (DataType (p->type()), (n+shift) % mod);
- if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
- if (id > send_cnt) {
- send_cnt = id;
+ 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));
_state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
- if (auditioner == 0) {
+ if (!auditioner) {
/* we delay creating the auditioner till now because
it makes its own connections to ports.
}
}
- /* Tell all IO objects to create their ports */
-
- IO::enable_ports ();
-
- if (_control_out) {
- uint32_t n;
- vector<string> cports;
-
- while (_control_out->n_inputs().n_audio() < _control_out->input_maximum().n_audio()) {
- if (_control_out->add_input_port ("", this)) {
- error << _("cannot setup control inputs")
- << endmsg;
- break;
- }
- }
- n = 0;
- while (_control_out->n_outputs().n_audio() < _control_out->output_maximum().n_audio()) {
- if (_control_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this)) {
- error << _("cannot set up master outputs")
- << endmsg;
- break;
- }
- n++;
- }
-
-
- uint32_t ni = _control_out->n_inputs().get (DataType::AUDIO);
-
- for (n = 0; n < ni; ++n) {
- cports.push_back (_control_out->input(n)->name());
- }
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
- (*x)->set_control_outs (cports);
- }
- }
-
/* load bundles, which we may have postponed earlier on */
if (_bundle_xml_node) {
load_bundles (*_bundle_xml_node);
/* 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) {
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;
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !Config->get_auto_input());
+ (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
}
}
} else {
{
replace_event (Event::PunchIn, location->start());
- if (get_record_enabled() && Config->get_punch_in()) {
+ if (get_record_enabled() && config.get_punch_in()) {
/* capture start has been changed, so save new pending state */
save_state ("", true);
}
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);
auto_loop_end_changed_connection.disconnect();
auto_loop_changed_connection.disconnect();
- 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));
+ 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->set_auto_loop (true, this);
}
void
-Session::locations_added (Location* ignored)
+Session::locations_added (Location *)
{
set_dirty ();
}
_last_record_location = _transport_frame;
deliver_mmc(MIDI::MachineControl::cmdRecordStrobe, _last_record_location);
- if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
if (rt_context)
deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
- if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (g_atomic_int_get (&_record_status) == Recording) {
g_atomic_int_set (&_record_status, Enabled);
- if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
save_state ("", true);
if (_transport_speed) {
- if (!Config->get_punch_in()) {
+ if (!config.get_punch_in()) {
enable_record ();
}
} else {
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;
-
- if (_transport_speed == 0.0f && non_realtime_work_pending()) {
- return last_stop_frame;
- }
/* 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()) {
/* MOVING */
/* check to see if we have passed the first guaranteed
- audible frame past our last stopping position. if not,
- the return that last stopping point because in terms
+ audible frame past our last start position. if not,
+ return that last start point because in terms
of audible frames, we have not moved yet.
*/
if (_transport_speed > 0.0f) {
if (!play_loop || !have_looped) {
- if (tf < last_stop_frame + offset) {
- return last_stop_frame;
-
+ if (tf < _last_roll_location + offset) {
+ return _last_roll_location;
}
- }
-
+ }
+
/* forwards */
ret -= offset;
/* XXX wot? no backward looping? */
- if (tf > last_stop_frame - offset) {
- return last_stop_frame;
+ if (tf > _last_roll_location - offset) {
+ return _last_roll_location;
} else {
/* backwards */
ret += offset;
*/
{
-
current_block_size = nframes;
ensure_buffers(_scratch_buffers->available());
}
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;
}
list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (TrackMode mode, uint32_t how_many)
+Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
char track_name[32];
uint32_t track_id = 0;
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (dynamic_cast<MidiTrack*>((*i).get()) != 0) {
+ if (boost::dynamic_pointer_cast<MidiTrack>(*i) != 0) {
if (!(*i)->is_hidden()) {
n++;
//channels_used += (*i)->n_inputs().n_midi();
try {
track = boost::shared_ptr<MidiTrack>((new MidiTrack (*this, track_name, Route::Flag (0), mode)));
- 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 (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;
}
*/
track->midi_diskstream()->non_realtime_input_change();
+ track->set_route_group (route_group, 0);
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
//track->set_remote_control_id (control_id);
}
list<boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
+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 = 0;
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
+ if (boost::dynamic_pointer_cast<AudioTrack>(*i) != 0) {
if (!(*i)->is_hidden()) {
n++;
channels_used += (*i)->n_inputs().n_audio();
try {
track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
- if (track->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
+ 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 (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;
port = physinputs[(channels_used+x)%nphysical_in];
}
- if (port.length() && track->connect_input (track->input (x), port, this)) {
+ if (port.length() && track->input()->connect (track->input()->nth(x), port, this)) {
break;
}
}
uint32_t nphysical_out = physoutputs.size();
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) {
- port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
+ if (_master_out && _master_out->n_inputs().n_audio() > 0) {
+ port = _master_out->input()->nth (x % _master_out->input()->n_ports().n_audio())->name();
}
}
-
- if (port.length() && track->connect_output (track->output (x), port, this)) {
+
+ if (port.length() && track->output()->connect (track->output()->nth(x), port, this)) {
break;
}
}
channels_used += track->n_inputs ().n_audio();
+ track->set_route_group (route_group, 0);
+
track->audio_diskstream()->non_realtime_input_change();
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
catch (AudioEngine::PortRegistrationFailure& pfe) {
- error << _("No more JACK ports are available. You will need to stop Ardour and restart JACK with ports if you need this many tracks.") << endmsg;
+ error << pfe.what() << endmsg;
if (track) {
/* we need to get rid of this, since the track failed to be created */
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;
} while (bus_id < (UINT_MAX-1));
try {
- shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
+ shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
- 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;
}
+ 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_inputs && x < bus->n_inputs(); ++x) {
-
+ for (uint32_t x = 0; n_physical_audio_inputs && x < bus->input()->n_ports().n_audio(); ++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)) {
+ }
+
+ if (port.length() && bus->input()->connect (bus->input()->nth (x), port, this)) {
break;
}
}
- */
for (uint32_t x = 0; n_physical_audio_outputs && x < bus->n_outputs().n_audio(); ++x) {
port = "";
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();
+ port = _master_out->input()->nth (x%_master_out->input()->n_ports().n_audio())->name();
}
}
- if (port.length() && bus->connect_output (bus->output (x), port, this)) {
+ if (port.length() && bus->output()->connect (bus->output()->nth(x), port, this)) {
break;
}
}
channels_used += bus->n_inputs ().n_audio();
+ bus->set_route_group (route_group, 0);
bus->set_remote_control_id (control_id);
++control_id;
+ if (aux) {
+ bus->add_internal_return ();
+ }
+
ret.push_back (bus);
}
}
catch (AudioEngine::PortRegistrationFailure& pfe) {
- error << _("No more JACK ports are available. You will need to stop Ardour and restart JACK with ports if you need this many tracks.") << endmsg;
+ error << pfe.what() << endmsg;
goto failure;
}
}
+RouteList
+Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
+{
+ char name[32];
+ RouteList ret;
+ uint32_t control_id;
+ XMLTree tree;
+ uint32_t number = 1;
+
+ if (!tree.read (template_path.c_str())) {
+ return ret;
+ }
+
+ XMLNode* node = tree.root();
+
+ control_id = ntracks() + nbusses() + 1;
+
+ 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());
+
+ /* generate a new name by adding a number to the end of the template name */
+
+ 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*/
+ }
+
+ 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, 3000));
+
+ if (route == 0) {
+ error << _("Session: cannot create track/bus from template description") << endmsg;
+ goto out;
+ }
+
+ if (boost::dynamic_pointer_cast<Track>(route)) {
+ /* force input/output change signals so that the new diskstream
+ 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->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;
+ }
+
+ out:
+ if (!ret.empty()) {
+ add_routes (ret, true);
+ }
+
+ return ret;
+}
+
void
Session::add_routes (RouteList& new_routes, bool save)
{
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);
+ (*x)->listen_changed.connect (sigc::bind (mem_fun (*this, &Session::route_listen_changed), wpr));
(*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)->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));
+ (*x)->route_group_changed.connect (hide (mem_fun (*this, &Session::route_group_changed)));
if ((*x)->is_master()) {
_master_out = (*x);
if (_control_out && IO::connecting_legal) {
- vector<string> cports;
- uint32_t ni = _control_out->n_inputs().n_audio();
-
- for (uint32_t n = 0; n < ni; ++n) {
- cports.push_back (_control_out->input(n)->name());
- }
-
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- (*x)->set_control_outs (cports);
+ 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();
}
void
-Session::add_diskstream (boost::shared_ptr<Diskstream> dstream)
+Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
{
- /* need to do this in case we're rolling at the time, to prevent false underruns */
+ 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
+Session::add_diskstream (boost::shared_ptr<Diskstream> dstream)
+{
+ /* need to do this in case we're rolling at the time, to prevent false underruns */
dstream->do_refill_with_alloc ();
dstream->set_block_size (current_block_size);
/* 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 (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), 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->prepare ();
}
if (route == _control_out) {
- _control_out = shared_ptr<Route> ();
/* cancel control outs for all routes */
- vector<string> empty;
-
for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
- (*r)->set_control_outs (empty);
+ (*r)->drop_listen (_control_out);
}
+
+ _control_out.reset ();
}
update_route_solo_state ();
/* writer goes out of scope, forces route list update */
}
- Track* t;
+ boost::shared_ptr<Track> t;
boost::shared_ptr<Diskstream> ds;
- if ((t = dynamic_cast<Track*>(route.get())) != 0) {
+ if ((t = boost::dynamic_pointer_cast<Track>(route)) != 0) {
ds = t->diskstream();
}
// 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);
update_latency_compensation (false, false);
set_dirty();
}
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)
+{
+ boost::shared_ptr<Route> route = wpr.lock();
+ if (!route) {
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ return;
+ }
+
+ if (route->listening()) {
+ _listen_cnt++;
+ } else if (_listen_cnt > 0) {
+ _listen_cnt--;
+ }
+}
+
+void
+Session::route_solo_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 ();
if (!route) {
return;
}
- is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
-
shared_ptr<RouteList> r = routes.reader ();
+ int32_t delta;
- 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 (dynamic_cast<Track*>((*i).get()) == 0) {
- continue;
- }
-
- } else {
-
- /* don't mess with tracks */
-
- if (dynamic_cast<Track*>((*i).get()) != 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 (route->self_soloed()) {
+ delta = 1;
+ } else {
+ delta = -1;
+ }
- if (Config->get_solo_latched()) {
- continue;
- }
- }
+ /* now mod the solo level of all other routes except master & control outs
+ so that they will be silent if appropriate.
+ */
- /* do it */
+ solo_update_disabled = true;
- solo_update_disabled = true;
- (*i)->set_solo (false, src);
- solo_update_disabled = false;
- }
- }
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ bool via_sends_only;
- 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 (dynamic_cast<Track*>((*i).get())) {
- if (is_track) {
- same_thing_soloed = true;
- break;
- }
- } else {
- if (!is_track) {
- same_thing_soloed = true;
- break;
- }
+ 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);
}
- break;
- }
+ }
}
- if (something_soloed != currently_soloing) {
- signal = true;
- currently_soloing = something_soloed;
- }
+ /* make sure master is never muted by solo */
- modify_solo_mute (is_track, same_thing_soloed);
+ 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 (signal) {
- SoloActive (currently_soloing); /* EMIT SIGNAL */
+ 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::update_route_solo_state ()
+Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
{
- bool mute = false;
- bool is_track = false;
- bool signal = false;
+ /* now figure out if anything that matters is soloed */
- /* this is where we actually implement solo by changing
- the solo mute setting of each track.
- */
+ bool something_soloed = false;
- shared_ptr<RouteList> r = routes.reader ();
+ if (!r) {
+ r = routes.reader();
+ }
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ((*i)->soloed()) {
- mute = true;
- if (dynamic_cast<Track*>((*i).get())) {
- is_track = true;
- }
+ if (!(*i)->is_master() && !(*i)->is_control() && !(*i)->is_hidden() && (*i)->self_soloed()) {
+ something_soloed = 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);
- }
-
- return;
- }
-
- modify_solo_mute (is_track, mute);
-
- if (signal) {
- SoloActive (currently_soloing);
+ if (something_soloed != _non_soloed_outs_muted) {
+ _non_soloed_outs_muted = something_soloed;
+ SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
}
}
-void
-Session::modify_solo_mute (bool is_track, bool mute)
+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) {
-
- if (is_track) {
-
- /* only alter track solo mute */
-
- if (dynamic_cast<Track*>((*i).get())) {
- if ((*i)->soloed()) {
- (*i)->set_solo_mute (!mute);
- } else {
- (*i)->set_solo_mute (mute);
- }
- }
-
- } else {
-
- /* only alter bus solo mute */
-
- if (!dynamic_cast<Track*>((*i).get())) {
-
- if ((*i)->soloed()) {
-
- (*i)->set_solo_mute (false);
-
- } else {
-
- /* don't mute master or control outs
- in response to another bus solo
- */
-
- if ((*i) != _master_out &&
- (*i) != _control_out) {
- (*i)->set_solo_mute (mute);
- }
- }
- }
-
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if ((*i)->internal_return ()) {
+ rl->push_back (*i);
}
}
+ return rl;
}
-
-void
-Session::catch_up_on_solo ()
-{
- /* 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();
-}
-
-void
-Session::catch_up_on_solo_mute_override ()
-{
- if (Config->get_solo_model() != InverseMute) {
- return;
- }
-
- /* this is called whenever the param solo-mute-override is
- changed.
- */
- shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->catch_up_on_solo_mute_override ();
- }
-}
-
shared_ptr<Route>
Session::route_by_name (string name)
{
char buf[16];
string subbase;
- assert(base.find("/") == string::npos);
+ if (base.find("/") != string::npos) {
+ base = base.substr(base.find_last_of("/") + 1);
+ }
if (base == "") {
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);
}
}
}
/* Source Management */
+
void
Session::add_source (boost::shared_ptr<Source> source)
{
}
}
+/** Return the number of playlists (not regions) that contain @a src */
+uint32_t
+Session::source_use_count (boost::shared_ptr<const Source> src) const
+{
+ uint32_t count = 0;
+ for (PlaylistList::const_iterator p = playlists.begin(); p != playlists.end(); ++p) {
+ for (Playlist::RegionList::const_iterator r = (*p)->region_list().begin();
+ r != (*p)->region_list().end(); ++r) {
+ if ((*r)->uses_source(src)) {
+ ++count;
+ break;
+ }
+ }
+ }
+ return count;
+}
+
boost::shared_ptr<Source>
Session::source_by_id (const PBD::ID& id)
{
return source;
}
-
boost::shared_ptr<Source>
Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
{
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
cerr << "comparing " << path << " with " << i->second->name() << endl;
- boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
+ boost::shared_ptr<AudioFileSource> afs
+ = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
if (afs && afs->path() == path && chn == afs->channel()) {
return afs;
}
-
}
return boost::shared_ptr<Source>();
}
-Glib::ustring
-Session::peak_path (Glib::ustring base) const
-{
- sys::path peakfile_path(_session_dir->peak_path());
- peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
- return peakfile_path.to_string();
-}
string
-Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
+Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
{
string look_for;
string old_basename = PBD::basename_nosuffix (oldname);
/* non-destructive file sources have a name of the form:
- /path/to/NAME-nnnnn(%[LR])?.wav
+ /path/to/NAME-nnnnn(%[LR])?.ext
the task here is to replace NAME with the new name.
*/
if (postfix != string::npos) {
suffix = suffix.substr (postfix);
} else {
- error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
+ error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
return "";
}
return path;
}
+/** Return the full path (in some session directory) for a new embedded source.
+ * \a name must be a session-unique name that does not contain slashes
+ * (e.g. as returned by new_*_source_name)
+ */
+string
+Session::new_source_path_from_name (DataType type, const string& name)
+{
+ assert(name.find("/") == string::npos);
+
+ SessionDirectory sdir(get_best_session_directory_for_new_source());
+
+ sys::path p;
+ if (type == DataType::AUDIO) {
+ p = sdir.sound_path();
+ } else if (type == DataType::MIDI) {
+ p = sdir.midi_path();
+ } else {
+ error << "Unknown source type, unable to create file path" << endmsg;
+ return "";
+ }
+
+ p /= name;
+ return p.to_string();
+}
+
+Glib::ustring
+Session::peak_path (Glib::ustring base) const
+{
+ sys::path peakfile_path(_session_dir->peak_path());
+ peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
+ return peakfile_path.to_string();
+}
+
+/** Return a unique name based on \a base for a new internal audio source */
string
-Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
+Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
{
string spath;
uint32_t cnt;
string legalized;
buf[0] = '\0';
- legalized = legalize_for_path (name);
-
- /* find a "version" of the file name that doesn't exist in
- any of the possible directories.
- */
+ legalized = legalize_for_path (base);
+ // Find a "version" of the base name that doesn't exist in any of the possible directories.
for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
vector<space_and_path>::iterator i;
spath = sdir.sound_path().to_string();
if (destructive) {
+
if (nchan < 2) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
+ spath.c_str(), cnt, legalized.c_str());
} else if (nchan == 2) {
if (chan == 0) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav",
+ spath.c_str(), cnt, legalized.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav",
+ spath.c_str(), cnt, legalized.c_str());
}
} else if (nchan < 26) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav",
+ spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
+ spath.c_str(), cnt, legalized.c_str());
}
} else {
}
if (cnt > limit) {
- error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
+ error << string_compose(
+ _("There are already %1 recordings for %2, which I consider too many."),
+ limit, base) << endmsg;
destroy ();
throw failed_constructor();
}
}
- /* we now have a unique name for the file, but figure out where to
- actually put it.
- */
-
- string foo = buf;
-
- SessionDirectory sdir(get_best_session_directory_for_new_source ());
-
- spath = sdir.sound_path().to_string();
- spath += '/';
-
- string::size_type pos = foo.find_last_of ('/');
-
- if (pos == string::npos) {
- spath += foo;
- } else {
- spath += foo.substr (pos + 1);
- }
-
- return spath;
+ return Glib::path_get_basename(buf);
}
+/** Create a new embedded audio source */
boost::shared_ptr<AudioFileSource>
Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
{
- string spath = audio_path_from_name (ds.name(), ds.n_channels().n_audio(), chan, 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, spath, destructive, frame_rate()));
-}
-
-// FIXME: _terrible_ code duplication
-string
-Session::change_midi_path_by_name (string path, string oldname, string newname, bool destructive)
-{
- string look_for;
- string old_basename = PBD::basename_nosuffix (oldname);
- string new_legalized = legalize_for_path (newname);
-
- /* note: we know (or assume) the old path is already valid */
-
- if (destructive) {
-
- /* destructive file sources have a name of the form:
-
- /path/to/Tnnnn-NAME(%[LR])?.wav
-
- the task here is to replace NAME with the new name.
- */
-
- /* find last slash */
-
- string dir;
- string prefix;
- string::size_type slash;
- string::size_type dash;
-
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
-
- /* '-' is not a legal character for the NAME part of the path */
-
- if ((dash = path.find_last_of ('-')) == string::npos) {
- return "";
- }
-
- prefix = path.substr (slash+1, dash-(slash+1));
-
- path = dir;
- path += prefix;
- path += '-';
- path += new_legalized;
- path += ".mid"; /* XXX gag me with a spoon */
-
- } else {
-
- /* non-destructive file sources have a name of the form:
-
- /path/to/NAME-nnnnn(%[LR])?.wav
-
- the task here is to replace NAME with the new name.
- */
-
- string dir;
- string suffix;
- string::size_type slash;
- string::size_type dash;
- string::size_type postfix;
-
- /* find last slash */
-
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
-
- /* '-' is not a legal character for the NAME part of the path */
-
- if ((dash = path.find_last_of ('-')) == string::npos) {
- return "";
- }
-
- suffix = path.substr (dash+1);
-
- // Suffix is now everything after the dash. Now we need to eliminate
- // the nnnnn part, which is done by either finding a '%' or a '.'
-
- postfix = suffix.find_last_of ("%");
- if (postfix == string::npos) {
- postfix = suffix.find_last_of ('.');
- }
-
- if (postfix != string::npos) {
- suffix = suffix.substr (postfix);
- } else {
- error << "Logic error in Session::change_midi_path_by_name(), please report to the developers" << endl;
- return "";
- }
-
- const uint32_t limit = 10000;
- char buf[PATH_MAX+1];
-
- for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
-
- snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
-
- if (access (buf, F_OK) != 0) {
- path = buf;
- break;
- }
- path = "";
- }
-
- if (path == "") {
- error << "FATAL ERROR! Could not find a " << endl;
- }
-
- }
-
- return path;
+ SourceFactory::createWritable (
+ DataType::AUDIO, *this, path, true, destructive, frame_rate()));
}
+/** Return a unique name based on \a base for a new internal MIDI source */
string
-Session::midi_path_from_name (string name)
+Session::new_midi_source_name (const string& base)
{
- string spath;
uint32_t cnt;
char buf[PATH_MAX+1];
const uint32_t limit = 10000;
string legalized;
buf[0] = '\0';
- legalized = legalize_for_path (name);
-
- /* find a "version" of the file name that doesn't exist in
- any of the possible directories.
- */
+ legalized = legalize_for_path (base);
+ // Find a "version" of the file name that doesn't exist in any of the possible directories.
for (cnt = 1; cnt <= limit; ++cnt) {
vector<space_and_path>::iterator i;
SessionDirectory sdir((*i).path);
sys::path p = sdir.midi_path();
-
p /= legalized;
- spath = p.to_string();
-
- snprintf (buf, sizeof(buf), "%s-%u.mid", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
if (sys::exists (buf)) {
existing++;
}
if (cnt > limit) {
- error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
+ error << string_compose(
+ _("There are already %1 recordings for %2, which I consider too many."),
+ limit, base) << endmsg;
+ destroy ();
throw failed_constructor();
}
}
- /* we now have a unique name for the file, but figure out where to
- actually put it.
- */
-
- string foo = buf;
-
- SessionDirectory sdir(get_best_session_directory_for_new_source ());
-
- spath = sdir.midi_path().to_string();
- spath += '/';
-
- string::size_type pos = foo.find_last_of ('/');
-
- if (pos == string::npos) {
- spath += foo;
- } else {
- spath += foo.substr (pos + 1);
- }
-
- return spath;
+ return Glib::path_get_basename(buf);
}
+
+/** Create a new embedded MIDI source */
boost::shared_ptr<MidiSource>
Session::create_midi_source_for_session (MidiDiskstream& ds)
{
- string mpath = midi_path_from_name (ds.name());
+ const string name = new_midi_source_name (ds.name());
+ const string path = new_source_path_from_name (DataType::MIDI, name);
- return boost::dynamic_pointer_cast<SMFSource> (SourceFactory::createWritable (DataType::MIDI, *this, mpath, false, frame_rate()));
+ return boost::dynamic_pointer_cast<SMFSource> (
+ SourceFactory::createWritable (
+ DataType::MIDI, *this, path, true, false, frame_rate()));
}
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
set_dirty();
}
+void
+Session::set_all_listen (bool yn)
+{
+ shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ if (!(*i)->is_hidden()) {
+ (*i)->set_listen (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) {
- Track* at;
+ boost::shared_ptr<Track> t;
- if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
- at->set_record_enable (yn, this);
+ if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
+ t->set_record_enable (yn, this);
}
}
void
Session::add_processor (Processor* processor)
{
- Send* send;
- 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 (dynamic_cast<InternalSend *> (processor) != 0) {
- /* relax */
- } else {
- fatal << _("programming error: unknown type of Insert created!") << endmsg;
- /*NOTREACHED*/
- }
-
processor->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_processor), processor));
-
set_dirty();
}
Session::remove_processor (Processor* processor)
{
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);
- } else if (dynamic_cast<InternalSend *> (processor) != 0) {
- /* relax */
+ 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);
- }
- } else {
- fatal << _("programming error: unknown type of Insert deleted!") << endmsg;
- /*NOTREACHED*/
+ send_bitset[send->bit_slot()] = false;
+ } else if ((retrn = dynamic_cast<Return *> (processor)) != 0) {
+ return_bitset[send->bit_slot()] = false;
}
set_dirty();
{
float sample_bytes_on_disk = 4.0; // keep gcc happy
- switch (Config->get_native_file_data_format()) {
+ switch (config.get_native_file_data_format()) {
case FormatFloat:
sample_bytes_on_disk = 4.0;
break;
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 (Change)
{
clear_clicks ();
void
Session::ensure_buffers (ChanCount howmany)
{
- if (current_block_size == 0)
+ if (current_block_size == 0) {
return; // too early? (is this ok?)
+ }
- // We need at least 2 MIDI scratch buffers to mix/merge
- if (howmany.n_midi() < 2)
- howmany.set_midi(2);
-
- // FIXME: JACK needs to tell us maximum MIDI buffer size
- // Using nasty assumption (max # events == nframes) for now
- _scratch_buffers->ensure_buffers(howmany, current_block_size);
- _mix_buffers->ensure_buffers(howmany, current_block_size);
- _silent_buffers->ensure_buffers(howmany, current_block_size);
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ size_t count = std::max(_scratch_buffers->available().get(*t), howmany.get(*t));
+ _scratch_buffers->ensure_buffers (*t, count, _engine.raw_buffer_size(*t));
+ _mix_buffers->ensure_buffers (*t, count, _engine.raw_buffer_size(*t));
+ _silent_buffers->ensure_buffers (*t, count, _engine.raw_buffer_size(*t));
+ }
allocate_pan_automation_buffers (current_block_size, howmany.n_audio(), false);
}
+void
+Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
+{
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
+ }
+}
+
uint32_t
Session::next_insert_id ()
{
}
}
+uint32_t
+Session::next_return_id ()
+{
+ /* this doesn't really loop forever. just think about it */
+
+ while (true) {
+ for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
+ if (!return_bitset[n]) {
+ return_bitset[n] = true;
+ return n;
+
+ }
+ }
+
+ /* none available, so resize and try again */
+
+ return_bitset.resize (return_bitset.size() + 16, false);
+ }
+}
+
void
Session::mark_send_id (uint32_t id)
{
send_bitset[id] = true;
}
+void
+Session::mark_return_id (uint32_t id)
+{
+ if (id >= return_bitset.size()) {
+ return_bitset.resize (id+16, false);
+ }
+ if (return_bitset[id]) {
+ warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
+ }
+ return_bitset[id] = true;
+}
+
void
Session::mark_insert_id (uint32_t id)
{
return true;
}
+bool
+Session::route_name_internal (string n) const
+{
+ if (auditioner && auditioner->name() == n) {
+ return true;
+ }
+
+ if (_click_io && _click_io->name() == n) {
+ return true;
+ }
+
+ return false;
+}
+
uint32_t
Session::n_playlists () const
{
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- Track *at;
+ boost::shared_ptr<Track> t;
- if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
+ if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
/* XXX this is wrong because itt.progress will keep returning to zero at the start
of every track.
*/
- at->freeze (itt);
+ t->freeze (itt);
}
}
}
boost::shared_ptr<Region>
-Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
- bool overwrite, vector<boost::shared_ptr<Source> >& srcs, InterThreadInfo& itt)
+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;
boost::shared_ptr<Playlist> playlist;
// any bigger than this seems to cause stack overflows in called functions
const nframes_t chunk_size = (128 * 1024)/4;
- g_atomic_int_set (&processing_prohibited, 1);
+ // block all process callback handling
+
+ block_processing ();
/* call tree *MUST* hold route_lock */
try {
fsource = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, buf, true, false, frame_rate()));
}
catch (failed_constructor& err) {
to_do = len;
/* create a set of reasonably-sized buffers */
- buffers.ensure_buffers(nchans, chunk_size);
+ buffers.ensure_buffers(DataType::AUDIO, nchans.n_audio(), chunk_size);
buffers.set_count(nchans);
for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
this_chunk = min (to_do, chunk_size);
- if (track.export_stuff (buffers, start, this_chunk)) {
+ if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
goto out;
}
/* construct a region to represent the bounced material */
- result = RegionFactory::create (srcs, 0, srcs.front()->length(),
- region_name_from_path (srcs.front()->name(), true));
+ result = RegionFactory::create (srcs, 0,
+ srcs.front()->length(srcs.front()->timeline_position()),
+ region_name_from_path (srcs.front()->name(), true));
}
out:
if (afs) {
afs->mark_for_remove ();
}
-
+
(*src)->drop_references ();
}
}
}
- g_atomic_int_set (&processing_prohibited, 0);
+ unblock_processing ();
return result;
}
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- if (dynamic_cast<Track*> ((*i).get())) {
+ if (boost::dynamic_pointer_cast<Track> (*i)) {
++n;
}
}
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- if (dynamic_cast<Track*> ((*i).get()) == 0) {
+ if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
++n;
}
}
}
void
-Session::sync_order_keys (const char* base)
+Session::sync_order_keys (std::string const & base)
{
if (!Config->get_sync_all_route_ordering()) {
/* leave order keys as they are */
}
+/** @return true if there is at least one record-enabled diskstream, otherwise false */
+bool
+Session::have_rec_enabled_diskstream () const
+{
+ return g_atomic_int_get (&_have_rec_enabled_diskstream) == 1;
+}
+
+/** Update the state of our rec-enabled diskstreams flag */
+void
+Session::update_have_rec_enabled_diskstream ()
+{
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader ();
+ DiskstreamList::iterator i = dsl->begin ();
+ while (i != dsl->end () && (*i)->record_enabled () == false) {
+ ++i;
+ }
+
+ int const old = g_atomic_int_get (&_have_rec_enabled_diskstream);
+
+ g_atomic_int_set (&_have_rec_enabled_diskstream, i != dsl->end () ? 1 : 0);
+
+ if (g_atomic_int_get (&_have_rec_enabled_diskstream) != old) {
+ 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_all_solo (false);
+ } else {
+ set_all_listen (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;
+}
projects / ardour.git / blobdiff