blob: 2821a784e17bd7085ede506df3adc6ceb390b4c7 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LE_FX_ENGINE_DSP_CORE_DYNAMIC_RANGE_COMPRESSION_H_
#define LE_FX_ENGINE_DSP_CORE_DYNAMIC_RANGE_COMPRESSION_H_
#include "common/core/types.h"
#include "common/core/math.h"
#include "dsp/core/basic.h"
#include "dsp/core/interpolation.h"
//#define LOG_NDEBUG 0
#include <cutils/log.h>
namespace le_fx {
// An adaptive dynamic range compression algorithm. The gain adaptation is made
// at the logarithmic domain and it is based on a Branching-Smooth compensated
// digital peak detector with different time constants for attack and release.
class AdaptiveDynamicRangeCompression {
public:
AdaptiveDynamicRangeCompression();
// Initializes the compressor using prior information. It assumes that the
// input signal is speech from high-quality recordings that is scaled and then
// fed to the compressor. The compressor is tuned according to the target gain
// that is expected to be applied.
//
// Target gain receives values between 0.0 and 10.0. The knee threshold is
// reduced as the target gain increases in order to fit the increased range of
// values.
//
// Values between 1.0 and 2.0 will only mildly affect your signal. Higher
// values will reduce the dynamic range of the signal to the benefit of
// increased loudness.
//
// If nothing is known regarding the input, a `target_gain` of 1.0f is a
// relatively safe choice for many signals.
bool Initialize(float target_gain, float sampling_rate);
// A fast version of the algorithm that uses approximate computations for the
// log(.) and exp(.).
float Compress(float x);
// Stereo channel version of the compressor
void Compress(float *x1, float *x2);
// This version is slower than Compress(.) but faster than CompressSlow(.)
float CompressNormalSpeed(float x);
// A slow version of the algorithm that is easier for further developement,
// tuning and debugging
float CompressSlow(float x);
// Sets knee threshold (in decibel).
void set_knee_threshold(float decibel);
// Sets knee threshold via the target gain using an experimentally derived
// relationship.
void set_knee_threshold_via_target_gain(float target_gain);
private:
// The minimum accepted absolute input value and it's natural logarithm. This
// is to prevent numerical issues when the input is close to zero
static const float kMinAbsValue;
static const float kMinLogAbsValue;
// Fixed-point arithmetic limits
static const float kFixedPointLimit;
static const float kInverseFixedPointLimit;
// The default knee threshold in decibel. The knee threshold defines when the
// compressor is actually starting to compress the value of the input samples
static const float kDefaultKneeThresholdInDecibel;
// The compression ratio is the reciprocal of the slope of the line segment
// above the threshold (in the log-domain). The ratio controls the
// effectiveness of the compression.
static const float kCompressionRatio;
// The attack time of the envelope detector
static const float kTauAttack;
// The release time of the envelope detector
static const float kTauRelease;
float sampling_rate_;
// the internal state of the envelope detector
float state_;
// the latest gain factor that was applied to the input signal
float compressor_gain_;
// attack constant for exponential dumping
float alpha_attack_;
// release constant for exponential dumping
float alpha_release_;
float slope_;
// The knee threshold
float knee_threshold_;
float knee_threshold_in_decibel_;
// This interpolator provides the function that relates target gain to knee
// threshold.
sigmod::InterpolatorLinear<float> target_gain_to_knee_threshold_;
LE_FX_DISALLOW_COPY_AND_ASSIGN(AdaptiveDynamicRangeCompression);
};
} // namespace le_fx
#include "dsp/core/dynamic_range_compression-inl.h"
#endif // LE_FX_ENGINE_DSP_CORE_DYNAMIC_RANGE_COMPRESSION_H_
|
