fix crash when copy'ing latent plugins

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

diff --git a/libs/ardour/vca.cc b/libs/ardour/vca.cc
index 39303fc8cadbe9818ffdadfefba64cfc2f91c882..a2b16913bbb05c3bab47d43c4cbbfff78f6f4551 100644 (file)
--- a/libs/ardour/vca.cc
+++ b/libs/ardour/vca.cc
@@ -19,19 +19,22 @@
 #include "pbd/convert.h"
 
 #include "ardour/automation_control.h"
+#include "ardour/debug.h"
 #include "ardour/gain_control.h"
+#include "ardour/monitor_control.h"
 #include "ardour/rc_configuration.h"
 #include "ardour/route.h"
 #include "ardour/session.h"
 #include "ardour/vca.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
 using namespace PBD;
 using std::string;
 
-gint VCA::next_number = 1;
+Glib::Threads::Mutex VCA::number_lock;
+int32_t VCA::next_number = 1;
 string VCA::xml_node_name (X_("VCA"));
 
 string
@@ -40,35 +43,36 @@ VCA::default_name_template ()
        return _("VCA %n");
 }
 
-int
+int32_t
 VCA::next_vca_number ()
 {
-       /* recall that atomic_int_add() returns the value before the add. We
-        * start at one, then next one will be two etc.
-        */
-       return g_atomic_int_add (&next_number, 1);
+       /* we could use atomic inc here, but elsewhere we need more complete
+          mutex semantics, so we have to do it here also.
+       */
+       Glib::Threads::Mutex::Lock lm (number_lock);
+       return next_number++;
 }
 
 void
-VCA::set_next_vca_number (uint32_t n)
+VCA::set_next_vca_number (int32_t n)
 {
-       g_atomic_int_set (&next_number, n);
+       Glib::Threads::Mutex::Lock lm (number_lock);
+       next_number = n;
 }
 
-uint32_t
+int32_t
 VCA::get_next_vca_number ()
 {
-       return g_atomic_int_get (&next_number);
+       Glib::Threads::Mutex::Lock lm (number_lock);
+       return next_number;
 }
 
-VCA::VCA (Session& s,  uint32_t num, const string& name)
-       : Stripable (s, name)
+VCA::VCA (Session& s,  int32_t num, const string& name)
+       : Stripable (s, name, PresentationInfo (num, PresentationInfo::VCA))
        , Muteable (s, name)
        , Automatable (s)
        , _number (num)
        , _gain_control (new GainControl (s, Evoral::Parameter (GainAutomation), boost::shared_ptr<AutomationList> ()))
-       , _solo_requested (false)
-       , _mute_requested (false)
 {
 }
 
@@ -87,13 +91,16 @@ VCA::init ()
 
 VCA::~VCA ()
 {
-       DropReferences (); /* emit signal */
-}
-
-uint32_t
-VCA::remote_control_id () const
-{
-       return 9999999 + _number;
+       DEBUG_TRACE (DEBUG::Destruction, string_compose ("delete VCA %1\n", number()));
+       {
+               Glib::Threads::Mutex::Lock lm (number_lock);
+               if (_number == next_number - 1) {
+                       /* this was the "last" VCA added, so rewind the next number so
+                        * that future VCAs get numbered as intended
+                        */
+                       next_number--;
+               }
+       }
 }
 
 XMLNode&
@@ -102,12 +109,16 @@ VCA::get_state ()
        XMLNode* node = new XMLNode (xml_node_name);
        node->add_property (X_("name"), _name);
        node->add_property (X_("number"), _number);
-       node->add_property (X_("soloed"), (_solo_requested ? X_("yes") : X_("no")));
-       node->add_property (X_("muted"), (_mute_requested ? X_("yes") : X_("no")));
+
+       node->add_child_nocopy (_presentation_info.get_state());
 
        node->add_child_nocopy (_gain_control->get_state());
+       node->add_child_nocopy (_solo_control->get_state());
+       node->add_child_nocopy (_mute_control->get_state());
        node->add_child_nocopy (get_automation_xml_state());
 
+       node->add_child_nocopy (Slavable::get_state());
+
        return *node;
 }
 
@@ -116,6 +127,8 @@ VCA::set_state (XMLNode const& node, int version)
 {
        XMLProperty const* prop;
 
+       Stripable::set_state (node, version);
+
        if ((prop = node.property ("name")) != 0) {
                set_name (prop->value());
        }
@@ -127,10 +140,24 @@ VCA::set_state (XMLNode const& node, int version)
        XMLNodeList const &children (node.children());
        for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
                if ((*i)->name() == Controllable::xml_node_name) {
+
                        XMLProperty* prop = (*i)->property ("name");
-                       if (prop && prop->value() == X_("gaincontrol")) {
+
+                       if (!prop) {
+                               continue;
+                       }
+
+                       if (prop->value() == _gain_control->name()) {
                                _gain_control->set_state (**i, version);
                        }
+                       if (prop->value() == _solo_control->name()) {
+                               _solo_control->set_state (**i, version);
+                       }
+                       if (prop->value() == _mute_control->name()) {
+                               _mute_control->set_state (**i, version);
+                       }
+               } else if ((*i)->name() == Slavable::xml_node_name) {
+                       Slavable::set_state (**i, version);
                }
        }
 
@@ -138,25 +165,36 @@ VCA::set_state (XMLNode const& node, int version)
 }
 
 void
-VCA::set_solo (bool yn)
+VCA::clear_all_solo_state ()
 {
-       _solo_requested = yn;
+       _solo_control->clear_all_solo_state ();
 }
 
-void
-VCA::set_mute (bool yn)
+MonitorState
+VCA::monitoring_state () const
 {
-       _mute_requested = yn;
+       /* XXX this has to get more complex but not clear how */
+       return MonitoringInput;
 }
 
 bool
-VCA::soloed () const
+VCA::slaved () const
 {
-       return _solo_requested;
+       if (!_gain_control) {
+               return false;
+       }
+       /* just test one particular control, not all of them */
+       return _gain_control->slaved ();
 }
 
 bool
-VCA::muted () const
+VCA::slaved_to (boost::shared_ptr<VCA> vca) const
 {
-       return _mute_requested;
+       if (!vca || !_gain_control) {
+               return false;
+       }
+
+       /* just test one particular control, not all of them */
+
+       return _gain_control->slaved_to (vca->gain_control());
 }