#include <ardour/click.h>
#include <ardour/data_type.h>
#include <ardour/source_factory.h>
+#include <ardour/region_factory.h>
#ifdef HAVE_LIBLO
#include <ardour/osc.h>
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, mix_template, _engine.frame_rate() * 60 * 5)) {
+ if (create (new_session, mix_template, compute_initial_length())) {
cerr << "create failed\n";
throw failed_constructor ();
}
cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
- n_physical_outputs = max (requested_physical_out, _engine.n_physical_outputs());
- n_physical_inputs = max (requested_physical_in, _engine.n_physical_inputs());
+ n_physical_outputs = _engine.n_physical_outputs();
+ n_physical_inputs = _engine.n_physical_inputs();
+
+ 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, 0, initial_length)) {
throw failed_constructor ();
}
AudioDiskstream::free_working_buffers();
+
+ /* this should cause deletion of the auditioner */
+
+ // auditioner.reset ();
#undef TRACK_DESTRUCTION
#ifdef TRACK_DESTRUCTION
cerr << "delete audio regions\n";
#endif /* TRACK_DESTRUCTION */
- for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
+ for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); ) {
+ AudioRegionList::iterator tmp;
+
+ tmp = i;
+ ++tmp;
+
i->second->drop_references ();
+
+ i = tmp;
}
audio_regions.clear ();
{
g_atomic_int_set (&_record_status, Enabled);
- /* XXX this save should really happen in another thread. its needed so that
- pending capture state can be recovered if we crash.
+ /* this function is currently called from somewhere other than an RT thread.
+ this save_state() call therefore doesn't impact anything.
*/
save_state ("", true);
sync_time_vars();
- Route::set_automation_interval ((nframes_t) ceil ((double) frames_per_second * 0.25));
+ Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
// XXX we need some equivalent to this, somehow
- // DestructiveFileSource::setup_standard_crossfades (frames_per_second);
+ // SndFileSource::setup_standard_crossfades (frames_per_second);
set_dirty();
for (i = r->begin(); i != r->end(); ++i) {
trace_terminal (*i, *i);
- }
-
+ }
+
RouteSorter cmp;
r->sort (cmp);
+ /* don't leave dangling references to routes in Route::fed_by */
+
+ for (i = r->begin(); i != r->end(); ++i) {
+ (*i)->fed_by.clear ();
+ }
+
#if 0
cerr << "finished route resort\n";
<< endmsg;
}
- for (uint32_t x = 0; x < bus->n_inputs(); ++x) {
+ for (uint32_t x = 0; n_physical_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_inputs)];
}
if (port.length() && bus->connect_input (bus->input (x), port, this)) {
}
}
- for (uint32_t x = 0; x < bus->n_outputs(); ++x) {
+ for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs(); ++x) {
port = "";
}
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), (*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)->redirects_changed.connect (mem_fun (*this, &Session::update_latency_compensation_proxy));
{
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> rs = writer.get_copy ();
- rs->remove (route);
+ rs->remove (route);
+
/* deleting the master out seems like a dumb
idea, but its more of a UI policy issue
than our concern.
*/
if (route == _master_out) {
- _master_out = shared_ptr<Route> ((Route*) 0);
+ _master_out = shared_ptr<Route> ();
}
if (route == _control_out) {
- _control_out = shared_ptr<Route> ((Route*) 0);
+ _control_out = shared_ptr<Route> ();
/* cancel control outs for all routes */
update_latency_compensation (false, false);
set_dirty();
+
+ // We need to disconnect the routes inputs and outputs
+ route->disconnect_inputs(NULL);
+ route->disconnect_outputs(NULL);
- /* XXX should we disconnect from the Route's signals ? */
+ /* get rid of it from the dead wood collection in the route list manager */
+
+ /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
- save_state (_current_snapshot_name);
+ routes.flush ();
/* try to cause everyone to drop their references */
route->drop_references ();
+
+ /* save the new state of the world */
+
+ if (save_state (_current_snapshot_name)) {
+ save_history (_current_snapshot_name);
+ }
}
void
}
void
-Session::route_solo_changed (void* src, shared_ptr<Route> route)
+Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
{
if (solo_update_disabled) {
// We know already
}
bool is_track;
-
- is_track = (dynamic_cast<AudioTrack*>(route.get()) != 0);
+ boost::shared_ptr<Route> route = wpr.lock ();
+
+ if (!route) {
+ /* should not happen */
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ return;
+ }
+
+ is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
shared_ptr<RouteList> r = routes.reader ();
set_dirty();
if (added) {
- region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), region));
- region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), region));
+ 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)));
AudioRegionAdded (ar); /* EMIT SIGNAL */
}
}
void
-Session::region_changed (Change what_changed, boost::shared_ptr<Region> region)
+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);
}
void
-Session::region_renamed (boost::shared_ptr<Region> region)
-{
- add_region (region);
-}
-
-void
-Session::remove_region (boost::shared_ptr<Region> region)
+Session::remove_region (boost::weak_ptr<Region> weak_region)
{
AudioRegionList::iterator i;
+ boost::shared_ptr<Region> region (weak_region.lock ());
+
+ if (!region) {
+ return;
+ }
+
boost::shared_ptr<AudioRegion> ar;
bool removed = false;
-
+
{
Glib::Mutex::Lock lm (region_lock);
set_dirty();
if (removed) {
- AudioRegionRemoved(ar); /* EMIT SIGNAL */
+ AudioRegionRemoved (ar); /* EMIT SIGNAL */
}
}
}
}
- return boost::shared_ptr<AudioRegion> ((AudioRegion*) 0);
+ return boost::shared_ptr<AudioRegion> ();
}
void
int
Session::destroy_region (boost::shared_ptr<Region> region)
{
- boost::shared_ptr<AudioRegion> aregion;
-
- if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
- return 0;
- }
-
- if (aregion->playlist()) {
- aregion->playlist()->destroy_region (region);
- }
-
vector<boost::shared_ptr<Source> > srcs;
-
- for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
- srcs.push_back (aregion->source (n));
+
+ {
+ boost::shared_ptr<AudioRegion> aregion;
+
+ if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
+ return 0;
+ }
+
+ if (aregion->playlist()) {
+ aregion->playlist()->destroy_region (region);
+ }
+
+ for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
+ srcs.push_back (aregion->source (n));
+ }
}
+ region->drop_references ();
+
for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
-
- if ((*i).use_count() == 1) {
- boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
+ if (!(*i)->used()) {
+ boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
+
if (afs) {
(afs)->mark_for_remove ();
}
(*i)->drop_references ();
+
+ cerr << "source was not used by any playlist\n";
}
}
boost::shared_ptr<Source> source = src.lock();
if (!source) {
- cerr << "removing a source DEAD\n";
- } else {
- cerr << "removing a source " << source->name () << endl;
+ return;
+ }
+
+ {
+ Glib::Mutex::Lock lm (audio_source_lock);
- {
- Glib::Mutex::Lock lm (audio_source_lock);
-
- if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
- audio_sources.erase (i);
- }
- }
+ if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
+ audio_sources.erase (i);
+ }
+ }
+
+ if (!_state_of_the_state & InCleanup) {
- 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);
- }
+ /* save state so we don't end up with a session file
+ referring to non-existent sources.
+ */
- SourceRemoved(source); /* EMIT SIGNAL */
+ save_state (_current_snapshot_name);
}
+
+ SourceRemoved(source); /* EMIT SIGNAL */
}
boost::shared_ptr<Source>
PlaylistAdded (playlist); /* EMIT SIGNAL */
}
+void
+Session::get_playlists (vector<Playlist*>& s)
+{
+ {
+ Glib::Mutex::Lock lm (playlist_lock);
+ for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ s.push_back (*i);
+ }
+ for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
+ s.push_back (*i);
+ }
+ }
+}
+
void
Session::track_playlist (Playlist* pl, bool inuse)
{
nframes_t
Session::available_capture_duration ()
{
- const double scale = 4096.0 / sizeof (Sample);
+ float sample_bytes_on_disk;
+
+ switch (Config->get_native_file_data_format()) {
+ case FormatFloat:
+ sample_bytes_on_disk = 4;
+ break;
+
+ case FormatInt24:
+ sample_bytes_on_disk = 3;
+ break;
+ }
+
+ double scale = 4096.0 / sample_bytes_on_disk;
if (_total_free_4k_blocks * scale > (double) max_frames) {
return max_frames;
afs->build_peaks ();
}
}
-
+
+ /* 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()));
+
ret = 0;
}
}
void
-Session::add_curve(Curve *curve)
+Session::add_automation_list(AutomationList *al)
{
- curves[curve->id()] = curve;
+ automation_lists[al->id()] = al;
}
-void
-Session::add_automation_list(AutomationList *al)
+nframes_t
+Session::compute_initial_length ()
{
- automation_lists[al->id()] = al;
+ return _engine.frame_rate() * 60 * 5;
}
+