/*
- Copyright (C) 1999-2004 Paul Davis
+ Copyright (C) 1999-2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <unistd.h>
#include <limits.h>
-
#include <glibmm/thread.h>
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
-#include <glibmm/thread.h>
#include "pbd/error.h"
#include "pbd/boost_debug.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/audioplaylist.h"
#include "ardour/audioregion.h"
#include "ardour/auditioner.h"
+#include "ardour/buffer_manager.h"
#include "ardour/buffer_set.h"
#include "ardour/bundle.h"
#include "ardour/butler.h"
#include "ardour/midi_track.h"
#include "ardour/midi_ui.h"
#include "ardour/named_selection.h"
+#include "ardour/process_thread.h"
#include "ardour/playlist.h"
#include "ardour/plugin_insert.h"
#include "ardour/port_insert.h"
Session::Session (AudioEngine &eng,
const string& fullpath,
const string& snapshot_name,
+ BusProfile* bus_profile,
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()),
mmc (0),
_mmc_port (default_mmc_port),
_mtc_port (default_mtc_port),
{
playlists.reset (new SessionPlaylists);
- bool new_session;
-
interpolation.add_channel_to (0, 0);
if (!eng.connected()) {
throw failed_constructor();
}
- 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);
first_stage_init (fullpath, snapshot_name);
- new_session = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
+ _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
- if (new_session) {
- if (create (new_session, mix_template, compute_initial_length())) {
+ if (_is_new) {
+ if (create (mix_template, compute_initial_length(), bus_profile)) {
destroy ();
throw failed_constructor ();
}
- }
+ }
- if (second_stage_init (new_session)) {
+ if (second_stage_init ()) {
destroy ();
throw failed_constructor ();
}
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
}
-}
-
-Session::Session (AudioEngine &eng,
- string fullpath,
- string snapshot_name,
- AutoConnectOption input_ac,
- AutoConnectOption output_ac,
- uint32_t control_out_channels,
- uint32_t master_out_channels,
- uint32_t requested_physical_in,
- uint32_t requested_physical_out,
- 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()),
- mmc (0),
- _mmc_port (default_mmc_port),
- _mtc_port (default_mtc_port),
- _midi_port (default_midi_port),
- _midi_clock_port (default_midi_clock_port),
- _session_dir ( new SessionDirectory(fullpath)),
- state_tree (0),
- _butler (new Butler (*this)),
- _post_transport_work (0),
- _send_timecode_update (false),
- diskstreams (new DiskstreamList),
- routes (new RouteList),
- _total_free_4k_blocks (0),
- _bundles (new BundleList),
- _bundle_xml_node (0),
- _click_io ((IO *) 0),
- click_data (0),
- click_emphasis_data (0),
- main_outs (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();
- }
-
- 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);
-
- if (n_physical_inputs) {
- n_physical_inputs = max (requested_physical_in, n_physical_inputs);
- }
-
- if (n_physical_outputs) {
- n_physical_outputs = max (requested_physical_out, n_physical_outputs);
- }
-
- first_stage_init (fullpath, snapshot_name);
-
- new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
-
- if (new_session) {
- if (create (new_session, string(), initial_length)) {
- destroy ();
- throw failed_constructor ();
- }
- }
-
- {
- /* set up Master Out and Control Out if necessary */
-
- RouteList rl;
- int control_id = 1;
-
- if (master_out_channels) {
- ChanCount count(DataType::AUDIO, master_out_channels);
- 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);
- } else {
- /* prohibit auto-connect to master, because there isn't one */
- 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);
-
- if (second_stage_init (new_session)) {
- destroy ();
- throw failed_constructor ();
- }
-
- store_recent_sessions (_name, _path);
-
- _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
-
- Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
+ _is_new = false;
}
Session::~Session ()
Stateful::loading_state_version = 0;
+ _butler->drop_references ();
delete _butler;
delete midi_control_ui;
clear_clicks ();
- delete _scratch_buffers;
- delete _silent_buffers;
- delete _mix_buffers;
-
/* clear out any pending dead wood from RCU managed objects */
routes.flush ();
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 ();
- }
- regions.clear ();
+ RegionFactory::delete_all_regions ();
DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
auditioner.reset ();
_master_out.reset ();
- _control_out.reset ();
+ _monitor_out.reset ();
{
RCUWriter<RouteList> writer (routes);
hookup_io ();
- if (!no_auto_connect()) {
+ if (_is_new && !no_auto_connect()) {
+
+ /* don't connect the master bus outputs if there is a monitor bus */
- if (_master_out && Config->get_auto_connect_standard_busses()) {
+ if (_master_out && Config->get_auto_connect_standard_busses() && !_monitor_out) {
/* if requested auto-connect the outputs to the first N physical ports.
*/
}
}
- if (_control_out) {
+ if (_monitor_out) {
/* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
are undefined, at best.
under some conditions)
*/
- uint32_t limit = _control_out->n_inputs().n_audio();
+ uint32_t limit = _monitor_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* p = _monitor_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)) {
+ if (_monitor_out->input()->connect (p, connect_to, this)) {
error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
<< endmsg;
break;
}
}
- /* if control out is not connected,
- connect control out to physical outs, but use ones after the master if possible
+ /* if control out is not connected, connect control out to physical outs
*/
- if (!_control_out->output()->connected_to (boost::shared_ptr<IO>())) {
+ if (!_monitor_out->output()->connected ()) {
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);
+ _monitor_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())
}
} else {
-
- /* XXX this logic is wrong for mixed port types */
-
- 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();
-
- cerr << "Connecting " << limit << " control out ports, shift is " << shift << " mod is " << mod << endl;
-
- for (uint32_t n = 0; n < limit; ++n) {
-
- Port* p = _control_out->output()->nth (n);
- string connect_to = _engine.get_nth_physical_output (DataType (p->type()), (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;
+
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ uint32_t mod = _engine.n_physical_outputs (*t);
+ uint32_t limit = _monitor_out->n_outputs().get(*t);
+
+ for (uint32_t n = 0; n < limit; ++n) {
+
+ Port* p = _monitor_out->output()->ports().port(*t, n);
+ string connect_to = _engine.get_nth_physical_output (*t, (n % mod));
+
+ if (!connect_to.empty()) {
+ if (_monitor_out->output()->connect (p, connect_to, this)) {
+ error << string_compose (
+ _("cannot connect control output %1 to %2"),
+ n, connect_to)
+ << endmsg;
+ break;
+ }
}
}
}
/* we delay creating the auditioner till now because
it makes its own connections to ports.
- the engine has to be running for this to work.
*/
try {
- auditioner.reset (new Auditioner (*this));
+ Auditioner* a = new Auditioner (*this);
+ if (a->init()) {
+ delete a;
+ throw failed_constructor();
+ }
+ a->use_new_diskstream ();
+ auditioner.reset (a);
}
catch (failed_constructor& err) {
Delivery::reset_panners ();
- /* Connect tracks to listen/solo etc. busses XXX generalize this beyond control_out */
-
- if (_control_out) {
+ /* Connect tracks to monitor/listen bus if there is one.
+ Note that in an existing session, the internal sends will
+ already exist, but we want the routes to notice that
+ they connect to the control out specifically.
+ */
+ if (_monitor_out) {
boost::shared_ptr<RouteList> r = routes.reader ();
-
- 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);
- }
- }
+ for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
+
+ if ((*x)->is_monitor()) {
+
+ /* relax */
+
+ } else if ((*x)->is_master()) {
+
+ /* relax */
+
+ } else {
+
+ (*x)->listen_via (_monitor_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
+ }
+ }
+ }
/* Anyone who cares about input state, wake up and do something */
void
Session::playlist_length_changed ()
{
- /* we can't just increase end_location->end() if pl->get_maximum_extent()
+ /* we can't just increase session_range_location->end() if pl->get_maximum_extent()
if larger. if the playlist used to be the longest playlist,
- and its now shorter, we have to decrease end_location->end(). hence,
+ and its now shorter, we have to decrease session_range_location->end(). hence,
we have to iterate over all diskstreams and check the
playlists currently in use.
*/
set_loop = true;
}
- if (location->is_start()) {
- start_location = location;
- }
- if (location->is_end()) {
- end_location = location;
+ if (location->is_session_range()) {
+ _session_range_location = location;
}
}
void
Session::step_back_from_record ()
{
- /* XXX really atomic compare+swap here */
- if (g_atomic_int_get (&_record_status) == Recording) {
- g_atomic_int_set (&_record_status, Enabled);
+ if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
{
current_block_size = nframes;
- ensure_buffers(_scratch_buffers->available());
-
- delete [] _gain_automation_buffer;
- _gain_automation_buffer = new gain_t[nframes];
-
- allocate_pan_automation_buffers (nframes, _npan_buffers, true);
+ ensure_buffers ();
boost::shared_ptr<RouteList> r = routes.reader ();
}
-list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (TrackMode mode, RouteGroup* route_group, 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 = 0;
+ 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) {
+ if (!find_route_name ("Midi", ++track_id, track_name, sizeof(track_name))) {
+ error << "cannot find name for new midi track" << endmsg;
+ goto failed;
+ }
- /* 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);
+ shared_ptr<MidiTrack> track;
- if (route_by_name (track_name) == 0) {
- break;
- }
+ try {
+ MidiTrack* mt = new MidiTrack (*this, track_name, Route::Flag (0), mode);
- } while (track_id < (UINT_MAX-1));
+ if (mt->init ()) {
+ delete mt;
+ goto failed;
+ }
- shared_ptr<MidiTrack> track;
+ mt->use_new_diskstream();
- try {
- track = boost::shared_ptr<MidiTrack>((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->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;
- }
- }
-
- 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) {
}
track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
- //track->set_remote_control_id (control_id);
+ track->set_remote_control_id (control_id);
new_routes.push_back (track);
ret.push_back (track);
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 << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
if (track) {
/* we need to get rid of this, since the track failed to be created */
return ret;
}
-list<boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
+void
+Session::auto_connect_route (boost::shared_ptr<Route> route,
+ ChanCount& existing_inputs, ChanCount& existing_outputs)
{
- 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;
+ /* 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;
+
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+ vector<string> physinputs;
+ vector<string> physoutputs;
+
+ _engine.get_physical_outputs (*t, physoutputs);
+ _engine.get_physical_inputs (*t, physinputs);
+
+ 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;
+
+ 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;
}
}
}
- }
-
- vector<string> physinputs;
- vector<string> physoutputs;
- _engine.get_physical_outputs (DataType::AUDIO, physoutputs);
- _engine.get_physical_inputs (DataType::AUDIO, physinputs);
+ if (!physoutputs.empty()) {
+ uint32_t nphysical_out = physoutputs.size();
+ for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
+ port = empty_string;
- control_id = ntracks() + nbusses() + 1;
-
- while (how_many) {
+ 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();
+ }
+ }
- /* 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 (!port.empty() && route->output()->connect (
+ route->output()->ports().port(*t, i), port, this)) {
+ break;
+ }
+ }
+ }
+ }
+ existing_inputs += route->n_inputs();
+ existing_outputs += route->n_outputs();
+}
- do {
- ++track_id;
+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 = 0;
+ ChanCount existing_inputs;
+ ChanCount existing_outputs;
+ string port;
+ RouteList new_routes;
+ list<boost::shared_ptr<AudioTrack> > ret;
+ uint32_t control_id;
- snprintf (track_name, sizeof(track_name), "Audio %" PRIu32, track_id);
+ count_existing_route_channels (existing_inputs, existing_outputs);
- if (route_by_name (track_name) == 0) {
- break;
- }
+ control_id = ntracks() + nbusses() + 1;
- } while (track_id < (UINT_MAX-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 {
AudioTrack* at = new AudioTrack (*this, track_name, Route::Flag (0), mode);
+
+ if (at->init ()) {
+ delete at;
+ goto failed;
+ }
+
+ at->use_new_diskstream();
+
boost_debug_shared_ptr_mark_interesting (at, "Track");
track = boost::shared_ptr<AudioTrack>(at);
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"),
+ 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"),
+ 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->input()->connect (track->input()->nth(x), port, this)) {
- break;
- }
- }
- }
-
- if (!physoutputs.empty()) {
- 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 && _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->output()->connect (track->output()->nth(x), port, this)) {
- break;
- }
- }
- }
-
- channels_used += track->n_inputs ().n_audio();
+ auto_connect_route (track, existing_inputs, existing_outputs);
if (route_group) {
route_group->add (track);
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;
+ uint32_t bus_id = 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 {
Route* rt = new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO);
+
+ if (rt->init ()) {
+ delete rt;
+ goto failure;
+ }
+
boost_debug_shared_ptr_mark_interesting (rt, "Route");
shared_ptr<Route> bus (rt);
}
- 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->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->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 = "";
-
- 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()->nth (x%_master_out->input()->n_ports().n_audio())->name();
- }
- }
-
- if (port.length() && bus->output()->connect (bus->output()->nth(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;
}
- channels_used += bus->n_inputs ().n_audio();
+ auto_connect_route (bus, existing_inputs, existing_outputs);
if (route_group) {
route_group->add (bus);
RouteList ret;
uint32_t control_id;
XMLTree tree;
- uint32_t number = 1;
+ uint32_t number = 0;
if (!tree.read (template_path.c_str())) {
return ret;
std::string node_name = IO::name_from_state (*node_copy.children().front());
/* generate a new name by adding a number to the end of the template name */
-
- 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) {
+ if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name))) {
fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
/*NOTREACHED*/
}
we will resort when done.
*/
- if (!_control_out && IO::connecting_legal) {
+ if (!_monitor_out && IO::connecting_legal) {
resort_routes_using (r);
}
}
_master_out = r;
}
- if (r->is_control()) {
- _control_out = r;
+ if (r->is_monitor()) {
+ _monitor_out = r;
}
}
- if (_control_out && IO::connecting_legal) {
+ if (_monitor_out && IO::connecting_legal) {
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- if ((*x)->is_control() || (*x)->is_master()) {
- continue;
- }
- (*x)->listen_via (_control_out,
- (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
- false, false);
+ if ((*x)->is_monitor()) {
+ /* relax */
+ } else if ((*x)->is_master()) {
+ /* relax */
+ } else {
+ (*x)->listen_via (_monitor_out,
+ (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+ false, false);
+ }
}
resort_routes ();
void
Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
{
- if (dest->is_control() || dest->is_master()) {
+ if (dest->is_monitor() || dest->is_master()) {
return;
}
for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
- if ((*i)->is_control() || (*i)->is_master() || (*i) == dest) {
+ if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
continue;
}
diskstream_playlist_changed (boost::weak_ptr<Diskstream> (dstream));
dstream->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_diskstream, this));
-
- dstream->prepare ();
-
}
void
_master_out = shared_ptr<Route> ();
}
- if (route == _control_out) {
+ if (route == _monitor_out) {
/* cancel control outs for all routes */
for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
- (*r)->drop_listen (_control_out);
+ (*r)->drop_listen (_monitor_out);
}
- _control_out.reset ();
+ _monitor_out.reset ();
}
update_route_solo_state ();
delta = -1;
}
- /* now mod the solo level of all other routes except master & control outs
+ /* now mod the solo level of all other routes except master/control outs/auditioner
so that they will be silent if appropriate.
*/
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
bool via_sends_only;
-
- if ((*i) == route || !(*i)->solo_isolated() || !(*i)->is_master() || !(*i)->is_control() || (*i)->is_hidden()) {
+ if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
continue;
} else if ((*i)->feeds (route, &via_sends_only)) {
if (!via_sends_only) {
}
}
- /* make sure master is never muted by solo */
-
- 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 */
void
Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
{
- /* now figure out if anything that matters is soloed */
+ /* now figure out if anything that matters is soloed (or is "listening")*/
bool something_soloed = false;
+ uint32_t listeners = 0;
if (!r) {
r = routes.reader();
}
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_master() && !(*i)->is_control() && !(*i)->is_hidden() && (*i)->self_soloed()) {
+ if (!(*i)->is_master() && !(*i)->is_monitor() && !(*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 */
+ if (!(*i)->is_hidden() && (*i)->listening()) {
+ if (Config->get_solo_control_is_listen_control()) {
+ listeners++;
+ } else {
+ (*i)->set_listen (false, this);
+ }
+ }
}
+
+ if (something_soloed != _non_soloed_outs_muted) {
+ _non_soloed_outs_muted = something_soloed;
+ SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
+ }
+
+ if (listeners) {
+ _listen_cnt = listeners;
+ }
}
boost::shared_ptr<RouteList>
nframes_t max = get_maximum_extent ();
- if (max > end_location->end()) {
- end_location->set_end (max);
+ if (max > _session_range_location->end()) {
+ _session_range_location->set_end (max);
set_dirty();
DurationChanged(); /* EMIT SIGNAL */
}
/* Region management */
-string
-Session::new_region_name (string old)
-{
- string::size_type last_period;
- uint32_t number;
- string::size_type len = old.length() + 64;
- char buf[len];
-
- if ((last_period = old.find_last_of ('.')) == string::npos) {
-
- /* no period present - add one explicitly */
-
- old += '.';
- last_period = old.length() - 1;
- number = 0;
-
- } else {
-
- number = atoi (old.substr (last_period+1).c_str());
-
- }
-
- while (number < (UINT_MAX-1)) {
-
- RegionList::const_iterator i;
- string sbuf;
-
- number++;
-
- snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
- sbuf = buf;
-
- for (i = regions.begin(); i != regions.end(); ++i) {
- if (i->second->name() == sbuf) {
- break;
- }
- }
-
- if (i == regions.end()) {
- break;
- }
- }
-
- if (number != (UINT_MAX-1)) {
- return buf;
- }
-
- error << string_compose (_("cannot create new name for region \"%1\""), old) << endmsg;
- return old;
-}
-
-int
-Session::region_name (string& result, string base, bool newlevel)
-{
- char buf[16];
- string subbase;
-
- if (base.find("/") != string::npos) {
- base = base.substr(base.find_last_of("/") + 1);
- }
-
- if (base == "") {
-
- Glib::Mutex::Lock lm (region_lock);
-
- snprintf (buf, sizeof (buf), "%d", (int)regions.size() + 1);
- result = "region.";
- result += buf;
-
- } else {
-
- if (newlevel) {
- subbase = base;
- } else {
- string::size_type pos;
-
- pos = base.find_last_of ('.');
-
- /* pos may be npos, but then we just use entire base */
-
- subbase = base.substr (0, pos);
-
- }
-
- {
- Glib::Mutex::Lock lm (region_lock);
-
- map<string,uint32_t>::iterator x;
-
- result = subbase;
-
- if ((x = region_name_map.find (subbase)) == region_name_map.end()) {
- result += ".1";
- region_name_map[subbase] = 1;
- } else {
- x->second++;
- snprintf (buf, sizeof (buf), ".%d", x->second);
-
- result += buf;
- }
- }
- }
-
- return 0;
-}
-
-void
-Session::add_region (boost::shared_ptr<Region> region)
-{
- vector<boost::shared_ptr<Region> > v;
- v.push_back (region);
- add_regions (v);
-}
-
-void
-Session::add_regions (vector<boost::shared_ptr<Region> >& new_regions)
-{
- bool added = false;
-
- {
- Glib::Mutex::Lock lm (region_lock);
-
- for (vector<boost::shared_ptr<Region> >::iterator ii = new_regions.begin(); ii != new_regions.end(); ++ii) {
-
- boost::shared_ptr<Region> region = *ii;
-
- if (region == 0) {
-
- error << _("Session::add_region() ignored a null region. Warning: you might have lost a region.") << endmsg;
-
- } else {
-
- RegionList::iterator x;
-
- for (x = regions.begin(); x != regions.end(); ++x) {
-
- if (region->region_list_equivalent (x->second)) {
- break;
- }
- }
-
- if (x == regions.end()) {
-
- pair<RegionList::key_type,RegionList::mapped_type> entry;
-
- entry.first = region->id();
- entry.second = region;
-
- pair<RegionList::iterator,bool> x = regions.insert (entry);
-
- if (!x.second) {
- return;
- }
-
- added = true;
- }
- }
- }
- }
-
- /* mark dirty because something has changed even if we didn't
- add the region to the region list.
- */
-
- set_dirty ();
-
- if (added) {
-
- vector<boost::weak_ptr<Region> > v;
- boost::shared_ptr<Region> first_r;
-
- for (vector<boost::shared_ptr<Region> >::iterator ii = new_regions.begin(); ii != new_regions.end(); ++ii) {
-
- boost::shared_ptr<Region> region = *ii;
-
- if (region == 0) {
-
- error << _("Session::add_region() ignored a null region. Warning: you might have lost a region.") << endmsg;
-
- } else {
- v.push_back (region);
-
- if (!first_r) {
- first_r = region;
- }
- }
-
- region->StateChanged.connect_same_thread (*this, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
- update_region_name_map (region);
- }
-
- if (!v.empty()) {
- RegionsAdded (v); /* EMIT SIGNAL */
- }
- }
-}
-
-void
-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)
-{
- boost::shared_ptr<Region> region (weak_region.lock ());
-
- if (!region) {
- return;
- }
-
- if (what_changed & Region::HiddenChanged) {
- /* relay hidden changes */
- RegionHiddenChange (region);
- }
-
- if (what_changed & NameChanged) {
- update_region_name_map (region);
- }
-}
-
-void
-Session::remove_region (boost::weak_ptr<Region> weak_region)
-{
- RegionList::iterator i;
- boost::shared_ptr<Region> region (weak_region.lock ());
-
- if (!region) {
- return;
- }
-
- bool removed = false;
-
- {
- Glib::Mutex::Lock lm (region_lock);
-
- if ((i = regions.find (region->id())) != regions.end()) {
- regions.erase (i);
- removed = true;
- }
- }
-
- /* mark dirty because something has changed even if we didn't
- remove the region from the region list.
- */
-
- set_dirty();
-
- if (removed) {
- RegionRemoved(region); /* EMIT SIGNAL */
- }
-}
-
boost::shared_ptr<Region>
-Session::find_whole_file_parent (boost::shared_ptr<Region const> child)
+Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
{
- RegionList::iterator i;
+ const RegionFactory::RegionMap& regions (RegionFactory::regions());
+ RegionFactory::RegionMap::const_iterator i;
boost::shared_ptr<Region> region;
Glib::Mutex::Lock lm (region_lock);
for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
- (*i)->mark_for_remove ();
- (*i)->drop_references ();
-
- cerr << "source was not used by any playlist\n";
+ (*i)->mark_for_remove ();
+ (*i)->drop_references ();
+
+ cerr << "source was not used by any playlist\n";
}
return 0;
}
}
- 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);
return 0;
}
-int
-Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
-{
- remove_region (r);
- return 0;
-}
-
/* Source Management */
void
void
Session::cancel_audition ()
{
- if (auditioner->active()) {
+ if (auditioner->auditioning()) {
auditioner->cancel_audition ();
AuditionActive (false); /* EMIT SIGNAL */
}
bool
Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
{
+ if (a->is_monitor()) {
+ return true;
+ }
+ if (b->is_monitor()) {
+ return false;
+ }
return a->order_key(N_("signal")) < b->order_key(N_("signal"));
}
{
/* can be called before we have an auditioner object */
if (auditioner) {
- return auditioner->active();
+ return auditioner->auditioning();
} else {
return false;
}
}
}
-void
-Session::add_processor (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();
-}
-
-void
-Session::remove_processor (Processor* processor)
-{
- Send* send;
- Return* retrn;
- PortInsert* port_insert;
-
- if ((port_insert = dynamic_cast<PortInsert *> (processor)) != 0) {
- insert_bitset[port_insert->bit_slot()] = false;
- } else if ((send = dynamic_cast<Send *> (processor)) != 0) {
- send_bitset[send->bit_slot()] = false;
- } else if ((retrn = dynamic_cast<Return *> (processor)) != 0) {
- return_bitset[retrn->bit_slot()] = false;
- }
-
- set_dirty();
-}
-
nframes_t
Session::available_capture_duration ()
{
}
void
-Session::tempo_map_changed (Change)
+Session::tempo_map_changed (const PropertyChange&)
{
clear_clicks ();
void
Session::ensure_buffers (ChanCount howmany)
{
- if (current_block_size == 0) {
- return; // too early? (is this ok?)
- }
-
- 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);
+ BufferManager::ensure_buffers (howmany);
}
void
insert_bitset[id] = true;
}
+void
+Session::unmark_send_id (uint32_t id)
+{
+ if (id < send_bitset.size()) {
+ send_bitset[id] = false;
+ }
+}
+
+void
+Session::unmark_return_id (uint32_t id)
+{
+ if (id < return_bitset.size()) {
+ return_bitset[id] = false;
+ }
+}
+
+void
+Session::unmark_insert_id (uint32_t id)
+{
+ if (id < insert_bitset.size()) {
+ insert_bitset[id] = false;
+ }
+}
+
+
/* Named Selection management */
boost::shared_ptr<NamedSelection>
return false;
}
-void
-Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
-{
- if (!force && howmany <= _npan_buffers) {
- return;
- }
-
- if (_pan_automation_buffer) {
-
- for (uint32_t i = 0; i < _npan_buffers; ++i) {
- delete [] _pan_automation_buffer[i];
- }
-
- delete [] _pan_automation_buffer;
- }
-
- _pan_automation_buffer = new pan_t*[howmany];
-
- for (uint32_t i = 0; i < howmany; ++i) {
- _pan_automation_buffer[i] = new pan_t[nframes];
- }
-
- _npan_buffers = howmany;
-}
-
int
-Session::freeze (InterThreadInfo& itt)
+Session::freeze_all (InterThreadInfo& itt)
{
shared_ptr<RouteList> r = routes.reader ();
/* XXX this is wrong because itt.progress will keep returning to zero at the start
of every track.
*/
- t->freeze (itt);
+ t->freeze_me (itt);
}
}
/* 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:
return result;
}
+gain_t*
+Session::gain_automation_buffer() const
+{
+ return ProcessThread::gain_automation_buffer ();
+}
+
+pan_t**
+Session::pan_automation_buffer() const
+{
+ return ProcessThread::pan_automation_buffer ();
+}
+
BufferSet&
Session::get_silent_buffers (ChanCount count)
{
+ return ProcessThread::get_silent_buffers (count);
+#if 0
assert(_silent_buffers->available() >= count);
_silent_buffers->set_count(count);
}
return *_silent_buffers;
+#endif
}
BufferSet&
Session::get_scratch_buffers (ChanCount count)
{
+ return ProcessThread::get_scratch_buffers (count);
+#if 0
if (count != ChanCount::ZERO) {
assert(_scratch_buffers->available() >= count);
_scratch_buffers->set_count(count);
}
return *_scratch_buffers;
+#endif
}
BufferSet&
Session::get_mix_buffers (ChanCount count)
{
+ return ProcessThread::get_mix_buffers (count);
+#if 0
assert(_mix_buffers->available() >= count);
_mix_buffers->set_count(count);
return *_mix_buffers;
+#endif
}
uint32_t
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->put_control_outs_at (p);
+ (*i)->put_monitor_send_at (p);
}
}
{
/* 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);
- }
+ if (soloing()) {
+ set_solo (get_routes(), false);
+ } else if (listening()) {
+ set_listen (get_routes(), false);
+ }
}
void
projects / ardour.git / blobdiff