#include "ardour/graph.h"
#include "midi++/jack.h"
+#include "midi++/mmc.h"
#include "i18n.h"
: _engine (eng),
_target_transport_speed (0.0),
_requested_return_frame (-1),
- mmc (0),
- _mmc_port (default_mmc_port),
+ _mmc (0),
_mtc_port (default_mtc_port),
_midi_port (default_midi_port),
_midi_clock_port (default_midi_clock_port),
Crossfade::set_buffer_size (0);
- delete mmc;
+ delete _mmc;
/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
playlists.reset ();
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, true));
- c->add_channel (_("mono"));
+ c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
add_bundle (c);
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->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
- c->add_channel (_("R"));
+ c->add_channel (_("R"), DataType::AUDIO);
c->set_port (1, _engine.get_nth_physical_output (DataType::AUDIO, np + 1));
add_bundle (c);
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, false));
- c->add_channel (_("mono"));
+ c->add_channel (_("mono"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
add_bundle (c);
snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
shared_ptr<Bundle> c (new Bundle (buf, false));
- c->add_channel (_("L"));
+ c->add_channel (_("L"), DataType::AUDIO);
c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
- c->add_channel (_("R"));
+ c->add_channel (_("R"), DataType::AUDIO);
c->set_port (1, _engine.get_nth_physical_input (DataType::AUDIO, np + 1));
add_bundle (c);
if (g_atomic_int_get (&_record_status) != Recording) {
g_atomic_int_set (&_record_status, Recording);
_last_record_location = _transport_frame;
- deliver_mmc(MIDI::MachineControl::cmdRecordStrobe, _last_record_location);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
+ }
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
if ((!Config->get_latched_record_enable () && !play_loop) || force) {
g_atomic_int_set (&_record_status, Disabled);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
+ }
} else {
if (rs == Recording) {
g_atomic_int_set (&_record_status, Enabled);
}
}
- // FIXME: timestamp correct? [DR]
- // FIXME FIXME FIXME: rt_context? this must be called in the process thread.
- // does this /need/ to be sent in all cases?
- if (rt_context) {
- deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
- }
-
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
boost::shared_ptr<RouteList> rl = routes.reader ();
enable_record ();
}
} else {
- deliver_mmc (MIDI::MachineControl::cmdRecordPause, _transport_frame);
+ if (_mmc) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
+ }
RecordStateChanged (); /* EMIT SIGNAL */
}
return;
}
-
{
-
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> r = writer.get_copy ();
resort_routes_using (r);
/* writer goes out of scope and forces update */
- route_graph->rechain( r );
}
//route_graph->dump(1);
RouteSorter cmp;
r->sort (cmp);
+ route_graph->rechain (r);
+
#ifndef NDEBUG
DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
}
shared_ptr<MidiTrack> track;
-
+
try {
MidiTrack* mt = new MidiTrack (*this, track_name, Route::Flag (0), mode);
auto_connect_route (track, existing_inputs, existing_outputs);
track->non_realtime_input_change();
+
if (route_group) {
route_group->add (track);
}
? ChanCount::max(existing_inputs, existing_outputs)
: existing_outputs;
- static string empty_string;
- string& port = empty_string;
-
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
vector<string> physinputs;
vector<string> physoutputs;
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;
+ string port;
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
if (!physoutputs.empty()) {
uint32_t nphysical_out = physoutputs.size();
for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
- port = empty_string;
+ string port;
if (Config->get_output_auto_connect() & AutoConnectPhysical) {
port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
void
Session::remove_route (shared_ptr<Route> route)
{
+ if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
+ return;
+ }
+
{
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> rs = writer.get_copy ();
/* writer goes out of scope, forces route list update */
}
-
+
update_route_solo_state ();
update_session_range_location_marker ();
update_latency_compensation (false, false);
set_dirty();
+ /* flush references out of the graph
+ */
+
+ route_graph->clear_other_chain ();
+
/* 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) */
}
int
-Session::destroy_region (boost::shared_ptr<Region> region)
+Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
{
- vector<boost::shared_ptr<Source> > srcs;
-
- {
- if (region->playlist()) {
- region->playlist()->destroy_region (region);
- }
+ set<boost::shared_ptr<Region> > relevant_regions;
- for (uint32_t n = 0; n < region->n_channels(); ++n) {
- srcs.push_back (region->source (n));
- }
+ for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
+ RegionFactory::get_regions_using_source (*s, relevant_regions);
}
- region->drop_references ();
+ cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
+
+ for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
+ set<boost::shared_ptr<Region> >::iterator tmp;
+
+ tmp = r;
+ ++tmp;
+
+ cerr << "Cleanup " << (*r)->name() << " UC = " << (*r).use_count() << endl;
+
+ playlists->destroy_region (*r);
+ RegionFactory::map_remove (*r);
+
+ (*r)->drop_sources ();
+ (*r)->drop_references ();
- for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
+ cerr << "\tdone UC = " << (*r).use_count() << endl;
- (*i)->mark_for_remove ();
- (*i)->drop_references ();
+ relevant_regions.erase (r);
+
+ r = tmp;
+ }
+
+ for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
- cerr << "source was not used by any playlist\n";
- }
+ {
+ Glib::Mutex::Lock ls (source_lock);
+ /* remove from the main source list */
+ sources.erase ((*s)->id());
+ }
- return 0;
-}
+ (*s)->mark_for_remove ();
+ (*s)->drop_references ();
+
+ s = srcs.erase (s);
+ }
-int
-Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
-{
- for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
- destroy_region (*i);
- }
return 0;
}
int
Session::remove_last_capture ()
{
- list<boost::shared_ptr<Region> > r;
+ list<boost::shared_ptr<Source> > srcs;
boost::shared_ptr<RouteList> rl = routes.reader ();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
continue;
}
- list<boost::shared_ptr<Region> >& l = tr->last_capture_regions();
+ list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
if (!l.empty()) {
- r.insert (r.end(), l.begin(), l.end());
+ srcs.insert (srcs.end(), l.begin(), l.end());
l.clear ();
}
}
- destroy_regions (r);
+ destroy_sources (srcs);
save_state (_current_snapshot_name);
}
if (result.second) {
- set_dirty();
- }
- boost::shared_ptr<AudioFileSource> afs;
+ /* yay, new source */
- if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
- if (Config->get_auto_analyse_audio()) {
- Analyser::queue_source_for_analysis (source, false);
- }
- }
+ 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
/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
-Session::create_midi_source_for_session (string const & n)
+Session::create_midi_source_for_session (Track* track, string const & n)
{
+ /* try to use the existing write source for the track, to keep numbering sane
+ */
+
+ if (track) {
+ /*MidiTrack* mt = dynamic_cast<Track*> (track);
+ assert (mt);
+ */
+
+ list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
+
+ if (!l.empty()) {
+ assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
+ return boost::dynamic_pointer_cast<MidiSource> (l.front());
+ }
+ }
+
const string name = new_midi_source_name (n);
const string path = new_source_path_from_name (DataType::MIDI, name);