X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fvolume_controller.cc;h=c72a31036a1adac47cc7bc3414aa315e9865ec6b;hb=e0d0735fa2c2543c6995e9128dbd16c799f4ec8f;hp=8a382f6cb156736d25ce7baa572f00bfc13d3687;hpb=01e006e46e6d4dd0ab25e08bd44d13dd1e195886;p=ardour.git diff --git a/gtk2_ardour/volume_controller.cc b/gtk2_ardour/volume_controller.cc index 8a382f6cb1..c72a31036a 100644 --- a/gtk2_ardour/volume_controller.cc +++ b/gtk2_ardour/volume_controller.cc @@ -28,6 +28,7 @@ #include "gtkmm2ext/gui_thread.h" #include "ardour/dB.h" +#include "ardour/rc_configuration.h" #include "ardour/utils.h" #include "volume_controller.h" @@ -42,21 +43,13 @@ VolumeController::VolumeController (Glib::RefPtr p, bool with_numeric, int subw, int subh, - bool linear, - bool dB) + bool linear) : MotionFeedback (p, MotionFeedback::Rotary, c, def, step, page, "", with_numeric, subw, subh) , _linear (linear) - , _controllable_uses_dB (dB) { set_print_func (VolumeController::_dB_printer, this); - - if (step < 1.0) { - value->set_width_chars (6 + abs ((int) ceil (log10 (step)))); - } else { - value->set_width_chars (5); // -NNdB - } - + value->set_width_chars (8); } void @@ -72,27 +65,39 @@ VolumeController::dB_printer (char buf[32], const boost::shared_ptrget_value()); + if (step_inc < 1.0) { - snprintf (buf, 32, "%.2f dB", c->get_value()); + if (val >= 0.0) { + snprintf (buf, 32, "+%5.2f dB", val); + } else { + snprintf (buf, 32, "%5.2f dB", val); + } } else { - snprintf (buf, 32, "%ld dB", lrint (c->get_value())); + if (val >= 0.0) { + snprintf (buf, 32, "+%2ld dB", lrint (val)); + } else { + snprintf (buf, 32, "%2ld dB", lrint (val)); + } } + } else { - double gain_coefficient; - - if (!_controllable_uses_dB) { - gain_coefficient = c->get_value(); - } else { - double fract = (c->get_value() - c->lower()) / (c->upper() - c->lower()); - gain_coefficient = slider_position_to_gain (fract); - } + double dB = accurate_coefficient_to_dB (c->get_value()); if (step_inc < 1.0) { - snprintf (buf, 32, "%.2f dB", accurate_coefficient_to_dB (gain_coefficient)); + if (dB >= 0.0) { + snprintf (buf, 32, "+%5.2f dB", dB); + } else { + snprintf (buf, 32, "%5.2f dB", dB); + } } else { - snprintf (buf, 32, "%ld dB", lrint (accurate_coefficient_to_dB (gain_coefficient))); + if (dB >= 0.0) { + snprintf (buf, 32, "+%2ld dB", lrint (dB)); + } else { + snprintf (buf, 32, "%2ld dB", lrint (dB)); + } } } } else { @@ -111,8 +116,7 @@ VolumeController::to_control_value (double display_value) if (_linear) { v = _controllable->lower() + ((_controllable->upper() - _controllable->lower()) * display_value); } else { - - v = slider_position_to_gain (display_value); + v = slider_position_to_gain_with_max (display_value, ARDOUR::Config->get_max_gain()); } return v; @@ -126,8 +130,101 @@ VolumeController::to_display_value (double control_value) if (_linear) { v = (control_value - _controllable->lower ()) / (_controllable->upper() - _controllable->lower()); } else { - v = gain_to_slider_position (control_value); + v = gain_to_slider_position_with_max (control_value, _controllable->upper()); } return v; } + +double +VolumeController::adjust (double control_delta) +{ + 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. + */ + + /* convert to linear/fractional slider position domain */ + v = 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 = 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 { + 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)); + } + +}