VCA API-change: return created VCAs (handy for Lua scripts)

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

diff --git a/libs/ardour/ardour/parameter_descriptor.h b/libs/ardour/ardour/parameter_descriptor.h
index 379d97ef3e190a4f36c6e25b365fe9b319bc1dbd..87363bb2c31b46e9782868d7427de873059cd5e7 100644 (file)
--- a/libs/ardour/ardour/parameter_descriptor.h
+++ b/libs/ardour/ardour/parameter_descriptor.h
@@ -20,8 +20,11 @@
 #ifndef __ardour_parameter_descriptor_h__
 #define __ardour_parameter_descriptor_h__
 
+#include "ardour/types.h"
 #include "ardour/variant.h"
+
 #include "evoral/Parameter.hpp"
+#include "evoral/ParameterDescriptor.hpp"
 
 namespace ARDOUR {
 
@@ -31,93 +34,75 @@ typedef std::map<const std::string, const float> ScalePoints;
  *
  * Essentially a union of LADSPA, VST and LV2 info.
  */
-struct ParameterDescriptor
+struct LIBARDOUR_API ParameterDescriptor : public Evoral::ParameterDescriptor
 {
        enum Unit {
                NONE,       ///< No unit
                DB,         ///< Decibels
                MIDI_NOTE,  ///< MIDI note number
+               HZ,         ///< Frequency in Hertz
        };
 
-       ParameterDescriptor(const Evoral::Parameter& parameter)
-               : key((uint32_t)-1)
-               , datatype(Variant::VOID)
-               , normal(parameter.normal())
-               , lower(parameter.min())
-               , upper(parameter.max())
-               , step((upper - lower) / 100.0f)
-               , smallstep((upper - lower) / 1000.0f)
-               , largestep((upper - lower) / 10.0f)
-               , integer_step(parameter.type() >= MidiCCAutomation &&
-                              parameter.type() <= MidiChannelPressureAutomation)
-               , toggled(parameter.toggled())
-               , logarithmic(false)
-               , sr_dependent(false)
-               , min_unbound(0)
-               , max_unbound(0)
-               , enumeration(false)
-       {
-               if (parameter.type() == GainAutomation) {
-                       unit = DB;
-               }
-       }
-
-       ParameterDescriptor()
-               : key((uint32_t)-1)
-               , datatype(Variant::VOID)
-               , normal(0)
-               , lower(0)
-               , upper(0)
-               , step(0)
-               , smallstep(0)
-               , largestep(0)
-               , integer_step(false)
-               , toggled(false)
-               , logarithmic(false)
-               , sr_dependent(false)
-               , min_unbound(0)
-               , max_unbound(0)
-               , enumeration(false)
-       {}
-
-       /// Set step, smallstep, and largestep, based on current description
-       void update_steps() {
-               if (unit == ParameterDescriptor::MIDI_NOTE) {
-                       step      = smallstep = 1;  // semitone
-                       largestep = 12;             // octave
-               } else {
-                       const float delta = upper - lower;
-
-                       step      = delta / 1000.0f;
-                       smallstep = delta / 10000.0f;
-                       largestep = delta / 10.0f;
-
-                       if (integer_step) {
-                               step      = rint(step);
-                               largestep = rint(largestep);
-                               // leave smallstep alone for fine tuning
-                       }
-               }
-       }
+       static std::string midi_note_name (uint8_t, bool translate=true);
+
+       /** Dual of midi_note_name, convert a note name into its midi note number. */
+       typedef std::map<std::string, uint8_t> NameNumMap;
+       static std::string normalize_note_name(const std::string& name);
+       static NameNumMap build_midi_name2num();
+       static uint8_t midi_note_num (const std::string& name);
+
+       ParameterDescriptor(const Evoral::Parameter& parameter);
+
+       ParameterDescriptor();
+
+       /** control-value to normalized [0..1] range
+        *
+        * Convert given AutomationType from lower/upper range to [0..1]
+        * interface value, using settings from Evoral::ParameterDescriptor.
+        *
+        * default for AutomationControl::internal_to_interface ();
+        */
+       float to_interface (float) const;
+
+       /** normalized [0..1] to control-value range
+        *
+        * Convert [0..1] to the control's range of this AutomationType
+        * using settings from Evoral::ParameterDescriptor.
+        *
+        * default for AutomationControl::interface_to_internal ();
+        */
+       float from_interface (float) const;
+
+       bool  is_linear () const;
+       float compute_delta (float from, float to) const;
+       float apply_delta (float value, float delta) const;
+
+       /* find the closest scale-point, return the internal value of
+        * the prev/next scale-point (no wrap-around)
+        *
+        * If the given parameter is not en enum, the given val is returned.
+        *
+        * @param val internal (not interface) value
+        * @param prev if true, step to prev scale-point, otherwise next
+        * @return internal value, suitable for set_value()
+        */
+       float step_enum (float val, bool prev) const;
+
+       /** Set step, smallstep, and largestep, based on current description. */
+       void update_steps();
 
        std::string                    label;
        std::string                    print_fmt;  ///< format string for pretty printing
        boost::shared_ptr<ScalePoints> scale_points;
        uint32_t                       key;  ///< for properties
        Variant::Type                  datatype;  ///< for properties
+       AutomationType                 type;
        Unit                           unit;
-       float                          normal;
-       float                          lower;  ///< for frequencies, this is in Hz (not a fraction of the sample rate)
-       float                          upper;  ///< for frequencies, this is in Hz (not a fraction of the sample rate)
        float                          step;
        float                          smallstep;
        float                          largestep;
        bool                           integer_step;
-       bool                           toggled;
-       bool                           logarithmic;
        bool                           sr_dependent;
-       bool                           min_unbound;
-       bool                           max_unbound;
        bool                           enumeration;
 };