/* * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ /* analog_agc.c * * Using a feedback system, determines an appropriate analog volume level * given an input signal and current volume level. Targets a conservative * signal level and is intended for use with a digital AGC to apply * additional gain. * */ #include "agc.h" #include #ifdef WEBRTC_AGC_DEBUG_DUMP #include #endif #include "webrtc_typedef.h" #ifndef MIN #define MIN(A, B) ((A) < (B) ? (A) : (B)) // Get min value #endif #ifndef MAX #define MAX(A, B) ((A) > (B) ? (A) : (B)) // Get max value #endif // Shifting with negative numbers allowed // Positive means left shift #ifndef SHIFT_W32 #define SHIFT_W32(x, c) ((c) >= 0 ? (x) * (1 << (c)) : (x) >> -(c)) #endif // C + the 32 most significant bits of A * B #ifndef AGC_SCALEDIFF32 #define AGC_SCALEDIFF32(A, B, C) \ ((C) + ((B) >> 16) * (A) + (((0x0000FFFF & (B)) * (A)) >> 16)) #endif #ifndef AGC_MUL32 // the 32 most significant bits of A(19) * B(26) >> 13 #define AGC_MUL32(A, B) (((B) >> 13) * (A) + (((0x00001FFF & (B)) * (A)) >> 13)) #endif /* The slope of in Q13*/ static const int16_t kSlope1[8] = {21793, 12517, 7189, 4129, 2372, 1362, 472, 78}; /* The offset in Q14 */ static const int16_t kOffset1[8] = {25395, 23911, 22206, 20737, 19612, 18805, 17951, 17367}; /* The slope of in Q13*/ static const int16_t kSlope2[8] = {2063, 1731, 1452, 1218, 1021, 857, 597, 337}; /* The offset in Q14 */ static const int16_t kOffset2[8] = {18432, 18379, 18290, 18177, 18052, 17920, 17670, 17286}; static const int16_t kMuteGuardTimeMs = 8000; static const int16_t kInitCheck = 42; static const size_t kNumSubframes = 10; /* Default settings if config is not used */ #define AGC_DEFAULT_TARGET_LEVEL 3 #define AGC_DEFAULT_COMP_GAIN 9 /* This is the target level for the analog part in ENV scale. To convert to RMS * scale you * have to add OFFSET_ENV_TO_RMS. */ #define ANALOG_TARGET_LEVEL 11 #define ANALOG_TARGET_LEVEL_2 5 // ANALOG_TARGET_LEVEL / 2 /* Offset between RMS scale (analog part) and ENV scale (digital part). This * value actually * varies with the FIXED_ANALOG_TARGET_LEVEL, hence we should in the future * replace it with * a table. */ #define OFFSET_ENV_TO_RMS 9 /* The reference input level at which the digital part gives an output of * targetLevelDbfs * (desired level) if we have no compression gain. This level should be set high * enough not * to compress the peaks due to the dynamics. */ #define DIGITAL_REF_AT_0_COMP_GAIN 4 /* Speed of reference level decrease. */ #define DIFF_REF_TO_ANALOG 5 #ifdef MIC_LEVEL_FEEDBACK #define NUM_BLOCKS_IN_SAT_BEFORE_CHANGE_TARGET 7 #endif /* Size of analog gain table */ #define GAIN_TBL_LEN 32 /* Matlab code: * fprintf(1, '\t%i, %i, %i, %i,\n', round(10.^(linspace(0,10,32)/20) * 2^12)); */ /* Q12 */ static const uint16_t kGainTableAnalog[GAIN_TBL_LEN] = { 4096, 4251, 4412, 4579, 4752, 4932, 5118, 5312, 5513, 5722, 5938, 6163, 6396, 6638, 6889, 7150, 7420, 7701, 7992, 8295, 8609, 8934, 9273, 9623, 9987, 10365, 10758, 11165, 11587, 12025, 12480, 12953}; /* Gain/Suppression tables for virtual Mic (in Q10) */ static const uint16_t kGainTableVirtualMic[128] = { 1052, 1081, 1110, 1141, 1172, 1204, 1237, 1271, 1305, 1341, 1378, 1416, 1454, 1494, 1535, 1577, 1620, 1664, 1710, 1757, 1805, 1854, 1905, 1957, 2010, 2065, 2122, 2180, 2239, 2301, 2364, 2428, 2495, 2563, 2633, 2705, 2779, 2855, 2933, 3013, 3096, 3180, 3267, 3357, 3449, 3543, 3640, 3739, 3842, 3947, 4055, 4166, 4280, 4397, 4517, 4640, 4767, 4898, 5032, 5169, 5311, 5456, 5605, 5758, 5916, 6078, 6244, 6415, 6590, 6770, 6956, 7146, 7341, 7542, 7748, 7960, 8178, 8402, 8631, 8867, 9110, 9359, 9615, 9878, 10148, 10426, 10711, 11004, 11305, 11614, 11932, 12258, 12593, 12938, 13292, 13655, 14029, 14412, 14807, 15212, 15628, 16055, 16494, 16945, 17409, 17885, 18374, 18877, 19393, 19923, 20468, 21028, 21603, 22194, 22801, 23425, 24065, 24724, 25400, 26095, 26808, 27541, 28295, 29069, 29864, 30681, 31520, 32382}; static const uint16_t kSuppressionTableVirtualMic[128] = { 1024, 1006, 988, 970, 952, 935, 918, 902, 886, 870, 854, 839, 824, 809, 794, 780, 766, 752, 739, 726, 713, 700, 687, 675, 663, 651, 639, 628, 616, 605, 594, 584, 573, 563, 553, 543, 533, 524, 514, 505, 496, 487, 478, 470, 461, 453, 445, 437, 429, 421, 414, 406, 399, 392, 385, 378, 371, 364, 358, 351, 345, 339, 333, 327, 321, 315, 309, 304, 298, 293, 288, 283, 278, 273, 268, 263, 258, 254, 249, 244, 240, 236, 232, 227, 223, 219, 215, 211, 208, 204, 200, 197, 193, 190, 186, 183, 180, 176, 173, 170, 167, 164, 161, 158, 155, 153, 150, 147, 145, 142, 139, 137, 134, 132, 130, 127, 125, 123, 121, 118, 116, 114, 112, 110, 108, 106, 104, 102}; /* Table for target energy levels. Values in Q(-7) * Matlab code * targetLevelTable = fprintf('%d,\t%d,\t%d,\t%d,\n', * round((32767*10.^(-(0:63)'/20)).^2*16/2^7) */ static const int32_t kTargetLevelTable[64] = { 134209536, 106606424, 84680493, 67264106, 53429779, 42440782, 33711911, 26778323, 21270778, 16895980, 13420954, 10660642, 8468049, 6726411, 5342978, 4244078, 3371191, 2677832, 2127078, 1689598, 1342095, 1066064, 846805, 672641, 534298, 424408, 337119, 267783, 212708, 168960, 134210, 106606, 84680, 67264, 53430, 42441, 33712, 26778, 21271, 16896, 13421, 10661, 8468, 6726, 5343, 4244, 3371, 2678, 2127, 1690, 1342, 1066, 847, 673, 534, 424, 337, 268, 213, 169, 134, 107, 85, 67}; static __inline int16_t DivW32W16ResW16(int32_t num, int16_t den) { // Guard against division with 0 return (den != 0) ? (int16_t) (num / den) : (int16_t) 0x7FFF; } static __inline int32_t DivW32W16(int32_t num, int16_t den) { // Guard against division with 0 return (den != 0) ? (int32_t) (num / den) : (int32_t) 0x7FFFFFFF; } static __inline uint32_t __clz_uint32(uint32_t v) { // Never used with input 0 assert(v > 0); #if defined(__INTEL_COMPILER) return _bit_scan_reverse(v) ^ 31U; #elif defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) // This will translate either to (bsr ^ 31U), clz , ctlz, cntlz, lzcnt depending on // -march= setting or to a software routine in exotic machines. return __builtin_clz(v); #elif defined(_MSC_VER) // for _BitScanReverse #include { uint32_t idx; _BitScanReverse(&idx, v); return idx ^ 31U; } #else // Will never be emitted for MSVC, GCC, Intel compilers static const uint8_t byte_to_unary_table[] = { 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; return word > 0xffffff ? byte_to_unary_table[v >> 24] : word > 0xffff ? byte_to_unary_table[v >> 16] + 8 : word > 0xff ? byte_to_unary_table[v >> 8] + 16 : byte_to_unary_table[v] + 24; #endif } // Return the number of steps a can be left-shifted without overflow, // or 0 if a == 0. static __inline int16_t NormU32(uint32_t a) { if (a == 0) return 0; return (int16_t) __clz_uint32(a); } static __inline int16_t SatW32ToW16(int32_t value32) { return (int16_t) value32 > 32767 ? (int16_t) 32767 : (value32 < -32768) ? (int16_t) (-32768) : (int16_t) value32; } // Return the number of steps a can be left-shifted without overflow, // or 0 if a == 0. static __inline int16_t NormW32(int32_t a) { if (a == 0) return 0; uint32_t v = (uint32_t) (a < 0 ? ~a : a); // Returns the number of leading zero bits in the argument. return (int16_t) (__clz_uint32(v) - 1); } static __inline int16_t WebRtcSpl_AddSatW16(int16_t a, int16_t b) { return SatW32ToW16((int32_t) a + (int32_t) b); } int32_t DotProductWithScale(const int16_t *vector1, const int16_t *vector2, size_t length, int scaling) { int64_t sum = 0; size_t i = 0; /* Unroll the loop to improve performance. */ for (i = 0; i + 3 < length; i += 4) { sum += (vector1[i + 0] * vector2[i + 0]) >> scaling; sum += (vector1[i + 1] * vector2[i + 1]) >> scaling; sum += (vector1[i + 2] * vector2[i + 2]) >> scaling; sum += (vector1[i + 3] * vector2[i + 3]) >> scaling; } for (; i < length; i++) { sum += (vector1[i] * vector2[i]) >> scaling; } return (int32_t) (sum); } static float fast_sqrt(float x) { float s; s = sqrtf(x); return s; } static __inline void downsampleBy2(const int16_t *in, size_t len, int16_t *out, int32_t *filtState) { int32_t tmp1, tmp2, diff, in32, out32; size_t i; register int32_t state0 = filtState[0]; register int32_t state1 = filtState[1]; register int32_t state2 = filtState[2]; register int32_t state3 = filtState[3]; register int32_t state4 = filtState[4]; register int32_t state5 = filtState[5]; register int32_t state6 = filtState[6]; register int32_t state7 = filtState[7]; for (i = (len >> 1); i > 0; i--) { // lower allpass filter in32 = (int32_t) (*in++) * (1 << 10); diff = in32 - state1; tmp1 = ((state0) + ((diff) >> 16) * (kResampleAllpass2[0]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass2[0])) >> 16)); state0 = in32; diff = tmp1 - state2; tmp2 = ((state1) + ((diff) >> 16) * (kResampleAllpass2[1]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass2[1])) >> 16)); state1 = tmp1; diff = tmp2 - state3; state3 = ((state2) + ((diff) >> 16) * (kResampleAllpass2[2]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass2[2])) >> 16)); state2 = tmp2; // upper allpass filter in32 = (int32_t) (*in++) * (1 << 10); diff = in32 - state5; tmp1 = ((state4) + ((diff) >> 16) * (kResampleAllpass1[0]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass1[0])) >> 16)); state4 = in32; diff = tmp1 - state6; tmp2 = ((state5) + ((diff) >> 16) * (kResampleAllpass1[1]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass1[1])) >> 16)); state5 = tmp1; diff = tmp2 - state7; state7 = ((state6) + ((diff) >> 16) * (kResampleAllpass1[2]) + (((uint32_t) ((diff) & 0x0000FFFF) * (kResampleAllpass1[2])) >> 16)); state6 = tmp2; // add two allpass outputs, divide by two and round out32 = (state3 + state7 + 1024) >> 11; // limit amplitude to prevent wrap-around, and write to output array *out++ = SatW32ToW16(out32); } filtState[0] = state0; filtState[1] = state1; filtState[2] = state2; filtState[3] = state3; filtState[4] = state4; filtState[5] = state5; filtState[6] = state6; filtState[7] = state7; } // To generate the gaintable, copy&paste the following lines to a Matlab window: // MaxGain = 6; MinGain = 0; CompRatio = 3; Knee = 1; // zeros = 0:31; lvl = 2.^(1-zeros); // A = -10*log10(lvl) * (CompRatio - 1) / CompRatio; // B = MaxGain - MinGain; // gains = round(2^16*10.^(0.05 * (MinGain + B * ( // log(exp(-Knee*A)+exp(-Knee*B)) - log(1+exp(-Knee*B)) ) / // log(1/(1+exp(Knee*B)))))); // fprintf(1, '\t%i, %i, %i, %i,\n', gains); // % Matlab code for plotting the gain and input/output level characteristic // (copy/paste the following 3 lines): // in = 10*log10(lvl); out = 20*log10(gains/65536); // subplot(121); plot(in, out); axis([-30, 0, -5, 20]); grid on; xlabel('Input // (dB)'); ylabel('Gain (dB)'); // subplot(122); plot(in, in+out); axis([-30, 0, -30, 5]); grid on; // xlabel('Input (dB)'); ylabel('Output (dB)'); // zoom on; // Generator table for y=log2(1+e^x) in Q8. enum { kGenFuncTableSize = 128 }; static const uint16_t kGenFuncTable[kGenFuncTableSize] = { 256, 485, 786, 1126, 1484, 1849, 2217, 2586, 2955, 3324, 3693, 4063, 4432, 4801, 5171, 5540, 5909, 6279, 6648, 7017, 7387, 7756, 8125, 8495, 8864, 9233, 9603, 9972, 10341, 10711, 11080, 11449, 11819, 12188, 12557, 12927, 13296, 13665, 14035, 14404, 14773, 15143, 15512, 15881, 16251, 16620, 16989, 17359, 17728, 18097, 18466, 18836, 19205, 19574, 19944, 20313, 20682, 21052, 21421, 21790, 22160, 22529, 22898, 23268, 23637, 24006, 24376, 24745, 25114, 25484, 25853, 26222, 26592, 26961, 27330, 27700, 28069, 28438, 28808, 29177, 29546, 29916, 30285, 30654, 31024, 31393, 31762, 32132, 32501, 32870, 33240, 33609, 33978, 34348, 34717, 35086, 35456, 35825, 36194, 36564, 36933, 37302, 37672, 38041, 38410, 38780, 39149, 39518, 39888, 40257, 40626, 40996, 41365, 41734, 42104, 42473, 42842, 43212, 43581, 43950, 44320, 44689, 45058, 45428, 45797, 46166, 46536, 46905}; static const int16_t kAvgDecayTime = 250; // frames; < 3000 int32_t WebRtcAgc_CalculateGainTable(int32_t *gainTable, // Q16 int16_t digCompGaindB, // Q0 int16_t targetLevelDbfs, // Q0 uint8_t limiterEnable, int16_t analogTarget) // Q0 { // This function generates the compressor gain table used in the fixed digital // part. uint32_t tmpU32no1, tmpU32no2, absInLevel, logApprox; int32_t inLevel, limiterLvl; int32_t tmp32, tmp32no1, tmp32no2, numFIX, den, y32; const uint16_t kLog10 = 54426; // log2(10) in Q14 const uint16_t kLog10_2 = 49321; // 10*log10(2) in Q14 const uint16_t kLogE_1 = 23637; // log2(e) in Q14 uint16_t constMaxGain; uint16_t tmpU16, intPart, fracPart; const int16_t kCompRatio = 3; // const int16_t kSoftLimiterLeft = 1; int16_t limiterOffset = 0; // Limiter offset int16_t limiterIdx, limiterLvlX; int16_t constLinApprox, maxGain, diffGain;//zeroGainLvl int16_t i, tmp16, tmp16no1; int zeros, zerosScale; // Constants // kLogE_1 = 23637; // log2(e) in Q14 // kLog10 = 54426; // log2(10) in Q14 // kLog10_2 = 49321; // 10*log10(2) in Q14 // Calculate maximum digital gain and zero gain level tmp32no1 = (digCompGaindB - analogTarget) * (kCompRatio - 1); tmp16no1 = analogTarget - targetLevelDbfs; tmp16no1 += DivW32W16ResW16(tmp32no1 + (kCompRatio >> 1), kCompRatio); maxGain = MAX(tmp16no1, (analogTarget - targetLevelDbfs)); // tmp32no1 = maxGain * kCompRatio; // zeroGainLvl = digCompGaindB; // zeroGainLvl -= WebRtcSpl_DivW32W16ResW16(tmp32no1 + ((kCompRatio - 1) >> 1), kCompRatio - 1); if ((digCompGaindB <= analogTarget) && (limiterEnable)) { //zeroGainLvl += (analogTarget - digCompGaindB + kSoftLimiterLeft); limiterOffset = 0; } // Calculate the difference between maximum gain and gain at 0dB0v: // diffGain = maxGain + (compRatio-1)*zeroGainLvl/compRatio // = (compRatio-1)*digCompGaindB/compRatio tmp32no1 = digCompGaindB * (kCompRatio - 1); diffGain = DivW32W16ResW16(tmp32no1 + (kCompRatio >> 1), kCompRatio); if (diffGain < 0 || diffGain >= kGenFuncTableSize) { assert(0); return -1; } // Calculate the limiter level and index: // limiterLvlX = analogTarget - limiterOffset // limiterLvl = targetLevelDbfs + limiterOffset/compRatio limiterLvlX = analogTarget - limiterOffset; limiterIdx = 2 + DivW32W16ResW16((int32_t) limiterLvlX * (1 << 13), kLog10_2 / 2); tmp16no1 = DivW32W16ResW16(limiterOffset + (kCompRatio >> 1), kCompRatio); limiterLvl = targetLevelDbfs + tmp16no1; // Calculate (through table lookup): // constMaxGain = log2(1+2^(log2(e)*diffGain)); (in Q8) constMaxGain = kGenFuncTable[diffGain]; // in Q8 // Calculate a parameter used to approximate the fractional part of 2^x with a // piecewise linear function in Q14: // constLinApprox = round(3/2*(4*(3-2*sqrt(2))/(log(2)^2)-0.5)*2^14); constLinApprox = 22817; // in Q14 // Calculate a denominator used in the exponential part to convert from dB to // linear scale: // den = 20*constMaxGain (in Q8) den = ((int32_t) (int16_t) (20) * (uint16_t) (constMaxGain)); // in Q8 for (i = 0; i < 32; i++) { // Calculate scaled input level (compressor): // inLevel = // fix((-constLog10_2*(compRatio-1)*(1-i)+fix(compRatio/2))/compRatio) tmp16 = (int16_t) ((kCompRatio - 1) * (i - 1)); // Q0 tmp32 = ((int32_t) (int16_t) (tmp16) * (uint16_t) (kLog10_2)) + 1; // Q14 inLevel = DivW32W16(tmp32, kCompRatio); // Q14 // Calculate diffGain-inLevel, to map using the genFuncTable inLevel = (int32_t) diffGain * (1 << 14) - inLevel; // Q14 // Make calculations on abs(inLevel) and compensate for the sign afterwards. absInLevel = (uint32_t) (((int32_t) (inLevel) >= 0) ? ((int32_t) (inLevel)) : -((int32_t) (inLevel))); // Q14 // LUT with interpolation intPart = (uint16_t) (absInLevel >> 14); fracPart = (uint16_t) (absInLevel & 0x00003FFF); // extract the fractional part tmpU16 = kGenFuncTable[intPart + 1] - kGenFuncTable[intPart]; // Q8 tmpU32no1 = tmpU16 * fracPart; // Q22 tmpU32no1 += (uint32_t) kGenFuncTable[intPart] << 14; // Q22 logApprox = tmpU32no1 >> 8; // Q14 // Compensate for negative exponent using the relation: // log2(1 + 2^-x) = log2(1 + 2^x) - x if (inLevel < 0) { zeros = NormU32(absInLevel); zerosScale = 0; if (zeros < 15) { // Not enough space for multiplication tmpU32no2 = absInLevel >> (15 - zeros); // Q(zeros-1) tmpU32no2 = ((uint32_t) ((uint32_t) (tmpU32no2) * (uint16_t) (kLogE_1))); // Q(zeros+13) if (zeros < 9) { zerosScale = 9 - zeros; tmpU32no1 >>= zerosScale; // Q(zeros+13) } else { tmpU32no2 >>= zeros - 9; // Q22 } } else { tmpU32no2 = ((uint32_t) ((uint32_t) (absInLevel) * (uint16_t) (kLogE_1))); // Q28 tmpU32no2 >>= 6; // Q22 } logApprox = 0; if (tmpU32no2 < tmpU32no1) { logApprox = (tmpU32no1 - tmpU32no2) >> (8 - zerosScale); // Q14 } } numFIX = (maxGain * constMaxGain) * (1 << 6); // Q14 numFIX -= (int32_t) logApprox * diffGain; // Q14 // Calculate ratio // Shift |numFIX| as much as possible. // Ensure we avoid wrap-around in |den| as well. if (numFIX > (den >> 8) || -numFIX > (den >> 8)) // |den| is Q8. { zeros = NormW32(numFIX); } else { zeros = NormW32(den) + 8; } numFIX *= 1 << zeros; // Q(14+zeros) // Shift den so we end up in Qy1 tmp32no1 = SHIFT_W32(den, zeros - 9); // Q(zeros - 1) y32 = numFIX / tmp32no1; // in Q15 // This is to do rounding in Q14. y32 = y32 >= 0 ? (y32 + 1) >> 1 : -((-y32 + 1) >> 1); if (limiterEnable && (i < limiterIdx)) { tmp32 = ((int32_t) (int16_t) (i - 1) * (uint16_t) (kLog10_2)); // Q14 tmp32 -= limiterLvl * (1 << 14); // Q14 y32 = DivW32W16(tmp32 + 10, 20); } if (y32 > 39000) { tmp32 = (y32 >> 1) * kLog10 + 4096; // in Q27 tmp32 >>= 13; // In Q14. } else { tmp32 = y32 * kLog10 + 8192; // in Q28 tmp32 >>= 14; // In Q14. } tmp32 += 16 << 14; // in Q14 (Make sure final output is in Q16) // Calculate power if (tmp32 > 0) { intPart = (int16_t) (tmp32 >> 14); fracPart = (uint16_t) (tmp32 & 0x00003FFF); // in Q14 if ((fracPart >> 13) != 0) { tmp16 = (2 << 14) - constLinApprox; tmp32no2 = (1 << 14) - fracPart; tmp32no2 *= tmp16; tmp32no2 >>= 13; tmp32no2 = (1 << 14) - tmp32no2; } else { tmp16 = constLinApprox - (1 << 14); tmp32no2 = (fracPart * tmp16) >> 13; } fracPart = (uint16_t) tmp32no2; gainTable[i] = (1 << intPart) + SHIFT_W32(fracPart, intPart - 14); } else { gainTable[i] = 0; } } return 0; } int32_t WebRtcAgc_InitDigital(DigitalAgc *stt, int16_t agcMode) { if (agcMode == kAgcModeFixedDigital) { // start at minimum to find correct gain faster stt->capacitorSlow = 0; } else { // start out with 0 dB gain stt->capacitorSlow = 134217728; // (int32_t)(0.125f * 32768.0f * 32768.0f); } stt->capacitorFast = 0; stt->gain = 65536; stt->gatePrevious = 0; stt->agcMode = agcMode; #ifdef WEBRTC_AGC_DEBUG_DUMP stt->frameCounter = 0; #endif // initialize VADs WebRtcAgc_InitVad(&stt->vadNearend); WebRtcAgc_InitVad(&stt->vadFarend); return 0; } int32_t WebRtcAgc_AddFarendToDigital(DigitalAgc *stt, const int16_t *in_far, size_t nrSamples) { assert(stt); // VAD for far end WebRtcAgc_ProcessVad(&stt->vadFarend, in_far, nrSamples); return 0; } int32_t WebRtcAgc_ProcessDigital(DigitalAgc *stt, const int16_t *const *in_near, size_t num_bands, int16_t *const *out, uint32_t FS, int16_t lowlevelSignal) { // array for gains (one value per ms, incl start & end) int32_t gains[11]; int32_t out_tmp, tmp32; int32_t env[10]; int32_t max_nrg; int32_t cur_level; int32_t gain32, delta; int16_t logratio; int16_t lower_thr, upper_thr; int16_t zeros = 0, zeros_fast, frac = 0; int16_t decay; int16_t gate, gain_adj; int16_t k; size_t n, i, L; int16_t L2; // samples/subframe // determine number of samples per ms if (FS == 8000) { L = 8; L2 = 3; } else if (FS == 16000 || FS == 32000 || FS == 48000) { L = 16; L2 = 4; } else { return -1; } for (i = 0; i < num_bands; ++i) { if (in_near[i] != out[i]) { // Only needed if they don't already point to the same place. memcpy(out[i], in_near[i], 10 * L * sizeof(in_near[i][0])); } } // VAD for near end logratio = WebRtcAgc_ProcessVad(&stt->vadNearend, out[0], L * 10); // Account for far end VAD if (stt->vadFarend.counter > 10) { tmp32 = 3 * logratio; logratio = (int16_t) ((tmp32 - stt->vadFarend.logRatio) >> 2); } // Determine decay factor depending on VAD // upper_thr = 1.0f; // lower_thr = 0.25f; upper_thr = 1024; // Q10 lower_thr = 0; // Q10 if (logratio > upper_thr) { // decay = -2^17 / DecayTime; -> -65 decay = -65; } else if (logratio < lower_thr) { decay = 0; } else { // decay = (int16_t)(((lower_thr - logratio) // * (2^27/(DecayTime*(upper_thr-lower_thr)))) >> 10); // SUBSTITUTED: 2^27/(DecayTime*(upper_thr-lower_thr)) -> 65 tmp32 = (lower_thr - logratio) * 65; decay = (int16_t) (tmp32 >> 10); } // adjust decay factor for long silence (detected as low standard deviation) // This is only done in the adaptive modes if (stt->agcMode != kAgcModeFixedDigital) { if (stt->vadNearend.stdLongTerm < 4000) { decay = 0; } else if (stt->vadNearend.stdLongTerm < 8096) { // decay = (int16_t)(((stt->vadNearend.stdLongTerm - 4000) * decay) >> // 12); tmp32 = (stt->vadNearend.stdLongTerm - 4000) * decay; decay = (int16_t) (tmp32 >> 12); } if (lowlevelSignal != 0) { decay = 0; } } #ifdef WEBRTC_AGC_DEBUG_DUMP stt->frameCounter++; fprintf(stt->logFile, "%5.2f\t%d\t%d\t%d\t", (float)(stt->frameCounter) / 100, logratio, decay, stt->vadNearend.stdLongTerm); #endif // Find max amplitude per sub frame // iterate over sub frames for (k = 0; k < 10; k++) { // iterate over samples max_nrg = 0; for (n = 0; n < L; n++) { int32_t nrg = out[0][k * L + n] * out[0][k * L + n]; if (nrg > max_nrg) { max_nrg = nrg; } } env[k] = max_nrg; } // Calculate gain per sub frame gains[0] = stt->gain; for (k = 0; k < 10; k++) { // Fast envelope follower // decay time = -131000 / -1000 = 131 (ms) stt->capacitorFast = AGC_SCALEDIFF32(-1000, stt->capacitorFast, stt->capacitorFast); if (env[k] > stt->capacitorFast) { stt->capacitorFast = env[k]; } // Slow envelope follower if (env[k] > stt->capacitorSlow) { // increase capacitorSlow stt->capacitorSlow = AGC_SCALEDIFF32(500, (env[k] - stt->capacitorSlow), stt->capacitorSlow); } else { // decrease capacitorSlow stt->capacitorSlow = AGC_SCALEDIFF32(decay, stt->capacitorSlow, stt->capacitorSlow); } // use maximum of both capacitors as current level if (stt->capacitorFast > stt->capacitorSlow) { cur_level = stt->capacitorFast; } else { cur_level = stt->capacitorSlow; } // Translate signal level into gain, using a piecewise linear approximation // find number of leading zeros zeros = NormU32((uint32_t) cur_level); if (cur_level == 0) { zeros = 31; } tmp32 = ((uint32_t) cur_level << zeros) & 0x7FFFFFFF; frac = (int16_t) (tmp32 >> 19); // Q12. tmp32 = (stt->gainTable[zeros - 1] - stt->gainTable[zeros]) * frac; gains[k + 1] = stt->gainTable[zeros] + (tmp32 >> 12); #ifdef WEBRTC_AGC_DEBUG_DUMP if (k == 0) { fprintf(stt->logFile, "%d\t%d\t%d\t%d\t%d\n", env[0], cur_level, stt->capacitorFast, stt->capacitorSlow, zeros); } #endif } // Gate processing (lower gain during absence of speech) zeros = (zeros << 9) - (frac >> 3); // find number of leading zeros zeros_fast = NormU32((uint32_t) stt->capacitorFast); if (stt->capacitorFast == 0) { zeros_fast = 31; } tmp32 = ((uint32_t) stt->capacitorFast << zeros_fast) & 0x7FFFFFFF; zeros_fast <<= 9; zeros_fast -= (int16_t) (tmp32 >> 22); gate = 1000 + zeros_fast - zeros - stt->vadNearend.stdShortTerm; if (gate < 0) { stt->gatePrevious = 0; } else { tmp32 = stt->gatePrevious * 7; gate = (int16_t) ((gate + tmp32) >> 3); stt->gatePrevious = gate; } // gate < 0 -> no gate // gate > 2500 -> max gate if (gate > 0) { if (gate < 2500) { gain_adj = (2500 - gate) >> 5; } else { gain_adj = 0; } for (k = 0; k < 10; k++) { if ((gains[k + 1] - stt->gainTable[0]) > 8388608) { // To prevent wraparound tmp32 = (gains[k + 1] - stt->gainTable[0]) >> 8; tmp32 *= 178 + gain_adj; } else { tmp32 = (gains[k + 1] - stt->gainTable[0]) * (178 + gain_adj); tmp32 >>= 8; } gains[k + 1] = stt->gainTable[0] + tmp32; } } // Limit gain to avoid overload distortion for (k = 0; k < 10; k++) { // To prevent wrap around zeros = 10; if (gains[k + 1] > 47453132) { zeros = 16 - NormW32(gains[k + 1]); } gain32 = (gains[k + 1] >> zeros) + 1; gain32 *= gain32; // check for overflow while (AGC_MUL32((env[k] >> 12) + 1, gain32) > SHIFT_W32((int32_t) 32767, 2 * (1 - zeros + 10))) { // multiply by 253/256 ==> -0.1 dB if (gains[k + 1] > 8388607) { // Prevent wrap around gains[k + 1] = (gains[k + 1] / 256) * 253; } else { gains[k + 1] = (gains[k + 1] * 253) / 256; } gain32 = (gains[k + 1] >> zeros) + 1; gain32 *= gain32; } } // gain reductions should be done 1 ms earlier than gain increases for (k = 1; k < 10; k++) { if (gains[k] > gains[k + 1]) { gains[k] = gains[k + 1]; } } // save start gain for next frame stt->gain = gains[10]; // Apply gain // handle first sub frame separately delta = (gains[1] - gains[0]) * (1 << (4 - L2)); gain32 = gains[0] * (1 << 4); // iterate over samples for (n = 0; n < L; n++) { for (i = 0; i < num_bands; ++i) { tmp32 = out[i][n] * ((gain32 + 127) >> 7); out_tmp = tmp32 >> 16; if (out_tmp > 4095) { out[i][n] = (int16_t) 32767; } else if (out_tmp < -4096) { out[i][n] = (int16_t) -32768; } else { tmp32 = out[i][n] * (gain32 >> 4); out[i][n] = (int16_t) (tmp32 >> 16); } } // gain32 += delta; } // iterate over subframes for (k = 1; k < 10; k++) { delta = (gains[k + 1] - gains[k]) * (1 << (4 - L2)); gain32 = gains[k] * (1 << 4); // iterate over samples for (n = 0; n < L; n++) { for (i = 0; i < num_bands; ++i) { int64_t tmp64 = ((int64_t) (out[i][k * L + n])) * (gain32 >> 4); tmp64 = tmp64 >> 16; if (tmp64 > 32767) { out[i][k * L + n] = 32767; } else if (tmp64 < -32768) { out[i][k * L + n] = -32768; } else { out[i][k * L + n] = (int16_t) (tmp64); } } gain32 += delta; } } return 0; } void WebRtcAgc_InitVad(AgcVad *state) { int16_t k; state->HPstate = 0; // state of high pass filter state->logRatio = 0; // log( P(active) / P(inactive) ) // average input level (Q10) state->meanLongTerm = 15 << 10; // variance of input level (Q8) state->varianceLongTerm = 500 << 8; state->stdLongTerm = 0; // standard deviation of input level in dB // short-term average input level (Q10) state->meanShortTerm = 15 << 10; // short-term variance of input level (Q8) state->varianceShortTerm = 500 << 8; state->stdShortTerm = 0; // short-term standard deviation of input level in dB state->counter = 3; // counts updates for (k = 0; k < 8; k++) { // downsampling filter state->downState[k] = 0; } } int16_t WebRtcAgc_ProcessVad(AgcVad *state, // (i) VAD state const int16_t *in, // (i) Speech signal size_t nrSamples) // (i) number of samples { uint32_t nrg; int32_t out, tmp32, tmp32b; uint16_t tmpU16; int16_t k, subfr, tmp16; int16_t buf1[8]; int16_t buf2[4]; int16_t HPstate; int16_t zeros, dB; // process in 10 sub frames of 1 ms (to save on memory) nrg = 0; HPstate = state->HPstate; for (subfr = 0; subfr < 10; subfr++) { // downsample to 4 kHz if (nrSamples == 160) { for (k = 0; k < 8; k++) { tmp32 = (int32_t) in[2 * k] + (int32_t) in[2 * k + 1]; tmp32 >>= 1; buf1[k] = (int16_t) tmp32; } in += 16; downsampleBy2(buf1, 8, buf2, state->downState); } else { downsampleBy2(in, 8, buf2, state->downState); in += 8; } // high pass filter and compute energy for (k = 0; k < 4; k++) { out = buf2[k] + HPstate; tmp32 = 600 * out; HPstate = (int16_t) ((tmp32 >> 10) - buf2[k]); // Add 'out * out / 2**6' to 'nrg' in a non-overflowing // way. Guaranteed to work as long as 'out * out / 2**6' fits in // an int32_t. nrg += out * (out / (1 << 6)); nrg += out * (out % (1 << 6)) / (1 << 6); } } state->HPstate = HPstate; // find number of leading zeros if (!(0xFFFF0000 & nrg)) { zeros = 16; } else { zeros = 0; } if (!(0xFF000000 & (nrg << zeros))) { zeros += 8; } if (!(0xF0000000 & (nrg << zeros))) { zeros += 4; } if (!(0xC0000000 & (nrg << zeros))) { zeros += 2; } if (!(0x80000000 & (nrg << zeros))) { zeros += 1; } // energy level (range {-32..30}) (Q10) dB = (15 - zeros) * (1 << 11); // Update statistics if (state->counter < kAvgDecayTime) { // decay time = AvgDecTime * 10 ms state->counter++; } // update short-term estimate of mean energy level (Q10) tmp32 = state->meanShortTerm * 15 + dB; state->meanShortTerm = (int16_t) (tmp32 >> 4); // update short-term estimate of variance in energy level (Q8) tmp32 = (dB * dB) >> 12; tmp32 += state->varianceShortTerm * 15; state->varianceShortTerm = tmp32 / 16; // update short-term estimate of standard deviation in energy level (Q10) tmp32 = state->meanShortTerm * state->meanShortTerm; tmp32 = (state->varianceShortTerm << 12) - tmp32; state->stdShortTerm = (int16_t) fast_sqrt(tmp32); // update long-term estimate of mean energy level (Q10) tmp32 = state->meanLongTerm * state->counter + dB; state->meanLongTerm = DivW32W16ResW16(tmp32, WebRtcSpl_AddSatW16(state->counter, 1)); // update long-term estimate of variance in energy level (Q8) tmp32 = (dB * dB) >> 12; tmp32 += state->varianceLongTerm * state->counter; state->varianceLongTerm = DivW32W16(tmp32, WebRtcSpl_AddSatW16(state->counter, 1)); // update long-term estimate of standard deviation in energy level (Q10) tmp32 = state->meanLongTerm * state->meanLongTerm; tmp32 = (state->varianceLongTerm << 12) - tmp32; state->stdLongTerm = (int16_t) fast_sqrt(tmp32); // update voice activity measure (Q10) tmp16 = 3 << 12; // TODO(bjornv): (dB - state->meanLongTerm) can overflow, e.g., in // ApmTest.Process unit test. Previously the macro WEBRTC_SPL_MUL_16_16() // was used, which did an intermediate cast to (int16_t), hence losing // significant bits. This cause logRatio to max out positive, rather than // negative. This is a bug, but has very little significance. tmp32 = tmp16 * (int16_t) (dB - state->meanLongTerm); tmp32 = DivW32W16(tmp32, state->stdLongTerm); tmpU16 = (13 << 12); tmp32b = ((int32_t) (int16_t) (state->logRatio) * (uint16_t) (tmpU16)); tmp32 += tmp32b >> 10; state->logRatio = (int16_t) (tmp32 >> 6); // limit if (state->logRatio > 2048) { state->logRatio = 2048; } if (state->logRatio < -2048) { state->logRatio = -2048; } return state->logRatio; // Q10 } int WebRtcAgc_AddMic(void *state, int16_t *const *in_mic, size_t num_bands, size_t samples) { int32_t nrg, max_nrg, sample, tmp32; int32_t *ptr; uint16_t targetGainIdx, gain; size_t i; int16_t n, L, tmp16, tmp_speech[16]; LegacyAgc *stt; stt = (LegacyAgc *) state; if (stt->fs == 8000) { L = 8; if (samples != 80) { return -1; } } else { L = 16; if (samples != 160) { return -1; } } /* apply slowly varying digital gain */ if (stt->micVol > stt->maxAnalog) { /* |maxLevel| is strictly >= |micVol|, so this condition should be * satisfied here, ensuring there is no divide-by-zero. */ assert(stt->maxLevel > stt->maxAnalog); /* Q1 */ tmp16 = (int16_t) (stt->micVol - stt->maxAnalog); tmp32 = (GAIN_TBL_LEN - 1) * tmp16; tmp16 = (int16_t) (stt->maxLevel - stt->maxAnalog); targetGainIdx = tmp32 / tmp16; assert(targetGainIdx < GAIN_TBL_LEN); /* Increment through the table towards the target gain. * If micVol drops below maxAnalog, we allow the gain * to be dropped immediately. */ if (stt->gainTableIdx < targetGainIdx) { stt->gainTableIdx++; } else if (stt->gainTableIdx > targetGainIdx) { stt->gainTableIdx--; } /* Q12 */ gain = kGainTableAnalog[stt->gainTableIdx]; for (i = 0; i < samples; i++) { size_t j; for (j = 0; j < num_bands; ++j) { sample = (in_mic[j][i] * gain) >> 12; if (sample > 32767) { in_mic[j][i] = 32767; } else if (sample < -32768) { in_mic[j][i] = -32768; } else { in_mic[j][i] = (int16_t) sample; } } } } else { stt->gainTableIdx = 0; } /* compute envelope */ if (stt->inQueue > 0) { ptr = stt->env[1]; } else { ptr = stt->env[0]; } for (i = 0; i < kNumSubframes; i++) { /* iterate over samples */ max_nrg = 0; for (n = 0; n < L; n++) { nrg = in_mic[0][i * L + n] * in_mic[0][i * L + n]; if (nrg > max_nrg) { max_nrg = nrg; } } ptr[i] = max_nrg; } /* compute energy */ if (stt->inQueue > 0) { ptr = stt->Rxx16w32_array[1]; } else { ptr = stt->Rxx16w32_array[0]; } for (i = 0; i < kNumSubframes / 2; i++) { if (stt->fs == 16000) { downsampleBy2(&in_mic[0][i * 32], 32, tmp_speech, stt->filterState); } else { memcpy(tmp_speech, &in_mic[0][i * 16], 16 * sizeof(short)); } /* Compute energy in blocks of 16 samples */ ptr[i] = DotProductWithScale(tmp_speech, tmp_speech, 16, 4); } /* update queue information */ if (stt->inQueue == 0) { stt->inQueue = 1; } else { stt->inQueue = 2; } /* call VAD (use low band only) */ WebRtcAgc_ProcessVad(&stt->vadMic, in_mic[0], samples); return 0; } int WebRtcAgc_AddFarend(void *state, const int16_t *in_far, size_t samples) { LegacyAgc *stt = (LegacyAgc *) state; int err = WebRtcAgc_GetAddFarendError(state, samples); if (err != 0) return err; return WebRtcAgc_AddFarendToDigital(&stt->digitalAgc, in_far, samples); } int WebRtcAgc_GetAddFarendError(void *state, size_t samples) { LegacyAgc *stt; stt = (LegacyAgc *) state; if (stt == NULL) return -1; if (stt->fs == 8000) { if (samples != 80) return -1; } else if (stt->fs == 16000 || stt->fs == 32000 || stt->fs == 48000) { if (samples != 160) return -1; } else { return -1; } return 0; } int WebRtcAgc_VirtualMic(void *agcInst, int16_t *const *in_near, size_t num_bands, size_t samples, int32_t micLevelIn, int32_t *micLevelOut) { int32_t tmpFlt, micLevelTmp, gainIdx; uint16_t gain; size_t ii, j; LegacyAgc *stt; uint32_t nrg; size_t sampleCntr; uint32_t frameNrg = 0; uint32_t frameNrgLimit = 5500; int16_t numZeroCrossing = 0; const int16_t kZeroCrossingLowLim = 15; const int16_t kZeroCrossingHighLim = 20; stt = (LegacyAgc *) agcInst; /* * Before applying gain decide if this is a low-level signal. * The idea is that digital AGC will not adapt to low-level * signals. */ if (stt->fs != 8000) { frameNrgLimit = frameNrgLimit << 1; } frameNrg = (uint32_t) (in_near[0][0] * in_near[0][0]); for (sampleCntr = 1; sampleCntr < samples; sampleCntr++) { // increment frame energy if it is less than the limit // the correct value of the energy is not important if (frameNrg < frameNrgLimit) { nrg = (uint32_t) (in_near[0][sampleCntr] * in_near[0][sampleCntr]); frameNrg += nrg; } // Count the zero crossings numZeroCrossing += ((in_near[0][sampleCntr] ^ in_near[0][sampleCntr - 1]) < 0); } if ((frameNrg < 500) || (numZeroCrossing <= 5)) { stt->lowLevelSignal = 1; } else if (numZeroCrossing <= kZeroCrossingLowLim) { stt->lowLevelSignal = 0; } else if (frameNrg <= frameNrgLimit) { stt->lowLevelSignal = 1; } else if (numZeroCrossing >= kZeroCrossingHighLim) { stt->lowLevelSignal = 1; } else { stt->lowLevelSignal = 0; } micLevelTmp = micLevelIn << stt->scale; /* Set desired level */ gainIdx = stt->micVol; if (stt->micVol > stt->maxAnalog) { gainIdx = stt->maxAnalog; } if (micLevelTmp != stt->micRef) { /* Something has happened with the physical level, restart. */ stt->micRef = micLevelTmp; stt->micVol = 127; *micLevelOut = 127; stt->micGainIdx = 127; gainIdx = 127; } /* Pre-process the signal to emulate the microphone level. */ /* Take one step at a time in the gain table. */ if (gainIdx > 127) { gain = kGainTableVirtualMic[gainIdx - 128]; } else { gain = kSuppressionTableVirtualMic[127 - gainIdx]; } for (ii = 0; ii < samples; ii++) { tmpFlt = (in_near[0][ii] * gain) >> 10; if (tmpFlt > 32767) { tmpFlt = 32767; gainIdx--; if (gainIdx >= 127) { gain = kGainTableVirtualMic[gainIdx - 127]; } else { gain = kSuppressionTableVirtualMic[127 - gainIdx]; } } if (tmpFlt < -32768) { tmpFlt = -32768; gainIdx--; if (gainIdx >= 127) { gain = kGainTableVirtualMic[gainIdx - 127]; } else { gain = kSuppressionTableVirtualMic[127 - gainIdx]; } } in_near[0][ii] = (int16_t) tmpFlt; for (j = 1; j < num_bands; ++j) { tmpFlt = (in_near[j][ii] * gain) >> 10; if (tmpFlt > 32767) { tmpFlt = 32767; } if (tmpFlt < -32768) { tmpFlt = -32768; } in_near[j][ii] = (int16_t) tmpFlt; } } /* Set the level we (finally) used */ stt->micGainIdx = gainIdx; // *micLevelOut = stt->micGainIdx; *micLevelOut = stt->micGainIdx >> stt->scale; /* Add to Mic as if it was the output from a true microphone */ if (WebRtcAgc_AddMic(agcInst, in_near, num_bands, samples) != 0) { return -1; } return 0; } void WebRtcAgc_UpdateAgcThresholds(LegacyAgc *stt) { int16_t tmp16; #ifdef MIC_LEVEL_FEEDBACK int zeros; if (stt->micLvlSat) { /* Lower the analog target level since we have reached its maximum */ zeros = WebRtcSpl_NormW32(stt->Rxx160_LPw32); stt->targetIdxOffset = (3 * zeros - stt->targetIdx - 2) / 4; } #endif /* Set analog target level in envelope dBOv scale */ tmp16 = (DIFF_REF_TO_ANALOG * stt->compressionGaindB) + ANALOG_TARGET_LEVEL_2; tmp16 = DivW32W16ResW16((int32_t) tmp16, ANALOG_TARGET_LEVEL); stt->analogTarget = DIGITAL_REF_AT_0_COMP_GAIN + tmp16; if (stt->analogTarget < DIGITAL_REF_AT_0_COMP_GAIN) { stt->analogTarget = DIGITAL_REF_AT_0_COMP_GAIN; } if (stt->agcMode == kAgcModeFixedDigital) { /* Adjust for different parameter interpretation in FixedDigital mode */ stt->analogTarget = stt->compressionGaindB; } #ifdef MIC_LEVEL_FEEDBACK stt->analogTarget += stt->targetIdxOffset; #endif /* Since the offset between RMS and ENV is not constant, we should make this * into a * table, but for now, we'll stick with a constant, tuned for the chosen * analog * target level. */ stt->targetIdx = ANALOG_TARGET_LEVEL + OFFSET_ENV_TO_RMS; #ifdef MIC_LEVEL_FEEDBACK stt->targetIdx += stt->targetIdxOffset; #endif /* Analog adaptation limits */ /* analogTargetLevel = round((32767*10^(-targetIdx/20))^2*16/2^7) */ stt->analogTargetLevel = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx]; /* ex. -20 dBov */ stt->startUpperLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx - 1]; /* -19 dBov */ stt->startLowerLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx + 1]; /* -21 dBov */ stt->upperPrimaryLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx - 2]; /* -18 dBov */ stt->lowerPrimaryLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx + 2]; /* -22 dBov */ stt->upperSecondaryLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx - 5]; /* -15 dBov */ stt->lowerSecondaryLimit = RXX_BUFFER_LEN * kTargetLevelTable[stt->targetIdx + 5]; /* -25 dBov */ stt->upperLimit = stt->startUpperLimit; stt->lowerLimit = stt->startLowerLimit; } void WebRtcAgc_SaturationCtrl(LegacyAgc *stt, uint8_t *saturated, const int32_t *env) { int16_t i, tmpW16; /* Check if the signal is saturated */ for (i = 0; i < 10; i++) { tmpW16 = (int16_t) (env[i] >> 20); if (tmpW16 > 875) { stt->envSum += tmpW16; } } if (stt->envSum > 25000) { *saturated = 1; stt->envSum = 0; } /* stt->envSum *= 0.99; */ stt->envSum = (int16_t) ((stt->envSum * 32440) >> 15); } void WebRtcAgc_ZeroCtrl(LegacyAgc *stt, int32_t *inMicLevel, const int32_t *env) { int16_t i; int64_t tmp = 0; int32_t midVal; /* Is the input signal zero? */ for (i = 0; i < 10; i++) { tmp += env[i]; } /* Each block is allowed to have a few non-zero * samples. */ if (tmp < 500) { stt->msZero += 10; } else { stt->msZero = 0; } if (stt->muteGuardMs > 0) { stt->muteGuardMs -= 10; } if (stt->msZero > 500) { stt->msZero = 0; /* Increase microphone level only if it's less than 50% */ midVal = (stt->maxAnalog + stt->minLevel + 1) / 2; if (*inMicLevel < midVal) { /* *inMicLevel *= 1.1; */ *inMicLevel = (1126 * *inMicLevel) >> 10; /* Reduces risk of a muted mic repeatedly triggering excessive levels due * to zero signal detection. */ *inMicLevel = MIN(*inMicLevel, stt->zeroCtrlMax); stt->micVol = *inMicLevel; } #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\t\tAGC->zeroCntrl, frame %d: 500 ms under threshold," " micVol: %d\n", stt->fcount, stt->micVol); #endif stt->activeSpeech = 0; stt->Rxx16_LPw32Max = 0; /* The AGC has a tendency (due to problems with the VAD parameters), to * vastly increase the volume after a muting event. This timer prevents * upwards adaptation for a short period. */ stt->muteGuardMs = kMuteGuardTimeMs; } } void WebRtcAgc_SpeakerInactiveCtrl(LegacyAgc *stt) { /* Check if the near end speaker is inactive. * If that is the case the VAD threshold is * increased since the VAD speech model gets * more sensitive to any sound after a long * silence. */ int32_t tmp32; int16_t vadThresh; if (stt->vadMic.stdLongTerm < 2500) { stt->vadThreshold = 1500; } else { vadThresh = kNormalVadThreshold; if (stt->vadMic.stdLongTerm < 4500) { /* Scale between min and max threshold */ vadThresh += (4500 - stt->vadMic.stdLongTerm) / 2; } /* stt->vadThreshold = (31 * stt->vadThreshold + vadThresh) / 32; */ tmp32 = vadThresh + 31 * stt->vadThreshold; stt->vadThreshold = (int16_t) (tmp32 >> 5); } } void WebRtcAgc_ExpCurve(int16_t volume, int16_t *index) { // volume in Q14 // index in [0-7] /* 8 different curves */ if (volume > 5243) { if (volume > 7864) { if (volume > 12124) { *index = 7; } else { *index = 6; } } else { if (volume > 6554) { *index = 5; } else { *index = 4; } } } else { if (volume > 2621) { if (volume > 3932) { *index = 3; } else { *index = 2; } } else { if (volume > 1311) { *index = 1; } else { *index = 0; } } } } int32_t WebRtcAgc_ProcessAnalog(void *state, int32_t inMicLevel, int32_t *outMicLevel, int16_t vadLogRatio, int16_t echo, uint8_t *saturationWarning) { uint32_t tmpU32; int32_t Rxx16w32, tmp32; int32_t inMicLevelTmp, lastMicVol; int16_t i; uint8_t saturated = 0; LegacyAgc *stt; stt = (LegacyAgc *) state; inMicLevelTmp = inMicLevel << stt->scale; if (inMicLevelTmp > stt->maxAnalog) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: micLvl > maxAnalog\n", stt->fcount); #endif return -1; } else if (inMicLevelTmp < stt->minLevel) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: micLvl < minLevel\n", stt->fcount); #endif return -1; } if (stt->firstCall == 0) { int32_t tmpVol; stt->firstCall = 1; tmp32 = ((stt->maxLevel - stt->minLevel) * 51) >> 9; tmpVol = (stt->minLevel + tmp32); /* If the mic level is very low at start, increase it! */ if ((inMicLevelTmp < tmpVol) && (stt->agcMode == kAgcModeAdaptiveAnalog)) { inMicLevelTmp = tmpVol; } stt->micVol = inMicLevelTmp; } /* Set the mic level to the previous output value if there is digital input * gain */ if ((inMicLevelTmp == stt->maxAnalog) && (stt->micVol > stt->maxAnalog)) { inMicLevelTmp = stt->micVol; } /* If the mic level was manually changed to a very low value raise it! */ if ((inMicLevelTmp != stt->micVol) && (inMicLevelTmp < stt->minOutput)) { tmp32 = ((stt->maxLevel - stt->minLevel) * 51) >> 9; inMicLevelTmp = (stt->minLevel + tmp32); stt->micVol = inMicLevelTmp; #ifdef MIC_LEVEL_FEEDBACK // stt->numBlocksMicLvlSat = 0; #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: micLvl < minLevel by manual" " decrease, raise vol\n", stt->fcount); #endif } if (inMicLevelTmp != stt->micVol) { if (inMicLevel == stt->lastInMicLevel) { // We requested a volume adjustment, but it didn't occur. This is // probably due to a coarse quantization of the volume slider. // Restore the requested value to prevent getting stuck. inMicLevelTmp = stt->micVol; } else { // As long as the value changed, update to match. stt->micVol = inMicLevelTmp; } } if (inMicLevelTmp > stt->maxLevel) { // Always allow the user to raise the volume above the maxLevel. stt->maxLevel = inMicLevelTmp; } // Store last value here, after we've taken care of manual updates etc. stt->lastInMicLevel = inMicLevel; lastMicVol = stt->micVol; /* Checks if the signal is saturated. Also a check if individual samples * are larger than 12000 is done. If they are the counter for increasing * the volume level is set to -100ms */ WebRtcAgc_SaturationCtrl(stt, &saturated, stt->env[0]); /* The AGC is always allowed to lower the level if the signal is saturated */ if (saturated == 1) { /* Lower the recording level * Rxx160_LP is adjusted down because it is so slow it could * cause the AGC to make wrong decisions. */ /* stt->Rxx160_LPw32 *= 0.875; */ stt->Rxx160_LPw32 = (stt->Rxx160_LPw32 / 8) * 7; stt->zeroCtrlMax = stt->micVol; /* stt->micVol *= 0.903; */ tmp32 = inMicLevelTmp - stt->minLevel; tmpU32 = ((uint32_t) ((uint32_t) (29591) * (uint32_t) (tmp32))); stt->micVol = (tmpU32 >> 15) + stt->minLevel; if (stt->micVol > lastMicVol - 2) { stt->micVol = lastMicVol - 2; } inMicLevelTmp = stt->micVol; #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: saturated, micVol = %d\n", stt->fcount, stt->micVol); #endif if (stt->micVol < stt->minOutput) { *saturationWarning = 1; } /* Reset counter for decrease of volume level to avoid * decreasing too much. The saturation control can still * lower the level if needed. */ stt->msTooHigh = -100; /* Enable the control mechanism to ensure that our measure, * Rxx160_LP, is in the correct range. This must be done since * the measure is very slow. */ stt->activeSpeech = 0; stt->Rxx16_LPw32Max = 0; /* Reset to initial values */ stt->msecSpeechInnerChange = kMsecSpeechInner; stt->msecSpeechOuterChange = kMsecSpeechOuter; stt->changeToSlowMode = 0; stt->muteGuardMs = 0; stt->upperLimit = stt->startUpperLimit; stt->lowerLimit = stt->startLowerLimit; #ifdef MIC_LEVEL_FEEDBACK // stt->numBlocksMicLvlSat = 0; #endif } /* Check if the input speech is zero. If so the mic volume * is increased. On some computers the input is zero up as high * level as 17% */ WebRtcAgc_ZeroCtrl(stt, &inMicLevelTmp, stt->env[0]); /* Check if the near end speaker is inactive. * If that is the case the VAD threshold is * increased since the VAD speech model gets * more sensitive to any sound after a long * silence. */ WebRtcAgc_SpeakerInactiveCtrl(stt); for (i = 0; i < 5; i++) { /* Computed on blocks of 16 samples */ Rxx16w32 = stt->Rxx16w32_array[0][i]; /* Rxx160w32 in Q(-7) */ tmp32 = (Rxx16w32 - stt->Rxx16_vectorw32[stt->Rxx16pos]) >> 3; stt->Rxx160w32 = stt->Rxx160w32 + tmp32; stt->Rxx16_vectorw32[stt->Rxx16pos] = Rxx16w32; /* Circular buffer */ stt->Rxx16pos++; if (stt->Rxx16pos == RXX_BUFFER_LEN) { stt->Rxx16pos = 0; } /* Rxx16_LPw32 in Q(-4) */ tmp32 = (Rxx16w32 - stt->Rxx16_LPw32) >> kAlphaShortTerm; stt->Rxx16_LPw32 = (stt->Rxx16_LPw32) + tmp32; if (vadLogRatio > stt->vadThreshold) { /* Speech detected! */ /* Check if Rxx160_LP is in the correct range. If * it is too high/low then we set it to the maximum of * Rxx16_LPw32 during the first 200ms of speech. */ if (stt->activeSpeech < 250) { stt->activeSpeech += 2; if (stt->Rxx16_LPw32 > stt->Rxx16_LPw32Max) { stt->Rxx16_LPw32Max = stt->Rxx16_LPw32; } } else if (stt->activeSpeech == 250) { stt->activeSpeech += 2; tmp32 = stt->Rxx16_LPw32Max >> 3; stt->Rxx160_LPw32 = tmp32 * RXX_BUFFER_LEN; } tmp32 = (stt->Rxx160w32 - stt->Rxx160_LPw32) >> kAlphaLongTerm; stt->Rxx160_LPw32 = stt->Rxx160_LPw32 + tmp32; if (stt->Rxx160_LPw32 > stt->upperSecondaryLimit) { stt->msTooHigh += 2; stt->msTooLow = 0; stt->changeToSlowMode = 0; if (stt->msTooHigh > stt->msecSpeechOuterChange) { stt->msTooHigh = 0; /* Lower the recording level */ /* Multiply by 0.828125 which corresponds to decreasing ~0.8dB */ tmp32 = stt->Rxx160_LPw32 >> 6; stt->Rxx160_LPw32 = tmp32 * 53; /* Reduce the max gain to avoid excessive oscillation * (but never drop below the maximum analog level). */ stt->maxLevel = (15 * stt->maxLevel + stt->micVol) / 16; stt->maxLevel = MAX(stt->maxLevel, stt->maxAnalog); stt->zeroCtrlMax = stt->micVol; /* 0.95 in Q15 */ tmp32 = inMicLevelTmp - stt->minLevel; tmpU32 = ((uint32_t) ((uint32_t) (31130) * (uint32_t) (tmp32))); stt->micVol = (tmpU32 >> 15) + stt->minLevel; if (stt->micVol > lastMicVol - 1) { stt->micVol = lastMicVol - 1; } inMicLevelTmp = stt->micVol; /* Enable the control mechanism to ensure that our measure, * Rxx160_LP, is in the correct range. */ stt->activeSpeech = 0; stt->Rxx16_LPw32Max = 0; #ifdef MIC_LEVEL_FEEDBACK // stt->numBlocksMicLvlSat = 0; #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: measure >" " 2ndUpperLim, micVol = %d, maxLevel = %d\n", stt->fcount, stt->micVol, stt->maxLevel); #endif } } else if (stt->Rxx160_LPw32 > stt->upperLimit) { stt->msTooHigh += 2; stt->msTooLow = 0; stt->changeToSlowMode = 0; if (stt->msTooHigh > stt->msecSpeechInnerChange) { /* Lower the recording level */ stt->msTooHigh = 0; /* Multiply by 0.828125 which corresponds to decreasing ~0.8dB */ stt->Rxx160_LPw32 = (stt->Rxx160_LPw32 / 64) * 53; /* Reduce the max gain to avoid excessive oscillation * (but never drop below the maximum analog level). */ stt->maxLevel = (15 * stt->maxLevel + stt->micVol) / 16; stt->maxLevel = MAX(stt->maxLevel, stt->maxAnalog); stt->zeroCtrlMax = stt->micVol; /* 0.965 in Q15 */ //tmp32 = inMicLevelTmp - stt->minLevel; tmpU32 = ((uint32_t) ((uint32_t) (31621) * (uint32_t) ((inMicLevelTmp - stt->minLevel)))); stt->micVol = (tmpU32 >> 15) + stt->minLevel; if (stt->micVol > lastMicVol - 1) { stt->micVol = lastMicVol - 1; } inMicLevelTmp = stt->micVol; #ifdef MIC_LEVEL_FEEDBACK // stt->numBlocksMicLvlSat = 0; #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: measure >" " UpperLim, micVol = %d, maxLevel = %d\n", stt->fcount, stt->micVol, stt->maxLevel); #endif } } else if (stt->Rxx160_LPw32 < stt->lowerSecondaryLimit) { stt->msTooHigh = 0; stt->changeToSlowMode = 0; stt->msTooLow += 2; if (stt->msTooLow > stt->msecSpeechOuterChange) { /* Raise the recording level */ int16_t index, weightFIX; int16_t volNormFIX = 16384; // =1 in Q14. stt->msTooLow = 0; /* Normalize the volume level */ tmp32 = (inMicLevelTmp - stt->minLevel) << 14; if (stt->maxInit != stt->minLevel) { volNormFIX = tmp32 / (stt->maxInit - stt->minLevel); } /* Find correct curve */ WebRtcAgc_ExpCurve(volNormFIX, &index); /* Compute weighting factor for the volume increase, 32^(-2*X)/2+1.05 */ weightFIX = kOffset1[index] - (int16_t) ((kSlope1[index] * volNormFIX) >> 13); /* stt->Rxx160_LPw32 *= 1.047 [~0.2 dB]; */ stt->Rxx160_LPw32 = (stt->Rxx160_LPw32 / 64) * 67; //tmp32 = inMicLevelTmp - stt->minLevel; tmpU32 = ((uint32_t) weightFIX * (uint32_t) (inMicLevelTmp - stt->minLevel)); stt->micVol = (tmpU32 >> 14) + stt->minLevel; if (stt->micVol < lastMicVol + 2) { stt->micVol = lastMicVol + 2; } inMicLevelTmp = stt->micVol; #ifdef MIC_LEVEL_FEEDBACK /* Count ms in level saturation */ // if (stt->micVol > stt->maxAnalog) { if (stt->micVol > 150) { /* mic level is saturated */ stt->numBlocksMicLvlSat++; fprintf(stderr, "Sat mic Level: %d\n", stt->numBlocksMicLvlSat); } #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: measure <" " 2ndLowerLim, micVol = %d\n", stt->fcount, stt->micVol); #endif } } else if (stt->Rxx160_LPw32 < stt->lowerLimit) { stt->msTooHigh = 0; stt->changeToSlowMode = 0; stt->msTooLow += 2; if (stt->msTooLow > stt->msecSpeechInnerChange) { /* Raise the recording level */ int16_t index, weightFIX; int16_t volNormFIX = 16384; // =1 in Q14. stt->msTooLow = 0; /* Normalize the volume level */ tmp32 = (inMicLevelTmp - stt->minLevel) << 14; if (stt->maxInit != stt->minLevel) { volNormFIX = tmp32 / (stt->maxInit - stt->minLevel); } /* Find correct curve */ WebRtcAgc_ExpCurve(volNormFIX, &index); /* Compute weighting factor for the volume increase, (3.^(-2.*X))/8+1 */ weightFIX = kOffset2[index] - (int16_t) ((kSlope2[index] * volNormFIX) >> 13); /* stt->Rxx160_LPw32 *= 1.047 [~0.2 dB]; */ stt->Rxx160_LPw32 = (stt->Rxx160_LPw32 / 64) * 67; // tmp32 = inMicLevelTmp - stt->minLevel; tmpU32 = ((uint32_t) weightFIX * (uint32_t) (inMicLevelTmp - stt->minLevel)); stt->micVol = (tmpU32 >> 14) + stt->minLevel; if (stt->micVol < lastMicVol + 1) { stt->micVol = lastMicVol + 1; } inMicLevelTmp = stt->micVol; #ifdef MIC_LEVEL_FEEDBACK /* Count ms in level saturation */ // if (stt->micVol > stt->maxAnalog) { if (stt->micVol > 150) { /* mic level is saturated */ stt->numBlocksMicLvlSat++; fprintf(stderr, "Sat mic Level: %d\n", stt->numBlocksMicLvlSat); } #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\tAGC->ProcessAnalog, frame %d: measure < LowerLim, micVol " "= %d\n", stt->fcount, stt->micVol); #endif } } else { /* The signal is inside the desired range which is: * lowerLimit < Rxx160_LP/640 < upperLimit */ if (stt->changeToSlowMode > 4000) { stt->msecSpeechInnerChange = 1000; stt->msecSpeechOuterChange = 500; stt->upperLimit = stt->upperPrimaryLimit; stt->lowerLimit = stt->lowerPrimaryLimit; } else { stt->changeToSlowMode += 2; // in milliseconds } stt->msTooLow = 0; stt->msTooHigh = 0; stt->micVol = inMicLevelTmp; } #ifdef MIC_LEVEL_FEEDBACK if (stt->numBlocksMicLvlSat > NUM_BLOCKS_IN_SAT_BEFORE_CHANGE_TARGET) { stt->micLvlSat = 1; fprintf(stderr, "target before = %d (%d)\n", stt->analogTargetLevel, stt->targetIdx); WebRtcAgc_UpdateAgcThresholds(stt); WebRtcAgc_CalculateGainTable( &(stt->digitalAgc.gainTable[0]), stt->compressionGaindB, stt->targetLevelDbfs, stt->limiterEnable, stt->analogTarget); stt->numBlocksMicLvlSat = 0; stt->micLvlSat = 0; fprintf(stderr, "target offset = %d\n", stt->targetIdxOffset); fprintf(stderr, "target after = %d (%d)\n", stt->analogTargetLevel, stt->targetIdx); } #endif } } /* Ensure gain is not increased in presence of echo or after a mute event * (but allow the zeroCtrl() increase on the frame of a mute detection). */ if (echo == 1 || (stt->muteGuardMs > 0 && stt->muteGuardMs < kMuteGuardTimeMs)) { if (stt->micVol > lastMicVol) { stt->micVol = lastMicVol; } } /* limit the gain */ if (stt->micVol > stt->maxLevel) { stt->micVol = stt->maxLevel; } else if (stt->micVol < stt->minOutput) { stt->micVol = stt->minOutput; } *outMicLevel = MIN(stt->micVol, stt->maxAnalog) >> stt->scale; return 0; } int WebRtcAgc_Process(void *agcInst, const int16_t *const *in_near, size_t num_bands, size_t samples, int16_t *const *out, int32_t inMicLevel, int32_t *outMicLevel, int16_t echo, uint8_t *saturationWarning) { LegacyAgc *stt; stt = (LegacyAgc *) agcInst; // if (stt == NULL) { return -1; } // if (stt->fs == 8000) { if (samples != 80) { return -1; } } else if (stt->fs == 16000 || stt->fs == 32000 || stt->fs == 48000) { if (samples != 160) { return -1; } } else { return -1; } *saturationWarning = 0; // TODO(minyue): PUT IN RANGE CHECKING FOR INPUT LEVELS *outMicLevel = inMicLevel; #ifdef WEBRTC_AGC_DEBUG_DUMP stt->fcount++; #endif if (WebRtcAgc_ProcessDigital(&stt->digitalAgc, in_near, num_bands, out, stt->fs, stt->lowLevelSignal) == -1) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "AGC->Process, frame %d: Error from DigAGC\n\n", stt->fcount); #endif return -1; } if (stt->agcMode < kAgcModeFixedDigital && (stt->lowLevelSignal == 0 || stt->agcMode != kAgcModeAdaptiveDigital)) { if (WebRtcAgc_ProcessAnalog(agcInst, inMicLevel, outMicLevel, stt->vadMic.logRatio, echo, saturationWarning) == -1) { return -1; } } #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->agcLog, "%5d\t%d\t%d\t%d\t%d\n", stt->fcount, inMicLevel, *outMicLevel, stt->maxLevel, stt->micVol); #endif /* update queue */ if (stt->inQueue > 1) { memcpy(stt->env[0], stt->env[1], 10 * sizeof(int32_t)); memcpy(stt->Rxx16w32_array[0], stt->Rxx16w32_array[1], 5 * sizeof(int32_t)); } if (stt->inQueue > 0) { stt->inQueue--; } return 0; } int WebRtcAgc_set_config(void *agcInst, WebRtcAgcConfig agcConfig) { LegacyAgc *stt; stt = (LegacyAgc *) agcInst; if (stt == NULL) { return -1; } if (stt->initFlag != kInitCheck) { stt->lastError = AGC_UNINITIALIZED_ERROR; return -1; } if (agcConfig.limiterEnable != kAgcFalse && agcConfig.limiterEnable != kAgcTrue) { stt->lastError = AGC_BAD_PARAMETER_ERROR; return -1; } stt->limiterEnable = agcConfig.limiterEnable; stt->compressionGaindB = agcConfig.compressionGaindB; if ((agcConfig.targetLevelDbfs < 0) || (agcConfig.targetLevelDbfs > 31)) { stt->lastError = AGC_BAD_PARAMETER_ERROR; return -1; } stt->targetLevelDbfs = agcConfig.targetLevelDbfs; if (stt->agcMode == kAgcModeFixedDigital) { /* Adjust for different parameter interpretation in FixedDigital mode */ stt->compressionGaindB += agcConfig.targetLevelDbfs; } /* Update threshold levels for analog adaptation */ WebRtcAgc_UpdateAgcThresholds(stt); /* Recalculate gain table */ if (WebRtcAgc_CalculateGainTable( &(stt->digitalAgc.gainTable[0]), stt->compressionGaindB, stt->targetLevelDbfs, stt->limiterEnable, stt->analogTarget) == -1) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "AGC->set_config, frame %d: Error from calcGainTable\n\n", stt->fcount); #endif return -1; } /* Store the config in a WebRtcAgcConfig */ stt->usedConfig.compressionGaindB = agcConfig.compressionGaindB; stt->usedConfig.limiterEnable = agcConfig.limiterEnable; stt->usedConfig.targetLevelDbfs = agcConfig.targetLevelDbfs; return 0; } int WebRtcAgc_get_config(void *agcInst, WebRtcAgcConfig *config) { LegacyAgc *stt; stt = (LegacyAgc *) agcInst; if (stt == NULL) { return -1; } if (config == NULL) { stt->lastError = AGC_NULL_POINTER_ERROR; return -1; } if (stt->initFlag != kInitCheck) { stt->lastError = AGC_UNINITIALIZED_ERROR; return -1; } config->limiterEnable = stt->usedConfig.limiterEnable; config->targetLevelDbfs = stt->usedConfig.targetLevelDbfs; config->compressionGaindB = stt->usedConfig.compressionGaindB; return 0; } void *WebRtcAgc_Create() { LegacyAgc *stt = webrtc_malloc(sizeof(LegacyAgc)); #ifdef WEBRTC_AGC_DEBUG_DUMP stt->fpt = fopen("./agc_test_log.txt", "wt"); stt->agcLog = fopen("./agc_debug_log.txt", "wt"); stt->digitalAgc.logFile = fopen("./agc_log.txt", "wt"); #endif stt->initFlag = 0; stt->lastError = 0; return stt; } void WebRtcAgc_Free(void *state) { LegacyAgc *stt; stt = (LegacyAgc *) state; #ifdef WEBRTC_AGC_DEBUG_DUMP fclose(stt->fpt); fclose(stt->agcLog); fclose(stt->digitalAgc.logFile); #endif webrtc_free(stt); } /* minLevel - Minimum volume level * maxLevel - Maximum volume level */ int WebRtcAgc_Init(void *agcInst, int32_t minLevel, int32_t maxLevel, int16_t agcMode, uint32_t fs) { int32_t max_add, tmp32; int16_t i; int tmpNorm; LegacyAgc *stt; /* typecast state pointer */ stt = (LegacyAgc *) agcInst; if (WebRtcAgc_InitDigital(&stt->digitalAgc, agcMode) != 0) { stt->lastError = AGC_UNINITIALIZED_ERROR; return -1; } /* Analog AGC variables */ stt->envSum = 0; /* mode = 0 - Only saturation protection * 1 - Analog Automatic Gain Control [-targetLevelDbfs (default -3 * dBOv)] * 2 - Digital Automatic Gain Control [-targetLevelDbfs (default -3 * dBOv)] * 3 - Fixed Digital Gain [compressionGaindB (default 8 dB)] */ #ifdef WEBRTC_AGC_DEBUG_DUMP stt->fcount = 0; fprintf(stt->fpt, "AGC->Init\n"); #endif if (agcMode < kAgcModeUnchanged || agcMode > kAgcModeFixedDigital) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "AGC->Init: error, incorrect mode\n\n"); #endif return -1; } stt->agcMode = agcMode; stt->fs = fs; /* initialize input VAD */ WebRtcAgc_InitVad(&stt->vadMic); /* If the volume range is smaller than 0-256 then * the levels are shifted up to Q8-domain */ tmpNorm = NormU32((uint32_t) maxLevel); stt->scale = tmpNorm - 23; if (stt->scale < 0) { stt->scale = 0; } // TODO(bjornv): Investigate if we really need to scale up a small range now // when we have // a guard against zero-increments. For now, we do not support scale up (scale // = 0). stt->scale = 0; maxLevel <<= stt->scale; minLevel <<= stt->scale; /* Make minLevel and maxLevel static in AdaptiveDigital */ if (stt->agcMode == kAgcModeAdaptiveDigital) { minLevel = 0; maxLevel = 255; stt->scale = 0; } /* The maximum supplemental volume range is based on a vague idea * of how much lower the gain will be than the real analog gain. */ max_add = (maxLevel - minLevel) / 4; /* Minimum/maximum volume level that can be set */ stt->minLevel = minLevel; stt->maxAnalog = maxLevel; stt->maxLevel = maxLevel + max_add; stt->maxInit = stt->maxLevel; stt->zeroCtrlMax = stt->maxAnalog; stt->lastInMicLevel = 0; /* Initialize micVol parameter */ stt->micVol = stt->maxAnalog; if (stt->agcMode == kAgcModeAdaptiveDigital) { stt->micVol = 127; /* Mid-point of mic level */ } stt->micRef = stt->micVol; stt->micGainIdx = 127; #ifdef MIC_LEVEL_FEEDBACK stt->numBlocksMicLvlSat = 0; stt->micLvlSat = 0; #endif #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "AGC->Init: minLevel = %d, maxAnalog = %d, maxLevel = %d\n", stt->minLevel, stt->maxAnalog, stt->maxLevel); #endif /* Minimum output volume is 4% higher than the available lowest volume level */ tmp32 = ((stt->maxLevel - stt->minLevel) * 10) >> 8; stt->minOutput = (stt->minLevel + tmp32); stt->msTooLow = 0; stt->msTooHigh = 0; stt->changeToSlowMode = 0; stt->firstCall = 0; stt->msZero = 0; stt->muteGuardMs = 0; stt->gainTableIdx = 0; stt->msecSpeechInnerChange = kMsecSpeechInner; stt->msecSpeechOuterChange = kMsecSpeechOuter; stt->activeSpeech = 0; stt->Rxx16_LPw32Max = 0; stt->vadThreshold = kNormalVadThreshold; stt->inActive = 0; for (i = 0; i < RXX_BUFFER_LEN; i++) { stt->Rxx16_vectorw32[i] = (int32_t) 1000; /* -54dBm0 */ } stt->Rxx160w32 = 125 * RXX_BUFFER_LEN; /* (stt->Rxx16_vectorw32[0]>>3) = 125 */ stt->Rxx16pos = 0; stt->Rxx16_LPw32 = (int32_t) 16284; /* Q(-4) */ for (i = 0; i < 5; i++) { stt->Rxx16w32_array[0][i] = 0; } for (i = 0; i < 10; i++) { stt->env[0][i] = 0; stt->env[1][i] = 0; } stt->inQueue = 0; #ifdef MIC_LEVEL_FEEDBACK stt->targetIdxOffset = 0; #endif memset(stt->filterState, 0, 8 * sizeof(int32_t)); stt->initFlag = kInitCheck; // Default config settings. stt->defaultConfig.limiterEnable = kAgcTrue; stt->defaultConfig.targetLevelDbfs = AGC_DEFAULT_TARGET_LEVEL; stt->defaultConfig.compressionGaindB = AGC_DEFAULT_COMP_GAIN; if (WebRtcAgc_set_config(stt, stt->defaultConfig) == -1) { stt->lastError = AGC_UNSPECIFIED_ERROR; return -1; } stt->Rxx160_LPw32 = stt->analogTargetLevel; // Initialize rms value stt->lowLevelSignal = 0; /* Only positive values are allowed that are not too large */ if ((minLevel >= maxLevel) || (maxLevel & 0xFC000000)) { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "minLevel, maxLevel value(s) are invalid\n\n"); #endif return -1; } else { #ifdef WEBRTC_AGC_DEBUG_DUMP fprintf(stt->fpt, "\n"); #endif return 0; } }