/*
- Copyright (C) 1999-2004 Paul Davis
+ Copyright (C) 1999-2004 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 <glibmm/thread.h>
#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/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/auto_bundle.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/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>
-
-#ifdef HAVE_LIBLO
-#include <ardour/osc.h>
-#endif
+#include "pbd/pathscanner.h"
+#include "pbd/stl_delete.h"
+#include "pbd/basename.h"
+#include "pbd/stacktrace.h"
+#include "pbd/file_utils.h"
+
+#include "ardour/analyser.h"
+#include "ardour/audio_buffer.h"
+#include "ardour/audio_diskstream.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/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/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/recent_sessions.h"
+#include "ardour/region_factory.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"
bool Session::_disable_all_loaded_plugins = false;
-Session::compute_peak_t Session::compute_peak = 0;
-Session::find_peaks_t Session::find_peaks = 0;
-Session::apply_gain_to_buffer_t Session::apply_gain_to_buffer = 0;
-Session::mix_buffers_with_gain_t Session::mix_buffers_with_gain = 0;
-Session::mix_buffers_no_gain_t Session::mix_buffers_no_gain = 0;
-
+sigc::signal<void,std::string> Session::Dialog;
sigc::signal<int> Session::AskAboutPendingState;
+sigc::signal<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
sigc::signal<void> Session::SendFeedback;
sigc::signal<void> Session::SMPTEOffsetChanged;
sigc::signal<void> Session::StartTimeChanged;
sigc::signal<void> Session::EndTimeChanged;
+sigc::signal<void> Session::AutoBindingOn;
+sigc::signal<void> Session::AutoBindingOff;
+sigc::signal<void, std::string, std::string> Session::Exported;
Session::Session (AudioEngine &eng,
const string& fullpath,
string mix_template)
: _engine (eng),
+ _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)),
pending_events (2048),
- //midi_requests (128), // the size of this should match the midi request pool size
+ state_tree (0),
+ butler_mixdown_buffer (0),
+ butler_gain_buffer (0),
+ post_transport_work((PostTransportWork)0),
_send_smpte_update (false),
+ midi_thread (pthread_t (0)),
+ midi_requests (128), // the size of this should match the midi request pool size
diskstreams (new DiskstreamList),
routes (new RouteList),
auditioner ((Auditioner*) 0),
+ _total_free_4k_blocks (0),
+ _bundles (new BundleList),
_bundle_xml_node (0),
_click_io ((IO*) 0),
- main_outs (0)
+ click_data (0),
+ click_emphasis_data (0),
+ main_outs (0),
+ _metadata (new SessionMetadata())
+
{
bool new_session;
if (!eng.connected()) {
throw failed_constructor();
}
-
+
cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
- n_physical_outputs = _engine.n_physical_outputs();
- n_physical_inputs = _engine.n_physical_inputs();
+ 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 = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
+ new_session = !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())) {
destroy ();
throw failed_constructor ();
}
}
-
+
if (second_stage_init (new_session)) {
destroy ();
throw failed_constructor ();
}
-
+
store_recent_sessions(_name, _path);
-
+
bool was_dirty = dirty();
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
nframes_t initial_length)
: _engine (eng),
+ _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)),
pending_events (2048),
- //midi_requests (16),
+ state_tree (0),
+ butler_mixdown_buffer (0),
+ butler_gain_buffer (0),
+ post_transport_work((PostTransportWork)0),
_send_smpte_update (false),
+ midi_thread (pthread_t (0)),
+ midi_requests (16),
diskstreams (new DiskstreamList),
routes (new RouteList),
+ auditioner ((Auditioner *) 0),
+ _total_free_4k_blocks (0),
+ _bundles (new BundleList),
_bundle_xml_node (0),
- main_outs (0)
-
+ _click_io ((IO *) 0),
+ click_data (0),
+ click_emphasis_data (0),
+ main_outs (0),
+ _metadata (new SessionMetadata())
{
bool new_session;
cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
- n_physical_outputs = _engine.n_physical_outputs();
- n_physical_inputs = _engine.n_physical_inputs();
+ 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);
{
/* set up Master Out and Control Out if necessary */
-
+
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));
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 (!rl.empty()) {
add_routes (rl, false);
}
-
+
}
Config->set_input_auto_connect (input_ac);
destroy ();
throw failed_constructor ();
}
-
+
store_recent_sessions (_name, _path);
-
- _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
}
_engine.remove_session ();
GoingAway (); /* EMIT SIGNAL */
-
+
/* do this */
notify_callbacks ();
_history.clear ();
/* clear state tree so that no references to objects are held any more */
-
- if (state_tree) {
- delete state_tree;
- }
+
+ delete state_tree;
terminate_butler_thread ();
//terminate_midi_thread ();
-
- if (click_data && click_data != default_click) {
+
+ if (click_data != default_click) {
delete [] click_data;
}
- if (click_emphasis_data && click_emphasis_data != default_click_emphasis) {
+ if (click_emphasis_data != default_click_emphasis) {
delete [] click_emphasis_data;
}
delete _mix_buffers;
AudioDiskstream::free_working_buffers();
-
+
+ Route::SyncOrderKeys.clear();
+
#undef TRACK_DESTRUCTION
#ifdef TRACK_DESTRUCTION
cerr << "delete named selections\n";
++tmp;
(*i)->drop_references ();
-
+
i = tmp;
}
-
+
for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ) {
PlaylistList::iterator tmp;
++tmp;
(*i)->drop_references ();
-
+
i = tmp;
}
-
+
playlists.clear ();
unused_playlists.clear ();
#ifdef TRACK_DESTRUCTION
cerr << "delete regions\n";
#endif /* TRACK_DESTRUCTION */
-
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ) {
RegionList::iterator tmp;
#ifdef TRACK_DESTRUCTION
cerr << "delete routes\n";
#endif /* TRACK_DESTRUCTION */
- {
+ {
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> r = writer.get_copy ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
i = tmp;
}
-
sources.clear ();
#ifdef TRACK_DESTRUCTION
#endif /* TRACK_DESTRUCTION */
for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
list<RouteGroup*>::iterator tmp;
-
+
tmp = i;
++tmp;
i = tmp;
}
-
- if (butler_mixdown_buffer) {
- delete [] butler_mixdown_buffer;
- }
- if (butler_gain_buffer) {
- delete [] butler_gain_buffer;
- }
+ delete [] butler_mixdown_buffer;
+ delete [] butler_gain_buffer;
Crossfade::set_buffer_size (0);
- if (mmc) {
- delete mmc;
- }
+ delete mmc;
}
void
}
boost::shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
_worst_output_latency = max (_worst_output_latency, (*i)->output_latency());
_worst_input_latency = max (_worst_input_latency, (*i)->input_latency());
/* we don't want to run execute this again */
+ BootMessage (_("Set block size and sample rate"));
+
set_block_size (_engine.frames_per_cycle());
set_frame_rate (_engine.frame_rate());
+ BootMessage (_("Using configuration"));
+
Config->map_parameters (mem_fun (*this, &Session::config_changed));
/* every time we reconnect, recompute worst case output latencies */
try {
XMLNode* child = 0;
-
+
_click_io.reset (new ClickIO (*this, "click", 0, 0, -1, -1));
if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
/* existing state for Click */
-
+
if (_click_io->set_state (*child->children().front()) == 0) {
-
+
_clicking = Config->get_clicking ();
} else {
}
} else {
-
+
/* default state for Click */
first_physical_output = _engine.get_nth_physical_output (DataType::AUDIO, 0);
error << _("cannot setup Click I/O") << endmsg;
}
+ BootMessage (_("Compute I/O Latencies"));
+
set_worst_io_latencies ();
if (_clicking) {
// XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
}
- /* Create a set of Bundle objects that map
- to the physical outputs currently available
- */
+ BootMessage (_("Set up standard connections"));
- /* ONE: MONO */
+ /* Create a set of Bundle objects that map
+ 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 */
for (uint32_t np = 0; np < n_physical_outputs; ++np) {
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
- shared_ptr<AutoBundle> c (new AutoBundle (buf, true));
- c->set_channels (1);
+ shared_ptr<Bundle> c (new Bundle (buf, true));
+ c->add_channel (_("mono"));
c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
add_bundle (c);
}
- for (uint32_t np = 0; np < n_physical_inputs; ++np) {
- char buf[32];
- snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
-
- shared_ptr<AutoBundle> c (new AutoBundle (buf, false));
- c->set_channels (1);
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ 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);
+ }
}
- /* TWO: STEREO */
-
- for (uint32_t np = 0; np < n_physical_outputs; np +=2) {
+ for (uint32_t np = 0; np < n_physical_inputs; ++np) {
char buf[32];
- snprintf (buf, sizeof (buf), _("out %" PRIu32 "+%" PRIu32), np+1, np+2);
+ snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
- shared_ptr<AutoBundle> c (new AutoBundle (buf, true));
- c->set_channels (2);
- c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
- c->set_port (1, _engine.get_nth_physical_output (DataType::AUDIO, np + 1));
+ shared_ptr<Bundle> c (new Bundle (buf, false));
+ c->add_channel (_("mono"));
+ c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
add_bundle (c);
}
- for (uint32_t np = 0; np < n_physical_inputs; np +=2) {
- char buf[32];
- snprintf (buf, sizeof (buf), _("in %" PRIu32 "+%" PRIu32), np+1, np+2);
+ 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);
- shared_ptr<AutoBundle> c (new AutoBundle (buf, false));
- c->set_channels (2);
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
- c->set_port (1, _engine.get_nth_physical_input (DataType::AUDIO, np + 1));
+ 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));
- add_bundle (c);
+ add_bundle (c);
+ }
}
- /* THREE MASTER */
-
if (_master_out) {
/* create master/control ports */
-
+
if (_master_out) {
uint32_t n;
/* force the master to ignore any later call to this */
-
+
if (_master_out->pending_state_node) {
_master_out->ports_became_legal();
}
/* no panner resets till we are through */
-
+
_master_out->defer_pan_reset ();
-
+
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")
+ error << _("cannot setup master inputs")
<< endmsg;
break;
}
}
_master_out->allow_pan_reset ();
-
- }
- shared_ptr<AutoBundle> c (new AutoBundle (_("Master Out"), true));
+ }
+ }
- c->set_channels (_master_out->n_inputs().n_total());
- for (uint32_t n = 0; n < _master_out->n_inputs ().n_total(); ++n) {
- c->set_port (n, _master_out->input(n)->name());
- }
- add_bundle (c);
- }
+ BootMessage (_("Setup signal flow and plugins"));
hookup_io ();
/* catch up on send+insert cnts */
+ BootMessage (_("Catch up with send/insert state"));
+
insert_cnt = 0;
-
+
for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
uint32_t id;
for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
uint32_t id;
-
+
if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
if (id > send_cnt) {
send_cnt = id;
}
}
-
- _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
/* hook us up to the engine */
- _engine.set_session (this);
-
-#ifdef HAVE_LIBLO
- /* and to OSC */
-
- osc->set_session (*this);
-#endif
+ BootMessage (_("Connect to engine"));
+ _engine.set_session (this);
}
void
if (auditioner == 0) {
-
+
/* 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));
}
-
+
catch (failed_constructor& err) {
warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
}
cports.push_back (_control_out->input(n)->name());
}
- boost::shared_ptr<RouteList> r = routes.reader ();
+ boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
(*x)->set_control_outs (cports);
if (_bundle_xml_node) {
load_bundles (*_bundle_xml_node);
delete _bundle_xml_node;
- }
+ }
/* Tell all IO objects to connect themselves together */
void
Session::playlist_length_changed ()
{
- /* we can't just increase end_location->end() if pl->get_maximum_extent()
+ /* we can't just increase end_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,
- we have to iterate over all diskstreams and check the
+ we have to iterate over all diskstreams and check the
playlists currently in use.
*/
find_current_end ();
if ((playlist = dstream->playlist()) != 0) {
playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
}
-
+
/* see comment in playlist_length_changed () */
find_current_end ();
}
/* capture start has been changed, so save new pending state */
save_state ("", true);
}
-}
+}
void
Session::auto_punch_end_changed (Location* location)
nframes_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (Event::PunchOut, when_to_stop);
-}
+}
void
Session::auto_punch_changed (Location* location)
replace_event (Event::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (Event::PunchOut, when_to_stop);
-}
+}
void
Session::auto_loop_changed (Location* location)
if (_transport_frame > location->end()) {
// relocate to beginning of loop
clear_events (Event::LocateRoll);
-
+
request_locate (location->start(), true);
}
else if (Config->get_seamless_loop() && !loop_changing) {
-
+
// schedule a locate-roll to refill the diskstreams at the
// previous loop end
loop_changing = true;
}
}
- }
+ }
last_loopend = location->end();
-
}
void
if (location == 0) {
return;
}
-
+
if (location->end() <= location->start()) {
error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
return;
auto_punch_start_changed_connection.disconnect();
auto_punch_end_changed_connection.disconnect();
auto_punch_changed_connection.disconnect();
-
+
auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
location->set_auto_punch (true, this);
+
+
+ auto_punch_changed (location);
+
auto_punch_location_changed (location);
}
remove_event (existing->end(), Event::AutoLoop);
auto_loop_location_changed (0);
}
-
+
set_dirty();
if (location == 0) {
}
last_loopend = location->end();
-
+
auto_loop_start_changed_connection.disconnect();
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));
location->set_auto_loop (true, this);
+
+ /* take care of our stuff first */
+
+ auto_loop_changed (location);
+
+ /* now tell everyone else */
+
auto_loop_location_changed (location);
}
set_auto_loop_location (location);
set_loop = true;
}
-
+
+ if (location->is_start()) {
+ start_location = location;
+ }
+ if (location->is_end()) {
+ end_location = location;
+ }
}
if (!set_loop) {
}
set_dirty();
-}
+}
void
Session::enable_record ()
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
- (*i)->monitor_input (true);
+ (*i)->monitor_input (true);
}
}
}
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 ()) {
- (*i)->monitor_input (false);
+ (*i)->monitor_input (false);
}
}
}
-
+
RecordStateChanged (); /* emit signal */
if (!rt_context) {
if (g_atomic_int_get (&_record_status) == Recording) {
g_atomic_int_set (&_record_status, Enabled);
- if (Config->get_monitoring_model() == HardwareMonitoring) {
+ 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 (Config->get_auto_input() && (*i)->record_enabled ()) {
+ if ((*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (false);
+ (*i)->monitor_input (false);
}
}
}
if (_transport_speed) {
if (!Config->get_punch_in()) {
enable_record ();
- }
+ }
} else {
deliver_mmc (MIDI::MachineControl::cmdRecordPause, _transport_frame);
RecordStateChanged (); /* EMIT SIGNAL */
nframes_t tf;
/* the first of these two possible settings for "offset"
- mean that the audible frame is stationary until
+ mean that the audible frame is stationary until
audio emerges from the latency compensation
"pseudo-pipeline".
if (offset > current_block_size) {
offset -= current_block_size;
- } else {
+ } else {
/* XXX is this correct? if we have no external
physical connections and everything is internal
then surely this is zero? still, how
} else {
tf = _transport_frame;
}
-
- if (_transport_speed == 0) {
- return tf;
- }
-
- if (tf < offset) {
- return 0;
- }
-
+
ret = tf;
if (!non_realtime_work_pending()) {
/* MOVING */
- /* take latency into account */
-
- ret -= offset;
+ /* check to see if we have passed the first guaranteed
+ audible frame past our last start position. if not,
+ return that last start point because in terms
+ of audible frames, we have not moved yet.
+ */
+
+ if (_transport_speed > 0.0f) {
+
+ if (!play_loop || !have_looped) {
+ if (tf < _last_roll_location + offset) {
+ return _last_roll_location;
+ }
+ }
+
+
+ /* forwards */
+ ret -= offset;
+
+ } else if (_transport_speed < 0.0f) {
+
+ /* XXX wot? no backward looping? */
+
+ if (tf > _last_roll_location - offset) {
+ return _last_roll_location;
+ } else {
+ /* backwards */
+ ret += offset;
+ }
+ }
}
return ret;
Session::set_frame_rate (nframes_t frames_per_second)
{
/** \fn void Session::set_frame_size(nframes_t)
- the AudioEngine object that calls this guarantees
+ the AudioEngine object that calls this guarantees
that it will not be called while we are also in
::process(). Its fine to do things that block
here.
Automatable::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
clear_clicks ();
-
+
// XXX we need some equivalent to this, somehow
// SndFileSource::setup_standard_crossfades (frames_per_second);
void
Session::set_block_size (nframes_t nframes)
{
- /* the AudioEngine guarantees
+ /* the AudioEngine guarantees
that it will not be called while we are also in
::process(). It is therefore fine to do things that block
here.
*/
- {
-
+ {
+
current_block_size = nframes;
ensure_buffers(_scratch_buffers->available());
- if (_gain_automation_buffer) {
- delete [] _gain_automation_buffer;
- }
+ delete [] _gain_automation_buffer;
_gain_automation_buffer = new gain_t[nframes];
allocate_pan_automation_buffers (nframes, _npan_buffers, true);
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->set_block_size (nframes);
}
-
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->set_block_size (nframes);
{
#if 0
nframes_t fade_frames;
-
+
/* Don't allow fade of less 1 frame */
-
+
if (fade_msecs < (1000.0 * (1.0/_current_frame_rate))) {
fade_msecs = 0;
fade_frames = 0;
} else {
-
+
fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
-
+
}
default_fade_msecs = fade_msecs;
set_dirty();
/* XXX have to do this at some point */
- /* foreach region using default fade, reset, then
+ /* foreach region using default fade, reset, then
refill_all_diskstream_buffers ();
*/
#endif
if ((r1->fed_by.find (rbase) != r1->fed_by.end()) && (rbase->fed_by.find (r1) != rbase->fed_by.end())) {
info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
return;
- }
+ }
/* make a copy of the existing list of routes that feed r1 */
Session::resort_routes_using (shared_ptr<RouteList> r)
{
RouteList::iterator i, j;
-
+
for (i = r->begin(); i != r->end(); ++i) {
-
+
(*i)->fed_by.clear ();
-
+
for (j = r->begin(); j != r->end(); ++j) {
-
+
/* although routes can feed themselves, it will
cause an endless recursive descent if we
detect it. so don't bother checking for
self-feeding.
*/
-
+
if (*j == *i) {
continue;
}
-
+
if ((*j)->feeds (*i)) {
(*i)->fed_by.insert (*j);
- }
+ }
}
}
-
+
for (i = r->begin(); i != r->end(); ++i) {
trace_terminal (*i, *i);
}
-
+
RouteSorter cmp;
r->sort (cmp);
-
+
#if 0
cerr << "finished route resort\n";
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
cerr << " " << (*i)->name() << " signal order = " << (*i)->order_key ("signal") << endl;
}
cerr << endl;
#endif
-
+
}
list<boost::shared_ptr<MidiTrack> >
//uint32_t control_id;
// FIXME: need physical I/O and autoconnect stuff for MIDI
-
+
/* count existing midi tracks */
{
}
}
- /*
vector<string> physinputs;
vector<string> physoutputs;
- uint32_t nphysical_in;
- uint32_t nphysical_out;
- _engine.get_physical_outputs (physoutputs);
- _engine.get_physical_inputs (physinputs);
- control_id = ntracks() + nbusses() + 1;
- */
+ _engine.get_physical_outputs (DataType::MIDI, physoutputs);
+ _engine.get_physical_inputs (DataType::MIDI, physinputs);
+
+ // control_id = ntracks() + nbusses();
while (how_many) {
save, close,restart,add new route - first named route is now
Audio2)
*/
-
+
do {
++track_id;
if (route_by_name (track_name) == 0) {
break;
}
-
- } while (track_id < (UINT_MAX-1));
- /*
- if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
- } else {
- nphysical_in = 0;
- }
-
- if (Config->get_output_auto_connect() & AutoConnectPhysical) {
- nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
- } else {
- nphysical_out = 0;
- }
- */
+ } while (track_id < (UINT_MAX-1));
shared_ptr<MidiTrack> track;
-
+
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)) {
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) {
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();
*/
track->midi_diskstream()->non_realtime_input_change();
-
+
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
//track->set_remote_control_id (control_id);
/* we need to get rid of this, since the track failed to be created */
/* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
- {
+ {
RCUWriter<DiskstreamList> writer (diskstreams);
boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
ds->remove (track->midi_diskstream());
/* we need to get rid of this, since the track failed to be created */
/* XXX arguably, MidiTrack::MidiTrack should not do the Session::add_diskstream() */
- {
+ {
RCUWriter<DiskstreamList> writer (diskstreams);
boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
ds->remove (track->midi_diskstream());
vector<string> physinputs;
vector<string> physoutputs;
- uint32_t nphysical_in;
- uint32_t nphysical_out;
- _engine.get_physical_outputs (physoutputs);
- _engine.get_physical_inputs (physinputs);
+ _engine.get_physical_outputs (DataType::AUDIO, physoutputs);
+ _engine.get_physical_inputs (DataType::AUDIO, physinputs);
+
control_id = ntracks() + nbusses() + 1;
while (how_many) {
save, close,restart,add new route - first named route is now
Audio2)
*/
-
+
do {
++track_id;
if (route_by_name (track_name) == 0) {
break;
}
-
- } while (track_id < (UINT_MAX-1));
- if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
- } else {
- nphysical_in = 0;
- }
-
- if (Config->get_output_auto_connect() & AutoConnectPhysical) {
- nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
- } else {
- nphysical_out = 0;
- }
+ } while (track_id < (UINT_MAX-1));
shared_ptr<AudioTrack> track;
-
+
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)) {
error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
input_channels, output_channels)
goto failed;
}
- if (nphysical_in) {
+ if (!physinputs.empty()) {
+ uint32_t nphysical_in = physinputs.size();
+
for (uint32_t x = 0; x < track->n_inputs().n_audio() && x < nphysical_in; ++x) {
-
+
port = "";
-
+
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[(channels_used+x)%nphysical_in];
- }
-
+ }
+
if (port.length() && track->connect_input (track->input (x), port, this)) {
break;
}
}
}
-
- 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_audio())->name();
+
+ 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) {
+ port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
+ }
+ }
+
+ if (port.length() && track->connect_output (track->output (x), port, this)) {
+ break;
}
- }
-
- if (port.length() && track->connect_output (track->output (x), port, this)) {
- break;
}
}
-
+
channels_used += track->n_inputs ().n_audio();
track->audio_diskstream()->non_realtime_input_change();
-
+
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
track->set_remote_control_id (control_id);
++control_id;
/* we need to get rid of this, since the track failed to be created */
/* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
- {
+ {
RCUWriter<DiskstreamList> writer (diskstreams);
boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
ds->remove (track->audio_diskstream());
/* we need to get rid of this, since the track failed to be created */
/* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
- {
+ {
RCUWriter<DiskstreamList> writer (diskstreams);
boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
ds->remove (track->audio_diskstream());
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if ( MixerOrdered == m) {
+ if ( MixerOrdered == m) {
long order = (*i)->order_key(N_("signal"));
(*i)->set_remote_control_id( order+1 );
} else if ( EditorOrdered == m) {
long order = (*i)->order_key(N_("editor"));
(*i)->set_remote_control_id( order+1 );
} else if ( UserOrdered == m) {
- //do nothing ... only changes to remote id's are initiated by user
+ //do nothing ... only changes to remote id's are initiated by user
}
}
}
-Session::RouteList
+RouteList
Session::new_audio_route (int input_channels, int output_channels, uint32_t how_many)
{
char bus_name[32];
uint32_t bus_id = 1;
uint32_t n = 0;
+ uint32_t channels_used = 0;
string port;
RouteList ret;
uint32_t control_id;
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<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 (physoutputs);
- _engine.get_physical_inputs (physinputs);
+ _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();
+
control_id = ntracks() + nbusses() + 1;
while (how_many) {
try {
shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
-
+
if (bus->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
input_channels, output_channels)
<< endmsg;
goto failure;
}
-
- for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs().n_audio(); ++x) {
-
- port = "";
+
+
+ /*
+ for (uint32_t x = 0; n_physical_audio_inputs && x < bus->n_inputs(); ++x) {
+
+ port = "";
+
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
- port = physinputs[((n+x)%n_physical_inputs)];
+ port = physinputs[((n+x)%n_physical_audio_inputs)];
}
if (port.length() && bus->connect_input (bus->input (x), port, this)) {
break;
}
}
-
- for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs().n_audio(); ++x) {
-
+ */
+
+ 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) {
port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
}
}
-
+
if (port.length() && bus->connect_output (bus->output (x), port, this)) {
break;
}
}
-
+
+ channels_used += bus->n_inputs ().n_audio();
+
bus->set_remote_control_id (control_id);
++control_id;
ret.push_back (bus);
}
-
+
catch (failed_constructor &err) {
error << _("Session: could not create new audio route.") << endmsg;
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());
}
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
-
+
boost::weak_ptr<Route> wpr (*x);
(*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
(*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
(*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
(*x)->processors_changed.connect (bind (mem_fun (*this, &Session::update_latency_compensation), false, false));
-
+
if ((*x)->is_master()) {
_master_out = (*x);
}
-
+
if ((*x)->is_control()) {
_control_out = (*x);
}
-
- add_bundle ((*x)->bundle_for_inputs());
- add_bundle ((*x)->bundle_for_outputs());
}
if (_control_out && IO::connecting_legal) {
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
(*x)->set_control_outs (cports);
}
- }
+ }
set_dirty();
{
/* 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);
{
boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
ds->push_back (dstream);
/* writer goes out of scope, copies ds back to main */
- }
+ }
dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
/* this will connect to future changes, and check the current length */
void
Session::remove_route (shared_ptr<Route> route)
{
- {
+ {
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> rs = writer.get_copy ();
-
+
rs->remove (route);
/* deleting the master out seems like a dumb
}
update_route_solo_state ();
-
+
/* writer goes out of scope, forces route list update */
}
Track* t;
boost::shared_ptr<Diskstream> ds;
-
+
if ((t = dynamic_cast<Track*>(route.get())) != 0) {
ds = t->diskstream();
}
-
+
if (ds) {
{
}
find_current_end ();
-
- // We need to disconnect the routes inputs and outputs
+
+ // We need to disconnect the routes inputs and outputs
route->disconnect_inputs (0);
route->disconnect_outputs (0);
-
+
update_latency_compensation (false, false);
set_dirty();
route->drop_references ();
+ sync_order_keys (N_("session"));
+
/* save the new state of the world */
if (save_state (_current_snapshot_name)) {
save_history (_current_snapshot_name);
}
-}
+}
void
Session::route_mute_changed (void* src)
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 ();
}
is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
-
+
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
+
/* soloing a track mutes all other tracks, soloing a bus mutes all other busses */
-
+
if (is_track) {
-
+
/* don't mess with busses */
-
+
if (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 (Config->get_solo_latched()) {
continue;
- }
+ }
}
-
+
/* do it */
solo_update_disabled = true;
solo_update_disabled = false;
}
}
-
+
bool something_soloed = false;
bool same_thing_soloed = false;
bool signal = false;
break;
}
}
-
+
if (something_soloed != currently_soloing) {
signal = true;
currently_soloing = something_soloed;
}
-
+
modify_solo_mute (is_track, same_thing_soloed);
if (signal) {
bool is_track = false;
bool signal = false;
- /* caller must hold RouteLock */
-
/* this is where we actually implement solo by changing
the solo mute setting of each track.
*/
-
+
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->set_solo_mute (false);
}
-
+
if (signal) {
SoloActive (false);
}
shared_ptr<RouteList> r = routes.reader ();
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);
/* 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);
}
}
-}
+}
void
*/
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)
{
Session::get_maximum_extent () const
{
nframes_t max = 0;
- nframes_t me;
+ nframes_t me;
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
+ if ((*i)->destructive()) //ignore tape tracks when getting max extents
+ continue;
boost::shared_ptr<Playlist> pl = (*i)->playlist();
if ((me = pl->get_maximum_extent()) > max) {
max = me;
char buf[len];
if ((last_period = old.find_last_of ('.')) == string::npos) {
-
+
/* no period present - add one explicitly */
old += '.';
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) const
+Session::region_name (string& result, string base, bool newlevel)
{
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 == "") {
-
+
Glib::Mutex::Lock lm (region_lock);
snprintf (buf, sizeof (buf), "%d", (int)regions.size() + 1);
-
-
result = "region.";
result += buf;
} else {
- /* XXX this is going to be slow. optimize me later */
-
if (newlevel) {
subbase = base;
} else {
}
- bool name_taken = true;
-
{
Glib::Mutex::Lock lm (region_lock);
-
- for (int n = 1; n < 5000; ++n) {
-
- result = subbase;
- snprintf (buf, sizeof (buf), ".%d", n);
+
+ 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;
-
- name_taken = false;
-
- for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- if (i->second->name() == result) {
- name_taken = true;
- break;
- }
- }
-
- if (!name_taken) {
- break;
- }
}
}
-
- if (name_taken) {
- fatal << string_compose(_("too many regions with names like %1"), base) << endmsg;
- /*NOTREACHED*/
- }
}
+
return 0;
-}
+}
void
Session::add_region (boost::shared_ptr<Region> region)
{
- boost::shared_ptr<Region> other;
+ 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);
- RegionList::iterator x;
+ for (vector<boost::shared_ptr<Region> >::iterator ii = new_regions.begin(); ii != new_regions.end(); ++ii) {
- for (x = regions.begin(); x != regions.end(); ++x) {
+ boost::shared_ptr<Region> region = *ii;
- other = x->second;
+ if (region == 0) {
- if (region->region_list_equivalent (other)) {
- break;
- }
- }
+ error << _("Session::add_region() ignored a null region. Warning: you might have lost a region.") << endmsg;
+
+ } else {
- if (x == regions.end()) {
+ RegionList::iterator x;
- pair<RegionList::key_type,RegionList::mapped_type> entry;
+ for (x = regions.begin(); x != regions.end(); ++x) {
- entry.first = region->id();
- entry.second = region;
+ if (region->region_list_equivalent (x->second)) {
+ break;
+ }
+ }
- pair<RegionList::iterator,bool> x = regions.insert (entry);
+ if (x == regions.end()) {
+ pair<RegionList::key_type,RegionList::mapped_type> entry;
- if (!x.second) {
- return;
- }
+ entry.first = region->id();
+ entry.second = region;
- added = true;
- }
+ 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();
-
+
+ set_dirty ();
+
if (added) {
- region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
- region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
- RegionAdded (region); /* EMIT SIGNAL */
- }
-}
-void
-Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
-{
- boost::shared_ptr<Region> region (weak_region.lock ());
+ vector<boost::weak_ptr<Region> > v;
+ boost::shared_ptr<Region> first_r;
- if (!region) {
- return;
- }
+ 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 (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
+ region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
+
+ 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
bool removed = false;
- {
+ {
Glib::Mutex::Lock lm (region_lock);
if ((i = regions.find (region->id())) != regions.end()) {
{
RegionList::iterator i;
boost::shared_ptr<Region> region;
-
+
Glib::Mutex::Lock lm (region_lock);
for (i = regions.begin(); i != regions.end(); ++i) {
return region;
}
}
- }
+ }
return boost::shared_ptr<Region> ();
-}
+}
void
Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
Session::destroy_region (boost::shared_ptr<Region> region)
{
vector<boost::shared_ptr<Source> > srcs;
-
+
{
- boost::shared_ptr<AudioRegion> aregion;
-
- if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
- return 0;
+ if (region->playlist()) {
+ region->playlist()->destroy_region (region);
}
-
- if (aregion->playlist()) {
- aregion->playlist()->destroy_region (region);
- }
-
- for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
- srcs.push_back (aregion->source (n));
+
+ for (uint32_t n = 0; n < region->n_channels(); ++n) {
+ srcs.push_back (region->source (n));
}
}
for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
- if (!(*i)->used()) {
- boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
-
- if (afs) {
- (afs)->mark_for_remove ();
- }
-
+ (*i)->mark_for_remove ();
(*i)->drop_references ();
-
+
cerr << "source was not used by any playlist\n";
- }
}
return 0;
Session::remove_last_capture ()
{
list<boost::shared_ptr<Region> > r;
-
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
+
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
list<boost::shared_ptr<Region> >& l = (*i)->last_capture_regions();
-
+
if (!l.empty()) {
r.insert (r.end(), l.begin(), l.end());
l.clear ();
}
/* Source Management */
+
void
Session::add_source (boost::shared_ptr<Source> source)
{
entry.first = source->id();
entry.second = source;
-
+
{
Glib::Mutex::Lock lm (source_lock);
result = sources.insert (entry);
source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
set_dirty();
}
+
+ boost::shared_ptr<AudioFileSource> afs;
+
+ if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
+ if (Config->get_auto_analyse_audio()) {
+ Analyser::queue_source_for_analysis (source, false);
+ }
+ }
}
void
if (!source) {
return;
- }
+ }
- {
+ {
Glib::Mutex::Lock lm (source_lock);
if ((i = sources.find (source->id())) != sources.end()) {
sources.erase (i);
- }
+ }
}
-
+
if (!_state_of_the_state & InCleanup) {
-
+
/* save state so we don't end up with a session file
referring to non-existent sources.
*/
-
+
save_state (_current_snapshot_name);
}
}
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);
/* 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 += ".wav"; /* 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_audio_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;
-}
-
-string
-Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
-{
- 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.
- */
-
- for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
-
- vector<space_and_path>::iterator i;
- uint32_t existing = 0;
-
- for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
-
- SessionDirectory sdir((*i).path);
-
- 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());
- } else if (nchan == 2) {
- if (chan == 0) {
- 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());
- }
- } else if (nchan < 26) {
- 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());
- }
-
- } else {
-
- spath += '/';
- spath += legalized;
-
- if (nchan < 2) {
- snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
- } else if (nchan == 2) {
- if (chan == 0) {
- snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
- } else {
- snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
- }
- } else if (nchan < 26) {
- snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
- } else {
- snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
- }
- }
-
- if (sys::exists(buf)) {
- existing++;
- }
-
- }
-
- if (existing == 0) {
- break;
- }
-
- if (cnt > limit) {
- error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << 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;
-}
-
-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);
- 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;
path += prefix;
path += '-';
path += new_legalized;
- path += ".mid"; /* XXX gag me with a spoon */
-
+ path += ".wav"; /* XXX gag me with a spoon */
+
} else {
-
+
/* 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.
*/
-
+
string dir;
string suffix;
string::size_type slash;
}
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 '.'
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;
+ 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::midi_path_from_name (string name)
+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);
- for (cnt = 1; cnt <= limit; ++cnt) {
+ // 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;
uint32_t existing = 0;
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
SessionDirectory sdir((*i).path);
-
- sys::path p = sdir.midi_path();
- p /= legalized;
+ spath = sdir.sound_path().to_string();
- spath = p.to_string();
+ if (destructive) {
- snprintf (buf, sizeof(buf), "%s-%u.mid", spath.c_str(), cnt);
+ if (nchan < 2) {
+ 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());
+ } else {
+ 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);
+ } else {
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
+ spath.c_str(), cnt, legalized.c_str());
+ }
- if (sys::exists (buf)) {
+ } else {
+
+ spath += '/';
+ spath += legalized;
+
+ if (nchan < 2) {
+ snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
+ } else if (nchan == 2) {
+ if (chan == 0) {
+ snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
+ } else {
+ snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
+ }
+ } else if (nchan < 26) {
+ snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
+ } else {
+ snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
+ }
+ }
+
+ if (sys::exists(buf)) {
existing++;
- }
+ }
+
}
if (existing == 0) {
}
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.
- */
+ return Glib::path_get_basename(buf);
+}
- string foo = buf;
+/** Create a new embedded audio source */
+boost::shared_ptr<AudioFileSource>
+Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
+{
+ const size_t n_chans = ds.n_channels().n_audio();
+ const string name = new_audio_source_name (ds.name(), n_chans, chan, destructive);
+ const string path = new_source_path_from_name(DataType::AUDIO, name);
+ return boost::dynamic_pointer_cast<AudioFileSource> (
+ SourceFactory::createWritable (
+ DataType::AUDIO, *this, path, true, destructive, frame_rate()));
+}
- SessionDirectory sdir(get_best_session_directory_for_new_source ());
+/** Return a unique name based on \a base for a new internal MIDI source */
+string
+Session::new_midi_source_name (const string& base)
+{
+ uint32_t cnt;
+ char buf[PATH_MAX+1];
+ const uint32_t limit = 10000;
+ string legalized;
- spath = sdir.midi_path().to_string();
- spath += '/';
+ buf[0] = '\0';
+ legalized = legalize_for_path (base);
- string::size_type pos = foo.find_last_of ('/');
-
- if (pos == string::npos) {
- spath += foo;
- } else {
- spath += foo.substr (pos + 1);
+ // 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;
+ uint32_t existing = 0;
+
+ for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+
+ SessionDirectory sdir((*i).path);
+
+ sys::path p = sdir.midi_path();
+ p /= legalized;
+
+ snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
+
+ if (sys::exists (buf)) {
+ existing++;
+ }
+ }
+
+ if (existing == 0) {
+ break;
+ }
+
+ if (cnt > limit) {
+ error << string_compose(
+ _("There are already %1 recordings for %2, which I consider too many."),
+ limit, base) << endmsg;
+ destroy ();
+ throw failed_constructor();
+ }
}
- 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());
-
- return boost::dynamic_pointer_cast<SMFSource> (SourceFactory::createWritable (DataType::MIDI, *this, mpath, false, frame_rate()));
+ 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, path, true, false, frame_rate()));
}
}
void
-Session::add_playlist (boost::shared_ptr<Playlist> playlist)
+Session::unassigned_playlists (std::list<boost::shared_ptr<Playlist> > & list)
+{
+ Glib::Mutex::Lock lm (playlist_lock);
+ for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ if (!(*i)->get_orig_diskstream_id().to_s().compare ("0")) {
+ list.push_back (*i);
+ }
+ }
+ for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
+ if (!(*i)->get_orig_diskstream_id().to_s().compare ("0")) {
+ list.push_back (*i);
+ }
+ }
+}
+
+void
+Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
{
if (playlist->hidden()) {
return;
}
- {
+ {
Glib::Mutex::Lock lm (playlist_lock);
if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
playlists.insert (playlists.begin(), playlist);
}
}
+ if (unused) {
+ playlist->release();
+ }
+
set_dirty();
PlaylistAdded (playlist); /* EMIT SIGNAL */
void
Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
{
- {
+ {
Glib::Mutex::Lock lm (playlist_lock);
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
s.push_back (*i);
return;
}
- {
+ {
Glib::Mutex::Lock lm (playlist_lock);
if (!inuse) {
unused_playlists.insert (pl);
-
+
if ((x = playlists.find (pl)) != playlists.end()) {
playlists.erase (x);
}
-
+
} else {
playlists.insert (pl);
-
+
if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
unused_playlists.erase (x);
}
return;
}
- {
+ {
Glib::Mutex::Lock lm (playlist_lock);
PlaylistList::iterator i;
if (i != unused_playlists.end()) {
unused_playlists.erase (i);
}
-
+
}
set_dirty();
PlaylistRemoved (playlist); /* EMIT SIGNAL */
}
-void
+void
Session::set_audition (boost::shared_ptr<Region> r)
{
pending_audition_region = r;
vector<string> audio_filenames;
get_files_in_directory (_session_dir->sound_path(), audio_filenames);
-
+
Glib::Mutex::Lock lm (source_lock);
TapeFileMatcher tape_file_matcher;
sys::path audio_file_path (_session_dir->sound_path());
audio_file_path /= *i;
-
+
if (AudioFileSource::is_empty (*this, audio_file_path.to_string())) {
try
}
catch (const sys::filesystem_error& err)
{
- error << err.what() << endmsg;
+ error << err.what() << endmsg;
}
}
}
Session::set_all_solo (bool yn)
{
shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
(*i)->set_solo (yn, this);
set_dirty();
}
-
+
void
Session::set_all_mute (bool yn)
{
shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
(*i)->set_mute (yn, this);
set_dirty();
}
-
+
uint32_t
Session::n_diskstreams () const
{
if (_state_of_the_state & InitialConnecting) {
return;
}
-
+
/* every track/bus asked for this to be handled but it was deferred because
we were connecting. do it now.
*/
resort_routes ();
- /* force all diskstreams to update their capture offset values to
+ /* force all diskstreams to update their capture offset values to
reflect any changes in latencies within the graph.
*/
-
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
Session::record_enable_change_all (bool yn)
{
shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
Track* at;
at->set_record_enable (yn, this);
}
}
-
+
/* since we don't keep rec-enable state, don't mark session dirty */
}
Send* send;
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()) {
sample_bytes_on_disk = 2.0;
break;
- default:
+ default:
/* impossible, but keep some gcc versions happy */
fatal << string_compose (_("programming error: %1"),
X_("illegal native file data format"))
if (_total_free_4k_blocks * scale > (double) max_frames) {
return max_frames;
}
-
+
return (nframes_t) floor (_total_free_4k_blocks * scale);
}
Session::add_bundle (shared_ptr<Bundle> bundle)
{
{
- Glib::Mutex::Lock guard (bundle_lock);
- _bundles.push_back (bundle);
+ RCUWriter<BundleList> writer (_bundles);
+ boost::shared_ptr<BundleList> b = writer.get_copy ();
+ b->push_back (bundle);
}
-
+
BundleAdded (bundle); /* EMIT SIGNAL */
set_dirty();
bool removed = false;
{
- Glib::Mutex::Lock guard (bundle_lock);
- BundleList::iterator i = find (_bundles.begin(), _bundles.end(), bundle);
-
- if (i != _bundles.end()) {
- _bundles.erase (i);
+ RCUWriter<BundleList> writer (_bundles);
+ boost::shared_ptr<BundleList> b = writer.get_copy ();
+ BundleList::iterator i = find (b->begin(), b->end(), bundle);
+
+ if (i != b->end()) {
+ b->erase (i);
removed = true;
}
}
shared_ptr<Bundle>
Session::bundle_by_name (string name) const
{
- Glib::Mutex::Lock lm (bundle_lock);
-
- for (BundleList::const_iterator i = _bundles.begin(); i != _bundles.end(); ++i) {
+ boost::shared_ptr<BundleList> b = _bundles.reader ();
+
+ for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
Session::tempo_map_changed (Change ignored)
{
clear_clicks ();
+
+ for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ (*i)->update_after_tempo_map_change ();
+ }
+
+ for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
+ (*i)->update_after_tempo_map_change ();
+ }
+
set_dirty ();
}
_scratch_buffers->ensure_buffers(howmany, current_block_size);
_mix_buffers->ensure_buffers(howmany, current_block_size);
_silent_buffers->ensure_buffers(howmany, current_block_size);
-
+
allocate_pan_automation_buffers (current_block_size, howmany.n_audio(), false);
}
if (!insert_bitset[n]) {
insert_bitset[n] = true;
return n;
-
+
}
}
-
+
/* none available, so resize and try again */
insert_bitset.resize (insert_bitset.size() + 16, false);
if (!send_bitset[n]) {
send_bitset[n] = true;
return n;
-
+
}
}
-
+
/* none available, so resize and try again */
send_bitset.resize (send_bitset.size() + 16, false);
void
Session::add_named_selection (NamedSelection* named_selection)
{
- {
+ {
Glib::Mutex::Lock lm (named_selection_lock);
named_selections.insert (named_selections.begin(), named_selection);
}
{
bool removed = false;
- {
+ {
Glib::Mutex::Lock lm (named_selection_lock);
NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
Session::route_name_unique (string n) const
{
shared_ptr<RouteList> r = routes.reader ();
-
+
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
if ((*i)->name() == n) {
return false;
}
}
-
+
return true;
}
}
_pan_automation_buffer = new pan_t*[howmany];
-
+
for (uint32_t i = 0; i < howmany; ++i) {
_pan_automation_buffer[i] = new pan_t[nframes];
}
return 0;
}
-int
-Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len,
- bool overwrite, vector<boost::shared_ptr<Source> >& srcs, InterThreadInfo& 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)
{
- int ret = -1;
+ boost::shared_ptr<Region> result;
boost::shared_ptr<Playlist> playlist;
boost::shared_ptr<AudioFileSource> fsource;
uint32_t x;
BufferSet buffers;
SessionDirectory sdir(get_best_session_directory_for_new_source ());
const string sound_dir = sdir.sound_path().to_string();
+ nframes_t len = end - start;
+
+ if (end <= start) {
+ error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
+ end, start) << endmsg;
+ return result;
+ }
// 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);
-
+
/* call tree *MUST* hold route_lock */
-
+
if ((playlist = track.diskstream()->playlist()) == 0) {
goto out;
}
break;
}
}
-
+
if (x == 99999) {
error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
goto out;
}
-
+
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) {
error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
goto out;
}
/* XXX need to flush all redirects */
-
+
position = start;
to_do = len;
if (afs)
afs->prepare_for_peakfile_writes ();
}
-
+
while (to_do && !itt.cancel) {
-
+
this_chunk = min (to_do, chunk_size);
-
+
if (track.export_stuff (buffers, start, this_chunk)) {
goto out;
}
uint32_t n = 0;
for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
-
+
if (afs) {
if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
goto out;
}
}
}
-
+
start += this_chunk;
to_do -= this_chunk;
-
+
itt.progress = (float) (1.0 - ((double) to_do / len));
}
if (!itt.cancel) {
-
+
time_t now;
struct tm* xnow;
time (&now);
xnow = localtime (&now);
-
+
for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
-
+
if (afs) {
afs->update_header (position, *xnow, now);
afs->flush_header ();
}
}
-
- /* construct a region to represent the bounced material */
- boost::shared_ptr<Region> aregion = RegionFactory::create (srcs, 0, srcs.front()->length(),
- region_name_from_path (srcs.front()->name(), true));
+ /* construct a region to represent the bounced material */
- ret = 0;
+ result = RegionFactory::create (srcs, 0,
+ srcs.front()->length(srcs.front()->timeline_position()),
+ region_name_from_path (srcs.front()->name(), true));
}
-
+
out:
- if (ret) {
+ if (!result) {
for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
if (afs) {
afs->mark_for_remove ();
}
-
+
(*src)->drop_references ();
}
} else {
for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
-
+
if (afs)
afs->done_with_peakfile_writes ();
}
g_atomic_int_set (&processing_prohibited, 0);
- return ret;
+ return result;
}
BufferSet&
_silent_buffers->set_count(count);
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- for (size_t i=0; i < count.get(*t); ++i) {
+ for (size_t i= 0; i < count.get(*t); ++i) {
_silent_buffers->get(*t, i).clear();
}
}
-
+
return *_silent_buffers;
}
BufferSet&
Session::get_scratch_buffers (ChanCount count)
{
- assert(_scratch_buffers->available() >= count);
- _scratch_buffers->set_count(count);
+ if (count != ChanCount::ZERO) {
+ assert(_scratch_buffers->available() >= count);
+ _scratch_buffers->set_count(count);
+ } else {
+ _scratch_buffers->set_count (_scratch_buffers->available());
+ }
+
return *_scratch_buffers;
}
return *_mix_buffers;
}
-uint32_t
+uint32_t
Session::ntracks () const
{
uint32_t n = 0;
return n;
}
-uint32_t
+uint32_t
Session::nbusses () const
{
uint32_t n = 0;
}
void
-Session::sync_order_keys ()
+Session::sync_order_keys (const char* base)
{
if (!Config->get_sync_all_route_ordering()) {
/* leave order keys as they are */
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->sync_order_keys ();
+ (*i)->sync_order_keys (base);
}
- Route::SyncOrderKeys (); // EMIT SIGNAL
+ Route::SyncOrderKeys (base); // EMIT SIGNAL
}
-void
-Session::foreach_bundle (sigc::slot<void, boost::shared_ptr<Bundle> > sl)
-{
- Glib::Mutex::Lock lm (bundle_lock);
- for (BundleList::iterator i = _bundles.begin(); i != _bundles.end(); ++i) {
- sl (*i);
- }
-}
projects / ardour.git / blobdiff