assert() to help find some possible causes of #2991. Fix some confusion with GTK...

[ardour.git] / libs / ardour / session_state.cc

diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index 1742feaab1755e878c8b7b4c3edc2349b2119fd9..e222de2221624a1df43ea398569179f483840b9a 100644 (file)
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -57,6 +57,7 @@
 #include "midi++/port.h"
 
 #include "pbd/boost_debug.h"
+#include "pbd/controllable_descriptor.h"
 #include "pbd/enumwriter.h"
 #include "pbd/error.h"
 #include "pbd/pathscanner.h"
@@ -64,6 +65,7 @@
 #include "pbd/search_path.h"
 #include "pbd/stacktrace.h"
 
+#include "ardour/amp.h"
 #include "ardour/audio_diskstream.h"
 #include "ardour/audio_track.h"
 #include "ardour/audioengine.h"
@@ -144,10 +146,8 @@ Session::first_stage_init (string fullpath, string snapshot_name)
        }
 
        if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
-               cerr << "Session non-writable based on " << _path << endl;
                _writable = false;
        } else {
-               cerr << "Session writable based on " << _path << endl;
                _writable = true;
        }
 
@@ -209,7 +209,6 @@ Session::first_stage_init (string fullpath, string snapshot_name)
        g_atomic_int_set (&_capture_load_min, 100);
        _play_range = false;
        _exporting = false;
-       _exporting_realtime = false;
        _gain_automation_buffer = 0;
        _pan_automation_buffer = 0;
        _npan_buffers = 0;
@@ -1378,6 +1377,7 @@ Session::XMLRouteFactory (const XMLNode& node, int version)
 
        DataType type = DataType::AUDIO;
        const XMLProperty* prop = node.property("default-type");
+       boost::shared_ptr<Route> ret;
 
        if (prop) {
                type = DataType(prop->value());
@@ -1388,17 +1388,19 @@ Session::XMLRouteFactory (const XMLNode& node, int version)
        if (has_diskstream) {
                if (type == DataType::AUDIO) {
                        AudioTrack* at = new AudioTrack (*this, node, version);
-                       // boost_debug_shared_ptr_mark_interesting (at, typeid (at).name());
-                       boost::shared_ptr<Route> ret (at);
-                       return ret;
+                       boost_debug_shared_ptr_mark_interesting (at, "Track");
+                       ret.reset (at);
+                       
                } else {
-                       boost::shared_ptr<Route> ret (new MidiTrack (*this, node, version));
-                       return ret;
+                       ret.reset (new MidiTrack (*this, node, version));
                }
        } else {
-               boost::shared_ptr<Route> ret (new Route (*this, node));
-               return ret;
+               Route* rt = new Route (*this, node);
+               boost_debug_shared_ptr_mark_interesting (rt, "Route");
+               ret.reset (rt);
        }
+
+       return ret;
 }
 
 int
@@ -2676,6 +2678,121 @@ Session::controllable_by_id (const PBD::ID& id)
        return boost::shared_ptr<Controllable>();
 }
 
+boost::shared_ptr<Controllable>
+Session::controllable_by_descriptor (const ControllableDescriptor& desc)
+{
+       boost::shared_ptr<Controllable> c;
+       boost::shared_ptr<Route> r;
+
+       switch (desc.top_level_type()) {
+       case ControllableDescriptor::NamedRoute:
+       {
+               std::string str = desc.top_level_name();
+               if (str == "master") {
+                       r = _master_out;
+               } else if (str == "control" || str == "listen") {
+                       r = _control_out;
+               } else {
+                       r = route_by_name (desc.top_level_name());
+               }
+               break;
+       }
+
+       case ControllableDescriptor::RemoteControlID:
+               r = route_by_remote_id (desc.rid());
+               break;
+       }
+       
+       if (!r) {
+               return c;
+       }
+
+       switch (desc.subtype()) {
+       case ControllableDescriptor::Gain:
+               c = r->gain_control ();
+               break;
+
+       case ControllableDescriptor::Solo:
+               c = r->solo_control();
+               break;
+
+       case ControllableDescriptor::Mute:
+               c = r->mute_control();
+               break;
+
+       case ControllableDescriptor::Recenable:
+       {
+               boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(r);
+               
+               if (t) {
+                       c = t->rec_enable_control ();
+               }
+               break;
+       }
+
+       case ControllableDescriptor::Pan:
+               /* XXX pan control */
+               break;
+
+       case ControllableDescriptor::Balance:
+               /* XXX simple pan control */
+               break;
+
+       case ControllableDescriptor::PluginParameter:
+       {
+               uint32_t plugin = desc.target (0);
+               uint32_t parameter_index = desc.target (1);
+
+               /* revert to zero based counting */
+               
+               if (plugin > 0) {
+                       --plugin;
+               }
+               
+               if (parameter_index > 0) {
+                       --parameter_index;
+               }
+
+               boost::shared_ptr<Processor> p = r->nth_plugin (plugin);
+               
+               if (p) {
+                       c = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
+                               p->data().control(Evoral::Parameter(PluginAutomation, 0, parameter_index)));
+               }
+               break;
+       }
+
+       case ControllableDescriptor::SendGain: 
+       {
+               uint32_t send = desc.target (0);
+
+               /* revert to zero-based counting */
+               
+               if (send > 0) {
+                       --send;
+               }
+               
+               boost::shared_ptr<Processor> p = r->nth_send (send);
+               
+               if (p) {
+                       boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(p);
+                       boost::shared_ptr<Amp> a = s->amp();
+
+                       if (a) {
+                               c = s->amp()->gain_control();
+                       }
+               }
+               break;
+       }
+
+       default:
+               /* relax and return a null pointer */
+               break;
+       }
+
+       return c;
+}
+
 void
 Session::add_instant_xml (XMLNode& node, bool write_to_config)
 {