libs/ardour/parameter_descriptor.cc

   1 /*
   2     Copyright (C) 2014 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify it
   6     under the terms of the GNU General Public License as published by the Free
   7     Software Foundation; either version 2 of the License, or (at your option)
   8     any later version.
   9
  10     This program is distributed in the hope that it will be useful, but WITHOUT
  11     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13     for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include "ardour/amp.h"
  21 #include "ardour/dB.h"
  22 #include "ardour/parameter_descriptor.h"
  23 #include "ardour/rc_configuration.h"
  24 #include "ardour/types.h"
  25 #include "ardour/utils.h"
  26
  27 namespace ARDOUR {
  28
  29 ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
  30         : Evoral::ParameterDescriptor()
  31         , key((uint32_t)-1)
  32         , datatype(Variant::NOTHING)
  33         , type((AutomationType)parameter.type())
  34         , unit(NONE)
  35         , step(0)
  36         , smallstep(0)
  37         , largestep(0)
  38         , integer_step(parameter.type() >= MidiCCAutomation &&
  39                        parameter.type() <= MidiChannelPressureAutomation)
  40         , logarithmic(false)
  41         , sr_dependent(false)
  42         , min_unbound(0)
  43         , max_unbound(0)
  44         , enumeration(false)
  45 {
  46         switch((AutomationType)parameter.type()) {
  47         case GainAutomation:
  48                 upper  = Config->get_max_gain();
  49                 normal = 1.0f;
  50                 break;
  51         case PanAzimuthAutomation:
  52                 normal = 0.5f; // there really is no _normal but this works for stereo, sort of
  53                 upper  = 1.0f;
  54                 break;
  55         case PanWidthAutomation:
  56                 lower  = -1.0;
  57                 upper  = 1.0;
  58                 normal = 0.0f;
  59                 break;
  60         case RecEnableAutomation:
  61                 lower  = 0.0;
  62                 upper  = 1.0;
  63                 toggled = true;
  64                 break;
  65         case PluginAutomation:
  66         case FadeInAutomation:
  67         case FadeOutAutomation:
  68         case EnvelopeAutomation:
  69                 upper  = 2.0f;
  70                 normal = 1.0f;
  71                 break;
  72         case SoloAutomation:
  73         case MuteAutomation:
  74                 upper  = 1.0f;
  75                 normal = 0.0f;
  76                 toggled = true;
  77                 break;
  78         case MidiCCAutomation:
  79         case MidiPgmChangeAutomation:
  80         case MidiChannelPressureAutomation:
  81                 lower  = 0.0;
  82                 normal = 0.0;
  83                 upper  = 127.0;
  84                 break;
  85         case MidiPitchBenderAutomation:
  86                 lower  = 0.0;
  87                 normal = 8192.0;
  88                 upper  = 16383.0;
  89                 break;
  90         default:
  91                 break;
  92         }
  93
  94         update_steps();
  95 }
  96
  97 ParameterDescriptor::ParameterDescriptor()
  98         : Evoral::ParameterDescriptor()
  99         , key((uint32_t)-1)
 100         , datatype(Variant::NOTHING)
 101         , unit(NONE)
 102         , step(0)
 103         , smallstep(0)
 104         , largestep(0)
 105         , integer_step(false)
 106         , logarithmic(false)
 107         , sr_dependent(false)
 108         , min_unbound(0)
 109         , max_unbound(0)
 110         , enumeration(false)
 111 {}
 112
 113 void
 114 ParameterDescriptor::update_steps()
 115 {
 116         if (unit == ParameterDescriptor::MIDI_NOTE) {
 117                 step      = smallstep = 1;  // semitone
 118                 largestep = 12;             // octave
 119         } else if (type == GainAutomation) {
 120                 /* dB_coeff_step gives a step normalized for [0, max_gain].  This is
 121                    like "slider position", so we convert from "slider position" to gain
 122                    to have the correct unit here. */
 123                 largestep = slider_position_to_gain(dB_coeff_step(upper));
 124                 step      = slider_position_to_gain(largestep / 10.0);
 125                 smallstep = step;
 126         } else {
 127                 const float delta = upper - lower;
 128
 129                 /* 30 happens to be the total number of steps for a fader with default
 130                    max gain of 2.0 (6 dB), so we use 30 here too for consistency. */
 131                 step      = smallstep = (delta / 300.0f);
 132                 largestep = (delta / 30.0f);
 133
 134                 if (logarithmic) {
 135                         /* Steps are linear, but we map them with pow like values (in
 136                            internal_to_interface).  Thus, they are applied exponentially,
 137                            which means too few steps.  So, divide to get roughly the
 138                            desired number of steps (30).  This is not mathematically
 139                            precise but seems to be about right for the controls I tried.
 140                            If you're reading this, you've probably found a case where that
 141                            isn't true, and somebody needs to sit down with a piece of paper
 142                            and actually do the math. */
 143                         smallstep = smallstep / logf(30.0f);
 144                         step      = step      / logf(30.0f);
 145                         largestep = largestep / logf(30.0f);
 146                 } else if (integer_step) {
 147                         smallstep = std::max(1.0, rint(smallstep));
 148                         step      = std::max(1.0, rint(step));
 149                         largestep = std::max(1.0, rint(largestep));
 150                 }
 151         }
 152 }
 153
 154 } // namespace ARDOUR