limiter_db_gain_curve.cc (5539B)
1 /* 2 * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "modules/audio_processing/agc2/limiter_db_gain_curve.h" 12 13 #include <array> 14 #include <cmath> 15 16 #include "common_audio/include/audio_util.h" 17 #include "modules/audio_processing/agc2/agc2_common.h" 18 #include "rtc_base/checks.h" 19 20 namespace webrtc { 21 namespace { 22 23 double ComputeKneeStart(double max_input_level_db, 24 double knee_smoothness_db, 25 double compression_ratio) { 26 RTC_CHECK_LT((compression_ratio - 1.0) * knee_smoothness_db / 27 (2.0 * compression_ratio), 28 max_input_level_db); 29 return -knee_smoothness_db / 2.0 - 30 max_input_level_db / (compression_ratio - 1.0); 31 } 32 33 std::array<double, 3> ComputeKneeRegionPolynomial(double knee_start_dbfs, 34 double knee_smoothness_db, 35 double compression_ratio) { 36 const double a = (1.0 - compression_ratio) / 37 (2.0 * knee_smoothness_db * compression_ratio); 38 const double b = 1.0 - 2.0 * a * knee_start_dbfs; 39 const double c = a * knee_start_dbfs * knee_start_dbfs; 40 return {{a, b, c}}; 41 } 42 43 double ComputeLimiterD1(double max_input_level_db, double compression_ratio) { 44 return (std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) * 45 (1.0 - compression_ratio) / compression_ratio) / 46 kMaxAbsFloatS16Value; 47 } 48 49 constexpr double ComputeLimiterD2(double compression_ratio) { 50 return (1.0 - 2.0 * compression_ratio) / compression_ratio; 51 } 52 53 double ComputeLimiterI2(double max_input_level_db, 54 double compression_ratio, 55 double gain_curve_limiter_i1) { 56 RTC_CHECK_NE(gain_curve_limiter_i1, 0.f); 57 return std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) / 58 gain_curve_limiter_i1 / 59 std::pow(kMaxAbsFloatS16Value, gain_curve_limiter_i1 - 1); 60 } 61 62 } // namespace 63 64 LimiterDbGainCurve::LimiterDbGainCurve() 65 : max_input_level_linear_(DbfsToFloatS16(max_input_level_db_)), 66 knee_start_dbfs_(ComputeKneeStart(max_input_level_db_, 67 knee_smoothness_db_, 68 compression_ratio_)), 69 knee_start_linear_(DbfsToFloatS16(knee_start_dbfs_)), 70 limiter_start_dbfs_(knee_start_dbfs_ + knee_smoothness_db_), 71 limiter_start_linear_(DbfsToFloatS16(limiter_start_dbfs_)), 72 knee_region_polynomial_(ComputeKneeRegionPolynomial(knee_start_dbfs_, 73 knee_smoothness_db_, 74 compression_ratio_)), 75 gain_curve_limiter_d1_( 76 ComputeLimiterD1(max_input_level_db_, compression_ratio_)), 77 gain_curve_limiter_d2_(ComputeLimiterD2(compression_ratio_)), 78 gain_curve_limiter_i1_(1.0 / compression_ratio_), 79 gain_curve_limiter_i2_(ComputeLimiterI2(max_input_level_db_, 80 compression_ratio_, 81 gain_curve_limiter_i1_)) { 82 static_assert(knee_smoothness_db_ > 0.0f, ""); 83 static_assert(compression_ratio_ > 1.0f, ""); 84 RTC_CHECK_GE(max_input_level_db_, knee_start_dbfs_ + knee_smoothness_db_); 85 } 86 87 double LimiterDbGainCurve::GetOutputLevelDbfs(double input_level_dbfs) const { 88 if (input_level_dbfs < knee_start_dbfs_) { 89 return input_level_dbfs; 90 } else if (input_level_dbfs < limiter_start_dbfs_) { 91 return GetKneeRegionOutputLevelDbfs(input_level_dbfs); 92 } 93 return GetCompressorRegionOutputLevelDbfs(input_level_dbfs); 94 } 95 96 double LimiterDbGainCurve::GetGainLinear(double input_level_linear) const { 97 if (input_level_linear < knee_start_linear_) { 98 return 1.0; 99 } 100 return DbfsToFloatS16( 101 GetOutputLevelDbfs(FloatS16ToDbfs(input_level_linear))) / 102 input_level_linear; 103 } 104 105 // Computes the first derivative of GetGainLinear() in `x`. 106 double LimiterDbGainCurve::GetGainFirstDerivativeLinear(double x) const { 107 // Beyond-knee region only. 108 RTC_CHECK_GE(x, limiter_start_linear_ - 1e-7 * kMaxAbsFloatS16Value); 109 return gain_curve_limiter_d1_ * 110 std::pow(x / kMaxAbsFloatS16Value, gain_curve_limiter_d2_); 111 } 112 113 // Computes the integral of GetGainLinear() in the range [x0, x1]. 114 double LimiterDbGainCurve::GetGainIntegralLinear(double x0, double x1) const { 115 RTC_CHECK_LE(x0, x1); // Valid interval. 116 RTC_CHECK_GE(x0, limiter_start_linear_); // Beyond-knee region only. 117 auto limiter_integral = [this](const double& x) { 118 return gain_curve_limiter_i2_ * std::pow(x, gain_curve_limiter_i1_); 119 }; 120 return limiter_integral(x1) - limiter_integral(x0); 121 } 122 123 double LimiterDbGainCurve::GetKneeRegionOutputLevelDbfs( 124 double input_level_dbfs) const { 125 return knee_region_polynomial_[0] * input_level_dbfs * input_level_dbfs + 126 knee_region_polynomial_[1] * input_level_dbfs + 127 knee_region_polynomial_[2]; 128 } 129 130 double LimiterDbGainCurve::GetCompressorRegionOutputLevelDbfs( 131 double input_level_dbfs) const { 132 return (input_level_dbfs - max_input_level_db_) / compression_ratio_; 133 } 134 135 } // namespace webrtc