provide mechanism for "drop all slaves" for VCA master

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

diff --git a/libs/ardour/parameter_descriptor.cc b/libs/ardour/parameter_descriptor.cc
index 5d988583cb5b7acad638d907e51fe0051329035b..e28dbecd3586afec3875d71c4da92db4e29ee176 100644 (file)
--- a/libs/ardour/parameter_descriptor.cc
+++ b/libs/ardour/parameter_descriptor.cc
@@ -24,6 +24,8 @@
 #include "ardour/types.h"
 #include "ardour/utils.h"
 
+#include "i18n.h"
+
 namespace ARDOUR {
 
 ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
@@ -43,11 +45,26 @@ ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
        , max_unbound(0)
        , enumeration(false)
 {
+       ScalePoints sp;
+
        switch((AutomationType)parameter.type()) {
        case GainAutomation:
                upper  = Config->get_max_gain();
                normal = 1.0f;
                break;
+       case BusSendLevel:
+               upper = Config->get_max_gain ();
+               normal = 1.0f;
+               break;
+       case BusSendEnable:
+               normal = 1.0f;
+               toggled = true;
+               break;
+       case TrimAutomation:
+               upper  = 10; // +20dB
+               lower  = .1; // -20dB
+               normal = 1.0f;
+               break;
        case PanAzimuthAutomation:
                normal = 0.5f; // there really is no _normal but this works for stereo, sort of
                upper  = 1.0f;
@@ -58,6 +75,7 @@ ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
                normal = 0.0f;
                break;
        case RecEnableAutomation:
+       case RecSafeAutomation:
                lower  = 0.0;
                upper  = 1.0;
                toggled = true;
@@ -87,6 +105,21 @@ ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
                normal = 8192.0;
                upper  = 16383.0;
                break;
+       case PhaseAutomation:
+               toggled = true;
+               break;
+       case MonitoringAutomation:
+               enumeration = true;
+               integer_step = true;
+               lower = MonitorAuto;
+               upper = MonitorDisk; /* XXX bump when we add MonitorCue */
+               break;
+       case SoloIsolateAutomation:
+               toggled = true;
+               break;
+       case SoloSafeAutomation:
+               toggled = true;
+               break;
        default:
                break;
        }
@@ -98,6 +131,7 @@ ParameterDescriptor::ParameterDescriptor()
        : Evoral::ParameterDescriptor()
        , key((uint32_t)-1)
        , datatype(Variant::NOTHING)
+       , type(NullAutomation)
        , unit(NONE)
        , step(0)
        , smallstep(0)
@@ -116,7 +150,7 @@ ParameterDescriptor::update_steps()
        if (unit == ParameterDescriptor::MIDI_NOTE) {
                step      = smallstep = 1;  // semitone
                largestep = 12;             // octave
-       } else if (type == GainAutomation) {
+       } else if (type == GainAutomation || type == TrimAutomation) {
                /* dB_coeff_step gives a step normalized for [0, max_gain].  This is
                   like "slider position", so we convert from "slider position" to gain
                   to have the correct unit here. */
@@ -132,15 +166,21 @@ ParameterDescriptor::update_steps()
                largestep = (delta / 30.0f);
 
                if (logarithmic) {
-                       /* Compensate for internal_to_interface's pow so we get roughly the
-                          desired number of steps. */
-                       smallstep = pow(smallstep, 1.5f);
-                       step      = pow(step, 1.5f);
-                       largestep = pow(largestep, 1.5f);
+                       /* Steps are linear, but we map them with pow like values (in
+                          internal_to_interface).  Thus, they are applied exponentially,
+                          which means too few steps.  So, divide to get roughly the
+                          desired number of steps (30).  This is not mathematically
+                          precise but seems to be about right for the controls I tried.
+                          If you're reading this, you've probably found a case where that
+                          isn't true, and somebody needs to sit down with a piece of paper
+                          and actually do the math. */
+                       smallstep = smallstep / logf(30.0f);
+                       step      = step      / logf(30.0f);
+                       largestep = largestep / logf(30.0f);
                } else if (integer_step) {
-                       smallstep = std::max(1.0, rint(smallstep));
-                       step      = std::max(1.0, rint(step));
-                       largestep = std::max(1.0, rint(largestep));
+                       smallstep = 1.0;
+                       step      = std::max(1.f, rintf (step));
+                       largestep = std::max(1.f, rintf (largestep));
                }
        }
 }