ardour/livetrax
13
0
Fork 0
Code

Make gain controls step by roughly 1.0/0.1 dB.

Browse Source 
Shoot for roughly 30 steps for all controls.

Always keep sensible step information in ParameterDescriptor and just convert
for the UI.

This is a little weird, but it's less weird than it was before, and works.
This commit is contained in:
David Robillard 2014-12-04 00:29:28 -05:00
parent 9b770c7aff
commit 24727e65be
7 changed files with 46 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
gtk2_ardour/automation_controller.cc
View File

@ -126,19 +126,8 @@ AutomationController::create(boost::shared_ptr<Automatable> printer,
const double lo = ac->internal_to_interface(desc.lower);
const double up = ac->internal_to_interface(desc.upper);
const double normal = ac->internal_to_interface(desc.normal);
double smallstep = desc.smallstep;
double largestep = desc.largestep;
if (smallstep == 0.0) {
smallstep = up / 1000.;
} else {
smallstep = ac->internal_to_interface(desc.lower + smallstep);
}
if (largestep == 0.0) {
largestep = up / 40.;
} else {
largestep = ac->internal_to_interface(desc.lower + largestep);
}
const double smallstep = ac->internal_to_interface(desc.lower + desc.smallstep);
const double largestep = ac->internal_to_interface(desc.lower + desc.largestep);
Gtk::Adjustment* adjustment = manage (
new Gtk::Adjustment (normal, lo, up, smallstep, largestep));

12
gtk2_ardour/gain_meter.cc
View File

@ -49,6 +49,7 @@
#include "ardour/meter.h"
#include "ardour/audio_track.h"
#include "ardour/midi_track.h"
#include "ardour/dB.h"
#include "i18n.h"
@ -82,11 +83,14 @@ reset_cursor_to_default_state (Gtk::StateType, Gtk::Entry* widget)
}
GainMeterBase::GainMeterBase (Session* s, bool horizontal, int fader_length, int fader_girth)
: gain_adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0.0, 1.0, 0.01, 0.1)
: gain_adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), // value
0.0, // lower
1.0, // upper
dB_coeff_step(Config->get_max_gain()) / 10.0, // step increment
dB_coeff_step(Config->get_max_gain())) // page increment
, gain_automation_style_button ("")
, gain_automation_state_button ("")
, _data_type (DataType::AUDIO)
{
using namespace Menu_Helpers;
@ -260,8 +264,8 @@ GainMeterBase::setup_gain_adjustment ()
_data_type = DataType::AUDIO;
gain_adjustment.set_lower (0.0);
gain_adjustment.set_upper (1.0);
gain_adjustment.set_step_increment (0.01);
gain_adjustment.set_page_increment (0.1);
gain_adjustment.set_step_increment (dB_coeff_step(Config->get_max_gain()) / 10.0);
gain_adjustment.set_page_increment (dB_coeff_step(Config->get_max_gain()));
gain_slider->set_default_value (gain_to_slider_position (1));
} else {
_data_type = DataType::MIDI;

6
libs/ardour/amp.cc
View File

@ -27,6 +27,7 @@
#include "ardour/audio_buffer.h"
#include "ardour/buffer_set.h"
#include "ardour/midi_buffer.h"
#include "ardour/rc_configuration.h"
#include "ardour/session.h"
#include "i18n.h"
@ -35,9 +36,6 @@ using namespace ARDOUR;
using namespace PBD;
using std::min;
/* gain range of -inf to +6dB, default 0dB */
const float Amp::max_gain_coefficient = 1.99526231f;
Amp::Amp (Session& s)
: Processor(s, "Amp")
, _apply_gain(true)
@ -403,7 +401,7 @@ Amp::set_state (const XMLNode& node, int version)
void
Amp::GainControl::set_value (double val)
{
AutomationControl::set_value (min (val, (double) max_gain_coefficient));
AutomationControl::set_value (min (val, (double) Config->get_max_gain()));
_amp->session().set_dirty ();
}

2
libs/ardour/ardour/amp.h
View File

@ -106,8 +106,6 @@ public:
std::string value_as_string (boost::shared_ptr<AutomationControl>) const;
static const float max_gain_coefficient;
private:
bool _denormal_protection;
bool _apply_gain;

5
libs/ardour/ardour/dB.h
View File

@ -34,6 +34,11 @@ static inline float accurate_coefficient_to_dB (float coeff) {
return 20.0f * log10f (coeff);
}
static inline double dB_coeff_step(double max_coeff) {
const double max_db = lrint(accurate_coefficient_to_dB(max_coeff));
return 0.1 * (max_coeff / max_db);
}
extern double zero_db_as_fraction;
#endif /* __ardour_dB_h__ */

1
libs/ardour/ardour/parameter_descriptor.h
View File

@ -54,6 +54,7 @@ struct LIBARDOUR_API ParameterDescriptor : public Evoral::ParameterDescriptor
boost::shared_ptr<ScalePoints> scale_points;
uint32_t key; ///< for properties
Variant::Type datatype; ///< for properties
AutomationType type;
Unit unit;
float step;
float smallstep;

45
libs/ardour/parameter_descriptor.cc
View File

@ -18,8 +18,11 @@
*/
#include "ardour/amp.h"
#include "ardour/dB.h"
#include "ardour/parameter_descriptor.h"
#include "ardour/rc_configuration.h"
#include "ardour/types.h"
#include "ardour/utils.h"
namespace ARDOUR {
@ -27,6 +30,7 @@ ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
: Evoral::ParameterDescriptor()
, key((uint32_t)-1)
, datatype(Variant::NOTHING)
, type((AutomationType)parameter.type())
, unit(NONE)
, step(0)
, smallstep(0)
@ -39,13 +43,9 @@ ParameterDescriptor::ParameterDescriptor(const Evoral::Parameter& parameter)
, max_unbound(0)
, enumeration(false)
{
if (parameter.type() == GainAutomation) {
unit = DB;
}
switch((AutomationType)parameter.type()) {
case GainAutomation:
upper = Amp::max_gain_coefficient;
upper = Config->get_max_gain();
normal = 1.0f;
break;
case PanAzimuthAutomation:
@ -116,22 +116,33 @@ ParameterDescriptor::update_steps()
if (unit == ParameterDescriptor::MIDI_NOTE) {
step = smallstep = 1; // semitone
largestep = 12; // octave
} else if (integer_step) {
} else if (type == GainAutomation) {
/* 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. */
largestep = slider_position_to_gain(dB_coeff_step(upper));
step = slider_position_to_gain(largestep / 10.0);
smallstep = step;
} else {
const float delta = upper - lower;
smallstep = delta / 10000.0f;
step = delta / 1000.0f;
largestep = delta / 40.0f;
/* 30 happens to be the total number of steps for a fader with default
max gain of 2.0 (6 dB), so we use 30 here too for consistency. */
step = smallstep = (delta / 300.0f);
largestep = (delta / 30.0f);
smallstep = std::max(1.0, rint(smallstep));
step = std::max(1.0, rint(step));
largestep = std::max(1.0, rint(largestep));
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);
} 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));
}
}
/* else: leave all others as default '0'
* in that case the UI (eg. AutomationController::create)
* uses internal_to_interface() to map the value
* to an appropriate interface range
*/
}
} // namespace ARDOUR