X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fvolume_controller.cc;h=007b623355ab497084cc7c138c25c86ef8d8bae7;hb=95df99e6d4cf6d1f8d71183299d31835e6708eb8;hp=ca5b0abaa274bad494bdce9ebcc9b0cbaad191ce;hpb=4a81c71e970ad91a6e0628e0ffd510d585c938b5;p=ardour.git diff --git a/gtk2_ardour/volume_controller.cc b/gtk2_ardour/volume_controller.cc index ca5b0abaa2..007b623355 100644 --- a/gtk2_ardour/volume_controller.cc +++ b/gtk2_ardour/volume_controller.cc @@ -101,7 +101,7 @@ VolumeController::dB_printer (char buf[32], const boost::shared_ptrlower() + ((_controllable->upper() - _controllable->lower()) * display_value); } else { - v = slider_position_to_gain_with_max (display_value, ARDOUR::Config->get_max_gain()); + v = ARDOUR::slider_position_to_gain_with_max (display_value, ARDOUR::Config->get_max_gain()); } return v; @@ -130,7 +130,7 @@ VolumeController::to_display_value (double control_value) if (_linear) { v = (control_value - _controllable->lower ()) / (_controllable->upper() - _controllable->lower()); } else { - v = gain_to_slider_position_with_max (control_value, ARDOUR::Config->get_max_gain()); + v = ARDOUR::gain_to_slider_position_with_max (control_value, _controllable->upper()); } return v; @@ -139,29 +139,142 @@ VolumeController::to_display_value (double control_value) double VolumeController::adjust (double control_delta) { - double v = _controllable->get_value (); - double abs_delta = fabs (control_delta); - - /* convert to linear/fractional slider position domain */ - v = gain_to_slider_position_with_max (v, ARDOUR::Config->get_max_gain()); - /* adjust in this domain */ - v += control_delta; - /* clamp in this domain */ - v = std::max (0.0, std::min (1.0, v)); - /* convert back to gain coefficient domain */ - v = slider_position_to_gain_with_max (v, ARDOUR::Config->get_max_gain()); - /* clamp in this domain */ - v = std::max (_controllable->lower(), std::min (_controllable->upper(), v)); - - /* now round to some precision in the dB domain */ - v = accurate_coefficient_to_dB (v); - - if (abs_delta <= 0.01) { - v -= fmod (v, 0.05); + double v; + + if (!_linear) { + /* we map back into the linear/fractional slider position, + * because this kind of control goes all the way down + * to -inf dB, and we want this occur in a reasonable way in + * terms of user interaction. if we leave the adjustment in the + * gain coefficient domain (or dB domain), the lower end of the + * control range (getting close to -inf dB) takes forever. + */ +#if 0 + /* convert to linear/fractional slider position domain */ + v = ARDOUR::gain_to_slider_position_with_max (_controllable->get_value (), _controllable->upper()); + /* increment in this domain */ + v += control_delta; + /* clamp to appropriate range for linear/fractional slider domain */ + v = std::max (0.0, std::min (1.0, v)); + /* convert back to gain coefficient domain */ + v = ARDOUR::slider_position_to_gain_with_max (v, _controllable->upper()); + /* clamp in controller domain */ + v = std::max (_controllable->lower(), std::min (_controllable->upper(), v)); + /* convert to dB domain */ + v = accurate_coefficient_to_dB (v); + /* round up/down to nearest 0.1dB */ + if (control_delta > 0.0) { + v = ceil (v * 10.0) / 10.0; + } else { + v = floor (v * 10.0) / 10.0; + } + /* and return it */ + return dB_to_coefficient (v); +#else + /* ^^ Above algorithm is not symmetric. Scroll up to steps, scoll down two steps, -> different gain. + * + * see ./libs/gtkmm2ext/gtkmm2ext/motionfeedback.h and gtk2_ardour/monitor_section.cc: + * min-delta (corr) = MIN(0.01 * page inc, 1 * size_inc) // (gain_control uses size_inc=0.01, page_inc=0.1) + * range corr: 0..2 -> -inf..+6dB + * step sizes [0.01, 0.10, 0.20] * page_inc, [1,2,10,100] * step_inc. [1,2,10,100] * page_inc + * + * 0.001, 0.01, 0.02, 0.1, .2, 1, 10 + * -> 1k steps between -inf..0dB + * -> 1k steps between 0..+dB + * + * IOW: + * the range is from *0 (-inf dB) to *2.0 ( +6dB) + * the knob is configured to to go in steps of 0.001 - that's 2000 steps between 0 and 2. + * or 1000 steps between 0 and 1. + * + * we cannot round to .01dB steps because + * There are only 600 possible values between +0db and +6dB when going in steps of .01dB + * 1000/600 = 1.66666... + * + ****** + * idea: make the 'controllable use a fixed range of dB. + * do a 1:1 mapping between values. :et's stick with the range of 0..2 in 0.001 steps + * + * "-80" becomes 0 and "+6" becomes 2000. (NB +6dB is actually 1995, but we clamp that to the top) + * + * This approach is better (more consistet) but not good. At least the dial does not annoy me as much + * anymore as it did before. + * + * const double stretchfactor = rint((_controllable->upper() - _controllable->lower()) / 0.001); // 2000; + * const double logfactor = stretchfactor / ((20.0 * log10( _controllable->upper())) + 80.0); // = 23.250244732 + */ + v = _controllable->get_value (); + /* assume everything below -60dB is silent (.001 ^= -60dB) + * but map range -80db..+6dB to a scale of 0..2000 + * 80db was motivated because 2000/((20.0 * log(1)) + 80.0) is an integer value. "0dB" is included on the scale. + * but this leaves a dead area at the bottom of the meter.. + */ + double arange = (v >= 0.001) ? ( ((20.0 * log10(v)) + 80.0) * 23.250244732 ) : ( 0 ); + /* add the delta */ + v = rint(arange) + rint(control_delta * 1000.0); // (min steps is 1.0/0.001 == 1000.0) + /* catch bottom -80..-60 db in one step */ + if (v < 466) v = (control_delta > 0) ? 0.001 : 0; + /* reverse operation (pow(10, .05 * ((v / 23.250244732) - 80.0))) + * can be simplified to :*/ + else v = pow(10, (v * 0.00215051499) - 4.0); + /* clamp value in coefficient domain */ + v = std::max (_controllable->lower(), std::min (_controllable->upper(), v)); + return v; +#endif } else { - v -= fmod (v, 0.1); - } + double mult; + + if (control_delta < 0.0) { + mult = -1.0; + } else { + mult = 1.0; + } + + if (fabs (control_delta) < 0.05) { + control_delta = mult * 0.05; + } else { + control_delta = mult * 0.1; + } + + v = _controllable->get_value(); + + if (v == 0.0) { + /* if we don't special case this, we can't escape from + the -infinity dB black hole. + */ + if (control_delta > 0.0) { + v = dB_to_coefficient (-100 + control_delta); + } + } else { + static const double dB_minus_200 = dB_to_coefficient (-200.0); + static const double dB_minus_100 = dB_to_coefficient (-100.0); + static const double dB_minus_50 = dB_to_coefficient (-50.0); + static const double dB_minus_20 = dB_to_coefficient (-20.0); + + if (control_delta < 0 && v < dB_minus_200) { + v = 0.0; + } else { + + /* non-linear scaling as the dB level gets low + so that we can hit -inf and get back out of + it appropriately. + */ + + if (v < dB_minus_100) { + control_delta *= 1000.0; + } else if (v < dB_minus_50) { + control_delta *= 100.0; + } else if (v < dB_minus_20) { + control_delta *= 10.0; + } + + v = accurate_coefficient_to_dB (v); + v += control_delta; + v = dB_to_coefficient (v); + } + } + + return std::max (_controllable->lower(), std::min (_controllable->upper(), v)); + } - /* and return it */ - return dB_to_coefficient (v); }