| /* |
| * Copyright (c) 2013 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. |
| */ |
| |
| #include "modules/audio_processing/aecm/aecm_core.h" |
| |
| #include "modules/audio_processing/aecm/echo_control_mobile.h" |
| #include "modules/audio_processing/utility/delay_estimator_wrapper.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/numerics/safe_conversions.h" |
| |
| static const ALIGN8_BEG int16_t WebRtcAecm_kSqrtHanning[] ALIGN8_END = { |
| 0, 399, 798, 1196, 1594, 1990, 2386, 2780, 3172, 3562, 3951, |
| 4337, 4720, 5101, 5478, 5853, 6224, 6591, 6954, 7313, 7668, 8019, |
| 8364, 8705, 9040, 9370, 9695, 10013, 10326, 10633, 10933, 11227, 11514, |
| 11795, 12068, 12335, 12594, 12845, 13089, 13325, 13553, 13773, 13985, 14189, |
| 14384, 14571, 14749, 14918, 15079, 15231, 15373, 15506, 15631, 15746, 15851, |
| 15947, 16034, 16111, 16179, 16237, 16286, 16325, 16354, 16373, 16384}; |
| |
| static const int16_t kNoiseEstQDomain = 15; |
| static const int16_t kNoiseEstIncCount = 5; |
| |
| static int16_t coefTable[] = { |
| 0, 4, 256, 260, 128, 132, 384, 388, 64, 68, 320, 324, 192, 196, 448, |
| 452, 32, 36, 288, 292, 160, 164, 416, 420, 96, 100, 352, 356, 224, 228, |
| 480, 484, 16, 20, 272, 276, 144, 148, 400, 404, 80, 84, 336, 340, 208, |
| 212, 464, 468, 48, 52, 304, 308, 176, 180, 432, 436, 112, 116, 368, 372, |
| 240, 244, 496, 500, 8, 12, 264, 268, 136, 140, 392, 396, 72, 76, 328, |
| 332, 200, 204, 456, 460, 40, 44, 296, 300, 168, 172, 424, 428, 104, 108, |
| 360, 364, 232, 236, 488, 492, 24, 28, 280, 284, 152, 156, 408, 412, 88, |
| 92, 344, 348, 216, 220, 472, 476, 56, 60, 312, 316, 184, 188, 440, 444, |
| 120, 124, 376, 380, 248, 252, 504, 508}; |
| |
| static int16_t coefTable_ifft[] = { |
| 0, 512, 256, 508, 128, 252, 384, 380, 64, 124, 320, 444, 192, 188, 448, |
| 316, 32, 60, 288, 476, 160, 220, 416, 348, 96, 92, 352, 412, 224, 156, |
| 480, 284, 16, 28, 272, 492, 144, 236, 400, 364, 80, 108, 336, 428, 208, |
| 172, 464, 300, 48, 44, 304, 460, 176, 204, 432, 332, 112, 76, 368, 396, |
| 240, 140, 496, 268, 8, 12, 264, 500, 136, 244, 392, 372, 72, 116, 328, |
| 436, 200, 180, 456, 308, 40, 52, 296, 468, 168, 212, 424, 340, 104, 84, |
| 360, 404, 232, 148, 488, 276, 24, 20, 280, 484, 152, 228, 408, 356, 88, |
| 100, 344, 420, 216, 164, 472, 292, 56, 36, 312, 452, 184, 196, 440, 324, |
| 120, 68, 376, 388, 248, 132, 504, 260}; |
| |
| static void ComfortNoise(AecmCore* aecm, |
| const uint16_t* dfa, |
| ComplexInt16* out, |
| const int16_t* lambda); |
| |
| static void WindowAndFFT(AecmCore* aecm, |
| int16_t* fft, |
| const int16_t* time_signal, |
| ComplexInt16* freq_signal, |
| int time_signal_scaling) { |
| int i, j; |
| int32_t tmp1, tmp2, tmp3, tmp4; |
| int16_t* pfrfi; |
| ComplexInt16* pfreq_signal; |
| int16_t f_coef, s_coef; |
| int32_t load_ptr, store_ptr1, store_ptr2, shift, shift1; |
| int32_t hann, hann1, coefs; |
| |
| memset(fft, 0, sizeof(int16_t) * PART_LEN4); |
| |
| // FFT of signal |
| __asm __volatile( |
| ".set push \n\t" |
| ".set noreorder \n\t" |
| "addiu %[shift], %[time_signal_scaling], -14 \n\t" |
| "addiu %[i], $zero, 64 \n\t" |
| "addiu %[load_ptr], %[time_signal], 0 \n\t" |
| "addiu %[hann], %[hanning], 0 \n\t" |
| "addiu %[hann1], %[hanning], 128 \n\t" |
| "addiu %[coefs], %[coefTable], 0 \n\t" |
| "bltz %[shift], 2f \n\t" |
| " negu %[shift1], %[shift] \n\t" |
| "1: " |
| "\n\t" |
| "lh %[tmp1], 0(%[load_ptr]) \n\t" |
| "lh %[tmp2], 0(%[hann]) \n\t" |
| "lh %[tmp3], 128(%[load_ptr]) \n\t" |
| "lh %[tmp4], 0(%[hann1]) \n\t" |
| "addiu %[i], %[i], -1 \n\t" |
| "mul %[tmp1], %[tmp1], %[tmp2] \n\t" |
| "mul %[tmp3], %[tmp3], %[tmp4] \n\t" |
| "lh %[f_coef], 0(%[coefs]) \n\t" |
| "lh %[s_coef], 2(%[coefs]) \n\t" |
| "addiu %[load_ptr], %[load_ptr], 2 \n\t" |
| "addiu %[hann], %[hann], 2 \n\t" |
| "addiu %[hann1], %[hann1], -2 \n\t" |
| "addu %[store_ptr1], %[fft], %[f_coef] \n\t" |
| "addu %[store_ptr2], %[fft], %[s_coef] \n\t" |
| "sllv %[tmp1], %[tmp1], %[shift] \n\t" |
| "sllv %[tmp3], %[tmp3], %[shift] \n\t" |
| "sh %[tmp1], 0(%[store_ptr1]) \n\t" |
| "sh %[tmp3], 0(%[store_ptr2]) \n\t" |
| "bgtz %[i], 1b \n\t" |
| " addiu %[coefs], %[coefs], 4 \n\t" |
| "b 3f \n\t" |
| " nop \n\t" |
| "2: " |
| "\n\t" |
| "lh %[tmp1], 0(%[load_ptr]) \n\t" |
| "lh %[tmp2], 0(%[hann]) \n\t" |
| "lh %[tmp3], 128(%[load_ptr]) \n\t" |
| "lh %[tmp4], 0(%[hann1]) \n\t" |
| "addiu %[i], %[i], -1 \n\t" |
| "mul %[tmp1], %[tmp1], %[tmp2] \n\t" |
| "mul %[tmp3], %[tmp3], %[tmp4] \n\t" |
| "lh %[f_coef], 0(%[coefs]) \n\t" |
| "lh %[s_coef], 2(%[coefs]) \n\t" |
| "addiu %[load_ptr], %[load_ptr], 2 \n\t" |
| "addiu %[hann], %[hann], 2 \n\t" |
| "addiu %[hann1], %[hann1], -2 \n\t" |
| "addu %[store_ptr1], %[fft], %[f_coef] \n\t" |
| "addu %[store_ptr2], %[fft], %[s_coef] \n\t" |
| "srav %[tmp1], %[tmp1], %[shift1] \n\t" |
| "srav %[tmp3], %[tmp3], %[shift1] \n\t" |
| "sh %[tmp1], 0(%[store_ptr1]) \n\t" |
| "sh %[tmp3], 0(%[store_ptr2]) \n\t" |
| "bgtz %[i], 2b \n\t" |
| " addiu %[coefs], %[coefs], 4 \n\t" |
| "3: " |
| "\n\t" |
| ".set pop \n\t" |
| : [load_ptr] "=&r"(load_ptr), [shift] "=&r"(shift), [hann] "=&r"(hann), |
| [hann1] "=&r"(hann1), [shift1] "=&r"(shift1), [coefs] "=&r"(coefs), |
| [tmp1] "=&r"(tmp1), [tmp2] "=&r"(tmp2), [tmp3] "=&r"(tmp3), |
| [tmp4] "=&r"(tmp4), [i] "=&r"(i), [f_coef] "=&r"(f_coef), |
| [s_coef] "=&r"(s_coef), [store_ptr1] "=&r"(store_ptr1), |
| [store_ptr2] "=&r"(store_ptr2) |
| : [time_signal] "r"(time_signal), [coefTable] "r"(coefTable), |
| [time_signal_scaling] "r"(time_signal_scaling), |
| [hanning] "r"(WebRtcAecm_kSqrtHanning), [fft] "r"(fft) |
| : "memory", "hi", "lo"); |
| |
| WebRtcSpl_ComplexFFT(fft, PART_LEN_SHIFT, 1); |
| pfrfi = fft; |
| pfreq_signal = freq_signal; |
| |
| __asm __volatile( |
| ".set push " |
| "\n\t" |
| ".set noreorder " |
| "\n\t" |
| "addiu %[j], $zero, 128 " |
| "\n\t" |
| "1: " |
| "\n\t" |
| "lh %[tmp1], 0(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp2], 2(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp3], 4(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp4], 6(%[pfrfi]) " |
| "\n\t" |
| "subu %[tmp2], $zero, %[tmp2] " |
| "\n\t" |
| "sh %[tmp1], 0(%[pfreq_signal]) " |
| "\n\t" |
| "sh %[tmp2], 2(%[pfreq_signal]) " |
| "\n\t" |
| "subu %[tmp4], $zero, %[tmp4] " |
| "\n\t" |
| "sh %[tmp3], 4(%[pfreq_signal]) " |
| "\n\t" |
| "sh %[tmp4], 6(%[pfreq_signal]) " |
| "\n\t" |
| "lh %[tmp1], 8(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp2], 10(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp3], 12(%[pfrfi]) " |
| "\n\t" |
| "lh %[tmp4], 14(%[pfrfi]) " |
| "\n\t" |
| "addiu %[j], %[j], -8 " |
| "\n\t" |
| "subu %[tmp2], $zero, %[tmp2] " |
| "\n\t" |
| "sh %[tmp1], 8(%[pfreq_signal]) " |
| "\n\t" |
| "sh %[tmp2], 10(%[pfreq_signal]) " |
| "\n\t" |
| "subu %[tmp4], $zero, %[tmp4] " |
| "\n\t" |
| "sh %[tmp3], 12(%[pfreq_signal]) " |
| "\n\t" |
| "sh %[tmp4], 14(%[pfreq_signal]) " |
| "\n\t" |
| "addiu %[pfreq_signal], %[pfreq_signal], 16 " |
| "\n\t" |
| "bgtz %[j], 1b " |
| "\n\t" |
| " addiu %[pfrfi], %[pfrfi], 16 " |
| "\n\t" |
| ".set pop " |
| "\n\t" |
| : [tmp1] "=&r"(tmp1), [tmp2] "=&r"(tmp2), [tmp3] "=&r"(tmp3), |
| [j] "=&r"(j), [pfrfi] "+r"(pfrfi), [pfreq_signal] "+r"(pfreq_signal), |
| [tmp4] "=&r"(tmp4) |
| : |
| : "memory"); |
| } |
| |
| static void InverseFFTAndWindow(AecmCore* aecm, |
| int16_t* fft, |
| ComplexInt16* efw, |
| int16_t* output, |
| const int16_t* nearendClean) { |
| int i, outCFFT; |
| int32_t tmp1, tmp2, tmp3, tmp4, tmp_re, tmp_im; |
| int16_t* pcoefTable_ifft = coefTable_ifft; |
| int16_t* pfft = fft; |
| int16_t* ppfft = fft; |
| ComplexInt16* pefw = efw; |
| int32_t out_aecm; |
| int16_t* paecm_buf = aecm->outBuf; |
| const int16_t* p_kSqrtHanning = WebRtcAecm_kSqrtHanning; |
| const int16_t* pp_kSqrtHanning = &WebRtcAecm_kSqrtHanning[PART_LEN]; |
| int16_t* output1 = output; |
| |
| __asm __volatile( |
| ".set push " |
| "\n\t" |
| ".set noreorder " |
| "\n\t" |
| "addiu %[i], $zero, 64 " |
| "\n\t" |
| "1: " |
| "\n\t" |
| "lh %[tmp1], 0(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp2], 2(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp_re], 0(%[pefw]) " |
| "\n\t" |
| "lh %[tmp_im], 2(%[pefw]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp2] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp1] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "subu %[tmp_im], $zero, %[tmp_im] " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "lh %[tmp1], 4(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp2], 6(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp_re], 4(%[pefw]) " |
| "\n\t" |
| "lh %[tmp_im], 6(%[pefw]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp2] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp1] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "subu %[tmp_im], $zero, %[tmp_im] " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "lh %[tmp1], 8(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp2], 10(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp_re], 8(%[pefw]) " |
| "\n\t" |
| "lh %[tmp_im], 10(%[pefw]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp2] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp1] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "subu %[tmp_im], $zero, %[tmp_im] " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "lh %[tmp1], 12(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp2], 14(%[pcoefTable_ifft]) " |
| "\n\t" |
| "lh %[tmp_re], 12(%[pefw]) " |
| "\n\t" |
| "lh %[tmp_im], 14(%[pefw]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp2] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "addu %[pfft], %[fft], %[tmp1] " |
| "\n\t" |
| "sh %[tmp_re], 0(%[pfft]) " |
| "\n\t" |
| "subu %[tmp_im], $zero, %[tmp_im] " |
| "\n\t" |
| "sh %[tmp_im], 2(%[pfft]) " |
| "\n\t" |
| "addiu %[pcoefTable_ifft], %[pcoefTable_ifft], 16 " |
| "\n\t" |
| "addiu %[i], %[i], -4 " |
| "\n\t" |
| "bgtz %[i], 1b " |
| "\n\t" |
| " addiu %[pefw], %[pefw], 16 " |
| "\n\t" |
| ".set pop " |
| "\n\t" |
| : [tmp1] "=&r"(tmp1), [tmp2] "=&r"(tmp2), [pfft] "+r"(pfft), [i] "=&r"(i), |
| [tmp_re] "=&r"(tmp_re), [tmp_im] "=&r"(tmp_im), [pefw] "+r"(pefw), |
| [pcoefTable_ifft] "+r"(pcoefTable_ifft), [fft] "+r"(fft) |
| : |
| : "memory"); |
| |
| fft[2] = efw[PART_LEN].real; |
| fft[3] = -efw[PART_LEN].imag; |
| |
| outCFFT = WebRtcSpl_ComplexIFFT(fft, PART_LEN_SHIFT, 1); |
| pfft = fft; |
| |
| __asm __volatile( |
| ".set push \n\t" |
| ".set noreorder \n\t" |
| "addiu %[i], $zero, 128 \n\t" |
| "1: \n\t" |
| "lh %[tmp1], 0(%[ppfft]) \n\t" |
| "lh %[tmp2], 4(%[ppfft]) \n\t" |
| "lh %[tmp3], 8(%[ppfft]) \n\t" |
| "lh %[tmp4], 12(%[ppfft]) \n\t" |
| "addiu %[i], %[i], -4 \n\t" |
| "sh %[tmp1], 0(%[pfft]) \n\t" |
| "sh %[tmp2], 2(%[pfft]) \n\t" |
| "sh %[tmp3], 4(%[pfft]) \n\t" |
| "sh %[tmp4], 6(%[pfft]) \n\t" |
| "addiu %[ppfft], %[ppfft], 16 \n\t" |
| "bgtz %[i], 1b \n\t" |
| " addiu %[pfft], %[pfft], 8 \n\t" |
| ".set pop \n\t" |
| : [tmp1] "=&r"(tmp1), [tmp2] "=&r"(tmp2), [pfft] "+r"(pfft), [i] "=&r"(i), |
| [tmp3] "=&r"(tmp3), [tmp4] "=&r"(tmp4), [ppfft] "+r"(ppfft) |
| : |
| : "memory"); |
| |
| pfft = fft; |
| out_aecm = (int32_t)(outCFFT - aecm->dfaCleanQDomain); |
| |
| __asm __volatile( |
| ".set push " |
| "\n\t" |
| ".set noreorder " |
| "\n\t" |
| "addiu %[i], $zero, 64 " |
| "\n\t" |
| "11: " |
| "\n\t" |
| "lh %[tmp1], 0(%[pfft]) " |
| "\n\t" |
| "lh %[tmp2], 0(%[p_kSqrtHanning]) " |
| "\n\t" |
| "addiu %[i], %[i], -2 " |
| "\n\t" |
| "mul %[tmp1], %[tmp1], %[tmp2] " |
| "\n\t" |
| "lh %[tmp3], 2(%[pfft]) " |
| "\n\t" |
| "lh %[tmp4], 2(%[p_kSqrtHanning]) " |
| "\n\t" |
| "mul %[tmp3], %[tmp3], %[tmp4] " |
| "\n\t" |
| "addiu %[tmp1], %[tmp1], 8192 " |
| "\n\t" |
| "sra %[tmp1], %[tmp1], 14 " |
| "\n\t" |
| "addiu %[tmp3], %[tmp3], 8192 " |
| "\n\t" |
| "sra %[tmp3], %[tmp3], 14 " |
| "\n\t" |
| "bgez %[out_aecm], 1f " |
| "\n\t" |
| " negu %[tmp2], %[out_aecm] " |
| "\n\t" |
| "srav %[tmp1], %[tmp1], %[tmp2] " |
| "\n\t" |
| "b 2f " |
| "\n\t" |
| " srav %[tmp3], %[tmp3], %[tmp2] " |
| "\n\t" |
| "1: " |
| "\n\t" |
| "sllv %[tmp1], %[tmp1], %[out_aecm] " |
| "\n\t" |
| "sllv %[tmp3], %[tmp3], %[out_aecm] " |
| "\n\t" |
| "2: " |
| "\n\t" |
| "lh %[tmp4], 0(%[paecm_buf]) " |
| "\n\t" |
| "lh %[tmp2], 2(%[paecm_buf]) " |
| "\n\t" |
| "addu %[tmp3], %[tmp3], %[tmp2] " |
| "\n\t" |
| "addu %[tmp1], %[tmp1], %[tmp4] " |
| "\n\t" |
| #if defined(MIPS_DSP_R1_LE) |
| "shll_s.w %[tmp1], %[tmp1], 16 " |
| "\n\t" |
| "sra %[tmp1], %[tmp1], 16 " |
| "\n\t" |
| "shll_s.w %[tmp3], %[tmp3], 16 " |
| "\n\t" |
| "sra %[tmp3], %[tmp3], 16 " |
| "\n\t" |
| #else // #if defined(MIPS_DSP_R1_LE) |
| "sra %[tmp4], %[tmp1], 31 " |
| "\n\t" |
| "sra %[tmp2], %[tmp1], 15 " |
| "\n\t" |
| "beq %[tmp4], %[tmp2], 3f " |
| "\n\t" |
| " ori %[tmp2], $zero, 0x7fff " |
| "\n\t" |
| "xor %[tmp1], %[tmp2], %[tmp4] " |
| "\n\t" |
| "3: " |
| "\n\t" |
| "sra %[tmp2], %[tmp3], 31 " |
| "\n\t" |
| "sra %[tmp4], %[tmp3], 15 " |
| "\n\t" |
| "beq %[tmp2], %[tmp4], 4f " |
| "\n\t" |
| " ori %[tmp4], $zero, 0x7fff " |
| "\n\t" |
| "xor %[tmp3], %[tmp4], %[tmp2] " |
| "\n\t" |
| "4: " |
| "\n\t" |
| #endif // #if defined(MIPS_DSP_R1_LE) |
| "sh %[tmp1], 0(%[pfft]) " |
| "\n\t" |
| "sh %[tmp1], 0(%[output1]) " |
| "\n\t" |
| "sh %[tmp3], 2(%[pfft]) " |
| "\n\t" |
| "sh %[tmp3], 2(%[output1]) " |
| "\n\t" |
| "lh %[tmp1], 128(%[pfft]) " |
| "\n\t" |
| "lh %[tmp2], 0(%[pp_kSqrtHanning]) " |
| "\n\t" |
| "mul %[tmp1], %[tmp1], %[tmp2] " |
| "\n\t" |
| "lh %[tmp3], 130(%[pfft]) " |
| "\n\t" |
| "lh %[tmp4], -2(%[pp_kSqrtHanning]) " |
| "\n\t" |
| "mul %[tmp3], %[tmp3], %[tmp4] " |
| "\n\t" |
| "sra %[tmp1], %[tmp1], 14 " |
| "\n\t" |
| "sra %[tmp3], %[tmp3], 14 " |
| "\n\t" |
| "bgez %[out_aecm], 5f " |
| "\n\t" |
| " negu %[tmp2], %[out_aecm] " |
| "\n\t" |
| "srav %[tmp3], %[tmp3], %[tmp2] " |
| "\n\t" |
| "b 6f " |
| "\n\t" |
| " srav %[tmp1], %[tmp1], %[tmp2] " |
| "\n\t" |
| "5: " |
| "\n\t" |
| "sllv %[tmp1], %[tmp1], %[out_aecm] " |
| "\n\t" |
| "sllv %[tmp3], %[tmp3], %[out_aecm] " |
| "\n\t" |
| "6: " |
| "\n\t" |
| #if defined(MIPS_DSP_R1_LE) |
| "shll_s.w %[tmp1], %[tmp1], 16 " |
| "\n\t" |
| "sra %[tmp1], %[tmp1], 16 " |
| "\n\t" |
| "shll_s.w %[tmp3], %[tmp3], 16 " |
| "\n\t" |
| "sra %[tmp3], %[tmp3], 16 " |
| "\n\t" |
| #else // #if defined(MIPS_DSP_R1_LE) |
| "sra %[tmp4], %[tmp1], 31 " |
| "\n\t" |
| "sra %[tmp2], %[tmp1], 15 " |
| "\n\t" |
| "beq %[tmp4], %[tmp2], 7f " |
| "\n\t" |
| " ori %[tmp2], $zero, 0x7fff " |
| "\n\t" |
| "xor %[tmp1], %[tmp2], %[tmp4] " |
| "\n\t" |
| "7: " |
| "\n\t" |
| "sra %[tmp2], %[tmp3], 31 " |
| "\n\t" |
| "sra %[tmp4], %[tmp3], 15 " |
| "\n\t" |
| "beq %[tmp2], %[tmp4], 8f " |
| "\n\t" |
| " ori %[tmp4], $zero, 0x7fff " |
| "\n\t" |
| "xor %[tmp3], %[tmp4], %[tmp2] " |
| "\n\t" |
| "8: " |
| "\n\t" |
| #endif // #if defined(MIPS_DSP_R1_LE) |
| "sh %[tmp1], 0(%[paecm_buf]) " |
| "\n\t" |
| "sh %[tmp3], 2(%[paecm_buf]) " |
| "\n\t" |
| "addiu %[output1], %[output1], 4 " |
| "\n\t" |
| "addiu %[paecm_buf], %[paecm_buf], 4 " |
| "\n\t" |
| "addiu %[pfft], %[pfft], 4 " |
| "\n\t" |
| "addiu %[p_kSqrtHanning], %[p_kSqrtHanning], 4 " |
| "\n\t" |
| "bgtz %[i], 11b " |
| "\n\t" |
| " addiu %[pp_kSqrtHanning], %[pp_kSqrtHanning], -4 " |
| "\n\t" |
| ".set pop " |
| "\n\t" |
| : [tmp1] "=&r"(tmp1), [tmp2] "=&r"(tmp2), [pfft] "+r"(pfft), |
| [output1] "+r"(output1), [tmp3] "=&r"(tmp3), [tmp4] "=&r"(tmp4), |
| [paecm_buf] "+r"(paecm_buf), [i] "=&r"(i), |
| [pp_kSqrtHanning] "+r"(pp_kSqrtHanning), |
| [p_kSqrtHanning] "+r"(p_kSqrtHanning) |
| : [out_aecm] "r"(out_aecm), |
| [WebRtcAecm_kSqrtHanning] "r"(WebRtcAecm_kSqrtHanning) |
| : "hi", "lo", "memory"); |
| |
| // Copy the current block to the old position |
| // (aecm->outBuf is shifted elsewhere) |
| memcpy(aecm->xBuf, aecm->xBuf + PART_LEN, sizeof(int16_t) * PART_LEN); |
| memcpy(aecm->dBufNoisy, aecm->dBufNoisy + PART_LEN, |
| sizeof(int16_t) * PART_LEN); |
| if (nearendClean != NULL) { |
| memcpy(aecm->dBufClean, aecm->dBufClean + PART_LEN, |
| sizeof(int16_t) * PART_LEN); |
| } |
| } |
| |
| void WebRtcAecm_CalcLinearEnergies_mips(AecmCore* aecm, |
| const uint16_t* far_spectrum, |
| int32_t* echo_est, |
| uint32_t* far_energy, |
| uint32_t* echo_energy_adapt, |
| uint32_t* echo_energy_stored) { |
| int i; |
| uint32_t par1 = (*far_energy); |
| uint32_t par2 = (*echo_energy_adapt); |
| uint32_t par3 = (*echo_energy_stored); |
| int16_t* ch_stored_p = &(aecm->channelStored[0]); |
| int16_t* ch_adapt_p = &(aecm->channelAdapt16[0]); |
| uint16_t* spectrum_p = (uint16_t*)(&(far_spectrum[0])); |
| int32_t* echo_p = &(echo_est[0]); |
| int32_t temp0, stored0, echo0, adept0, spectrum0; |
| int32_t stored1, adept1, spectrum1, echo1, temp1; |
| |
| // Get energy for the delayed far end signal and estimated |
| // echo using both stored and adapted channels. |
| for (i = 0; i < PART_LEN; i += 4) { |
| __asm __volatile( |
| ".set push \n\t" |
| ".set noreorder \n\t" |
| "lh %[stored0], 0(%[ch_stored_p]) \n\t" |
| "lhu %[adept0], 0(%[ch_adapt_p]) \n\t" |
| "lhu %[spectrum0], 0(%[spectrum_p]) \n\t" |
| "lh %[stored1], 2(%[ch_stored_p]) \n\t" |
| "lhu %[adept1], 2(%[ch_adapt_p]) \n\t" |
| "lhu %[spectrum1], 2(%[spectrum_p]) \n\t" |
| "mul %[echo0], %[stored0], %[spectrum0] \n\t" |
| "mul %[temp0], %[adept0], %[spectrum0] \n\t" |
| "mul %[echo1], %[stored1], %[spectrum1] \n\t" |
| "mul %[temp1], %[adept1], %[spectrum1] \n\t" |
| "addu %[par1], %[par1], %[spectrum0] \n\t" |
| "addu %[par1], %[par1], %[spectrum1] \n\t" |
| "addiu %[echo_p], %[echo_p], 16 \n\t" |
| "addu %[par3], %[par3], %[echo0] \n\t" |
| "addu %[par2], %[par2], %[temp0] \n\t" |
| "addu %[par3], %[par3], %[echo1] \n\t" |
| "addu %[par2], %[par2], %[temp1] \n\t" |
| "usw %[echo0], -16(%[echo_p]) \n\t" |
| "usw %[echo1], -12(%[echo_p]) \n\t" |
| "lh %[stored0], 4(%[ch_stored_p]) \n\t" |
| "lhu %[adept0], 4(%[ch_adapt_p]) \n\t" |
| "lhu %[spectrum0], 4(%[spectrum_p]) \n\t" |
| "lh %[stored1], 6(%[ch_stored_p]) \n\t" |
| "lhu %[adept1], 6(%[ch_adapt_p]) \n\t" |
| "lhu %[spectrum1], 6(%[spectrum_p]) \n\t" |
| "mul %[echo0], %[stored0], %[spectrum0] \n\t" |
| "mul %[temp0], %[adept0], %[spectrum0] \n\t" |
| "mul %[echo1], %[stored1], %[spectrum1] \n\t" |
| "mul %[temp1], %[adept1], %[spectrum1] \n\t" |
| "addu %[par1], %[par1], %[spectrum0] \n\t" |
| "addu %[par1], %[par1], %[spectrum1] \n\t" |
| "addiu %[ch_stored_p], %[ch_stored_p], 8 \n\t" |
| "addiu %[ch_adapt_p], %[ch_adapt_p], 8 \n\t" |
| "addiu %[spectrum_p], %[spectrum_p], 8 \n\t" |
| "addu %[par3], %[par3], %[echo0] \n\t" |
| "addu %[par2], %[par2], %[temp0] \n\t" |
| "addu %[par3], %[par3], %[echo1] \n\t" |
| "addu %[par2], %[par2], %[temp1] \n\t" |
| "usw %[echo0], -8(%[echo_p]) \n\t" |
| "usw %[echo1], -4(%[echo_p]) \n\t" |
| ".set pop \n\t" |
| : [temp0] "=&r"(temp0), [stored0] "=&r"(stored0), |
| [adept0] "=&r"(adept0), [spectrum0] "=&r"(spectrum0), |
| [echo0] "=&r"(echo0), [echo_p] "+r"(echo_p), [par3] "+r"(par3), |
| [par1] "+r"(par1), [par2] "+r"(par2), [stored1] "=&r"(stored1), |
| [adept1] "=&r"(adept1), [echo1] "=&r"(echo1), |
| [spectrum1] "=&r"(spectrum1), [temp1] "=&r"(temp1), |
| [ch_stored_p] "+r"(ch_stored_p), [ch_adapt_p] "+r"(ch_adapt_p), |
| [spectrum_p] "+r"(spectrum_p) |
| : |
| : "hi", "lo", "memory"); |
| } |
| |
| echo_est[PART_LEN] = WEBRTC_SPL_MUL_16_U16(aecm->channelStored[PART_LEN], |
| far_spectrum[PART_LEN]); |
| par1 += (uint32_t)(far_spectrum[PART_LEN]); |
| par2 += aecm->channelAdapt16[PART_LEN] * far_spectrum[PART_LEN]; |
| par3 += (uint32_t)echo_est[PART_LEN]; |
| |
| (*far_energy) = par1; |
| (*echo_energy_adapt) = par2; |
| (*echo_energy_stored) = par3; |
| } |
| |
| #if defined(MIPS_DSP_R1_LE) |
| void WebRtcAecm_StoreAdaptiveChannel_mips(AecmCore* aecm, |
| const uint16_t* far_spectrum, |
| int32_t* echo_est) { |
| int i; |
| int16_t* temp1; |
| uint16_t* temp8; |
| int32_t temp0, temp2, temp3, temp4, temp5, temp6; |
| int32_t* temp7 = &(echo_est[0]); |
| temp1 = &(aecm->channelStored[0]); |
| temp8 = (uint16_t*)(&far_spectrum[0]); |
| |
| // During startup we store the channel every block. |
| memcpy(aecm->channelStored, aecm->channelAdapt16, |
| sizeof(int16_t) * PART_LEN1); |
| // Recalculate echo estimate |
| for (i = 0; i < PART_LEN; i += 4) { |
| __asm __volatile( |
| "ulw %[temp0], 0(%[temp8]) \n\t" |
| "ulw %[temp2], 0(%[temp1]) \n\t" |
| "ulw %[temp4], 4(%[temp8]) \n\t" |
| "ulw %[temp5], 4(%[temp1]) \n\t" |
| "muleq_s.w.phl %[temp3], %[temp2], %[temp0] \n\t" |
| "muleq_s.w.phr %[temp0], %[temp2], %[temp0] \n\t" |
| "muleq_s.w.phl %[temp6], %[temp5], %[temp4] \n\t" |
| "muleq_s.w.phr %[temp4], %[temp5], %[temp4] \n\t" |
| "addiu %[temp7], %[temp7], 16 \n\t" |
| "addiu %[temp1], %[temp1], 8 \n\t" |
| "addiu %[temp8], %[temp8], 8 \n\t" |
| "sra %[temp3], %[temp3], 1 \n\t" |
| "sra %[temp0], %[temp0], 1 \n\t" |
| "sra %[temp6], %[temp6], 1 \n\t" |
| "sra %[temp4], %[temp4], 1 \n\t" |
| "usw %[temp3], -12(%[temp7]) \n\t" |
| "usw %[temp0], -16(%[temp7]) \n\t" |
| "usw %[temp6], -4(%[temp7]) \n\t" |
| "usw %[temp4], -8(%[temp7]) \n\t" |
| : [temp0] "=&r"(temp0), [temp2] "=&r"(temp2), [temp3] "=&r"(temp3), |
| [temp4] "=&r"(temp4), [temp5] "=&r"(temp5), [temp6] "=&r"(temp6), |
| [temp1] "+r"(temp1), [temp8] "+r"(temp8), [temp7] "+r"(temp7) |
| : |
| : "hi", "lo", "memory"); |
| } |
| echo_est[i] = WEBRTC_SPL_MUL_16_U16(aecm->channelStored[i], far_spectrum[i]); |
| } |
| |
| void WebRtcAecm_ResetAdaptiveChannel_mips(AecmCore* aecm) { |
| int i; |
| int32_t* temp3; |
| int16_t* temp0; |
| int32_t temp1, temp2, temp4, temp5; |
| |
| temp0 = &(aecm->channelStored[0]); |
| temp3 = &(aecm->channelAdapt32[0]); |
| |
| // The stored channel has a significantly lower MSE than the adaptive one for |
| // two consecutive calculations. Reset the adaptive channel. |
| memcpy(aecm->channelAdapt16, aecm->channelStored, |
| sizeof(int16_t) * PART_LEN1); |
| |
| // Restore the W32 channel |
| for (i = 0; i < PART_LEN; i += 4) { |
| __asm __volatile( |
| "ulw %[temp1], 0(%[temp0]) \n\t" |
| "ulw %[temp4], 4(%[temp0]) \n\t" |
| "preceq.w.phl %[temp2], %[temp1] \n\t" |
| "preceq.w.phr %[temp1], %[temp1] \n\t" |
| "preceq.w.phl %[temp5], %[temp4] \n\t" |
| "preceq.w.phr %[temp4], %[temp4] \n\t" |
| "addiu %[temp0], %[temp0], 8 \n\t" |
| "usw %[temp2], 4(%[temp3]) \n\t" |
| "usw %[temp1], 0(%[temp3]) \n\t" |
| "usw %[temp5], 12(%[temp3]) \n\t" |
| "usw %[temp4], 8(%[temp3]) \n\t" |
| "addiu %[temp3], %[temp3], 16 \n\t" |
| : [temp1] "=&r"(temp1), [temp2] "=&r"(temp2), [temp4] "=&r"(temp4), |
| [temp5] "=&r"(temp5), [temp3] "+r"(temp3), [temp0] "+r"(temp0) |
| : |
| : "memory"); |
| } |
| |
| aecm->channelAdapt32[i] = (int32_t)aecm->channelStored[i] << 16; |
| } |
| #endif // #if defined(MIPS_DSP_R1_LE) |
| |
| // Transforms a time domain signal into the frequency domain, outputting the |
| // complex valued signal, absolute value and sum of absolute values. |
| // |
| // time_signal [in] Pointer to time domain signal |
| // freq_signal_real [out] Pointer to real part of frequency domain array |
| // freq_signal_imag [out] Pointer to imaginary part of frequency domain |
| // array |
| // freq_signal_abs [out] Pointer to absolute value of frequency domain |
| // array |
| // freq_signal_sum_abs [out] Pointer to the sum of all absolute values in |
| // the frequency domain array |
| // return value The Q-domain of current frequency values |
| // |
| static int TimeToFrequencyDomain(AecmCore* aecm, |
| const int16_t* time_signal, |
| ComplexInt16* freq_signal, |
| uint16_t* freq_signal_abs, |
| uint32_t* freq_signal_sum_abs) { |
| int i = 0; |
| int time_signal_scaling = 0; |
| |
| // In fft_buf, +16 for 32-byte alignment. |
| int16_t fft_buf[PART_LEN4 + 16]; |
| int16_t* fft = (int16_t*)(((uintptr_t)fft_buf + 31) & ~31); |
| |
| int16_t tmp16no1; |
| #if !defined(MIPS_DSP_R2_LE) |
| int32_t tmp32no1; |
| int32_t tmp32no2; |
| int16_t tmp16no2; |
| #else |
| int32_t tmp32no10, tmp32no11, tmp32no12, tmp32no13; |
| int32_t tmp32no20, tmp32no21, tmp32no22, tmp32no23; |
| int16_t* freqp; |
| uint16_t* freqabsp; |
| uint32_t freqt0, freqt1, freqt2, freqt3; |
| uint32_t freqs; |
| #endif |
| |
| #ifdef AECM_DYNAMIC_Q |
| tmp16no1 = WebRtcSpl_MaxAbsValueW16(time_signal, PART_LEN2); |
| time_signal_scaling = WebRtcSpl_NormW16(tmp16no1); |
| #endif |
| |
| WindowAndFFT(aecm, fft, time_signal, freq_signal, time_signal_scaling); |
| |
| // Extract imaginary and real part, |
| // calculate the magnitude for all frequency bins |
| freq_signal[0].imag = 0; |
| freq_signal[PART_LEN].imag = 0; |
| freq_signal[PART_LEN].real = fft[PART_LEN2]; |
| freq_signal_abs[0] = (uint16_t)WEBRTC_SPL_ABS_W16(freq_signal[0].real); |
| freq_signal_abs[PART_LEN] = |
| (uint16_t)WEBRTC_SPL_ABS_W16(freq_signal[PART_LEN].real); |
| (*freq_signal_sum_abs) = |
| (uint32_t)(freq_signal_abs[0]) + (uint32_t)(freq_signal_abs[PART_LEN]); |
| |
| #if !defined(MIPS_DSP_R2_LE) |
| for (i = 1; i < PART_LEN; i++) { |
| if (freq_signal[i].real == 0) { |
| freq_signal_abs[i] = (uint16_t)WEBRTC_SPL_ABS_W16(freq_signal[i].imag); |
| } else if (freq_signal[i].imag == 0) { |
| freq_signal_abs[i] = (uint16_t)WEBRTC_SPL_ABS_W16(freq_signal[i].real); |
| } else { |
| // Approximation for magnitude of complex fft output |
| // magn = sqrt(real^2 + imag^2) |
| // magn ~= alpha * max(|imag|,|real|) + beta * min(|imag|,|real|) |
| // |
| // The parameters alpha and beta are stored in Q15 |
| tmp16no1 = WEBRTC_SPL_ABS_W16(freq_signal[i].real); |
| tmp16no2 = WEBRTC_SPL_ABS_W16(freq_signal[i].imag); |
| tmp32no1 = tmp16no1 * tmp16no1; |
| tmp32no2 = tmp16no2 * tmp16no2; |
| tmp32no2 = WebRtcSpl_AddSatW32(tmp32no1, tmp32no2); |
| tmp32no1 = WebRtcSpl_SqrtFloor(tmp32no2); |
| |
| freq_signal_abs[i] = (uint16_t)tmp32no1; |
| } |
| (*freq_signal_sum_abs) += (uint32_t)freq_signal_abs[i]; |
| } |
| #else // #if !defined(MIPS_DSP_R2_LE) |
| freqs = |
| (uint32_t)(freq_signal_abs[0]) + (uint32_t)(freq_signal_abs[PART_LEN]); |
| freqp = &(freq_signal[1].real); |
| |
| __asm __volatile( |
| "lw %[freqt0], 0(%[freqp]) \n\t" |
| "lw %[freqt1], 4(%[freqp]) \n\t" |
| "lw %[freqt2], 8(%[freqp]) \n\t" |
| "mult $ac0, $zero, $zero \n\t" |
| "mult $ac1, $zero, $zero \n\t" |
| "mult $ac2, $zero, $zero \n\t" |
| "dpaq_s.w.ph $ac0, %[freqt0], %[freqt0] \n\t" |
| "dpaq_s.w.ph $ac1, %[freqt1], %[freqt1] \n\t" |
| "dpaq_s.w.ph $ac2, %[freqt2], %[freqt2] \n\t" |
| "addiu %[freqp], %[freqp], 12 \n\t" |
| "extr.w %[tmp32no20], $ac0, 1 \n\t" |
| "extr.w %[tmp32no21], $ac1, 1 \n\t" |
| "extr.w %[tmp32no22], $ac2, 1 \n\t" |
| : [freqt0] "=&r"(freqt0), [freqt1] "=&r"(freqt1), [freqt2] "=&r"(freqt2), |
| [freqp] "+r"(freqp), [tmp32no20] "=r"(tmp32no20), |
| [tmp32no21] "=r"(tmp32no21), [tmp32no22] "=r"(tmp32no22) |
| : |
| : "memory", "hi", "lo", "$ac1hi", "$ac1lo", "$ac2hi", "$ac2lo"); |
| |
| tmp32no10 = WebRtcSpl_SqrtFloor(tmp32no20); |
| tmp32no11 = WebRtcSpl_SqrtFloor(tmp32no21); |
| tmp32no12 = WebRtcSpl_SqrtFloor(tmp32no22); |
| freq_signal_abs[1] = (uint16_t)tmp32no10; |
| freq_signal_abs[2] = (uint16_t)tmp32no11; |
| freq_signal_abs[3] = (uint16_t)tmp32no12; |
| freqs += (uint32_t)tmp32no10; |
| freqs += (uint32_t)tmp32no11; |
| freqs += (uint32_t)tmp32no12; |
| freqabsp = &(freq_signal_abs[4]); |
| for (i = 4; i < PART_LEN; i += 4) { |
| __asm __volatile( |
| "ulw %[freqt0], 0(%[freqp]) \n\t" |
| "ulw %[freqt1], 4(%[freqp]) \n\t" |
| "ulw %[freqt2], 8(%[freqp]) \n\t" |
| "ulw %[freqt3], 12(%[freqp]) \n\t" |
| "mult $ac0, $zero, $zero \n\t" |
| "mult $ac1, $zero, $zero \n\t" |
| "mult $ac2, $zero, $zero \n\t" |
| "mult $ac3, $zero, $zero \n\t" |
| "dpaq_s.w.ph $ac0, %[freqt0], %[freqt0] \n\t" |
| "dpaq_s.w.ph $ac1, %[freqt1], %[freqt1] \n\t" |
| "dpaq_s.w.ph $ac2, %[freqt2], %[freqt2] \n\t" |
| "dpaq_s.w.ph $ac3, %[freqt3], %[freqt3] \n\t" |
| "addiu %[freqp], %[freqp], 16 \n\t" |
| "addiu %[freqabsp], %[freqabsp], 8 \n\t" |
| "extr.w %[tmp32no20], $ac0, 1 \n\t" |
| "extr.w %[tmp32no21], $ac1, 1 \n\t" |
| "extr.w %[tmp32no22], $ac2, 1 \n\t" |
| "extr.w %[tmp32no23], $ac3, 1 \n\t" |
| : [freqt0] "=&r"(freqt0), [freqt1] "=&r"(freqt1), |
| [freqt2] "=&r"(freqt2), [freqt3] "=&r"(freqt3), |
| [tmp32no20] "=r"(tmp32no20), [tmp32no21] "=r"(tmp32no21), |
| [tmp32no22] "=r"(tmp32no22), [tmp32no23] "=r"(tmp32no23), |
| [freqabsp] "+r"(freqabsp), [freqp] "+r"(freqp) |
| : |
| : "memory", "hi", "lo", "$ac1hi", "$ac1lo", "$ac2hi", "$ac2lo", |
| "$ac3hi", "$ac3lo"); |
| |
| tmp32no10 = WebRtcSpl_SqrtFloor(tmp32no20); |
| tmp32no11 = WebRtcSpl_SqrtFloor(tmp32no21); |
| tmp32no12 = WebRtcSpl_SqrtFloor(tmp32no22); |
| tmp32no13 = WebRtcSpl_SqrtFloor(tmp32no23); |
| |
| __asm __volatile( |
| "sh %[tmp32no10], -8(%[freqabsp]) \n\t" |
| "sh %[tmp32no11], -6(%[freqabsp]) \n\t" |
| "sh %[tmp32no12], -4(%[freqabsp]) \n\t" |
| "sh %[tmp32no13], -2(%[freqabsp]) \n\t" |
| "addu %[freqs], %[freqs], %[tmp32no10] \n\t" |
| "addu %[freqs], %[freqs], %[tmp32no11] \n\t" |
| "addu %[freqs], %[freqs], %[tmp32no12] \n\t" |
| "addu %[freqs], %[freqs], %[tmp32no13] \n\t" |
| : [freqs] "+r"(freqs) |
| : [tmp32no10] "r"(tmp32no10), [tmp32no11] "r"(tmp32no11), |
| [tmp32no12] "r"(tmp32no12), [tmp32no13] "r"(tmp32no13), |
| [freqabsp] "r"(freqabsp) |
| : "memory"); |
| } |
| |
| (*freq_signal_sum_abs) = freqs; |
| #endif |
| |
| return time_signal_scaling; |
| } |
| |
| int WebRtcAecm_ProcessBlock(AecmCore* aecm, |
| const int16_t* farend, |
| const int16_t* nearendNoisy, |
| const int16_t* nearendClean, |
| int16_t* output) { |
| int i; |
| uint32_t xfaSum; |
| uint32_t dfaNoisySum; |
| uint32_t dfaCleanSum; |
| uint32_t echoEst32Gained; |
| uint32_t tmpU32; |
| int32_t tmp32no1; |
| |
| uint16_t xfa[PART_LEN1]; |
| uint16_t dfaNoisy[PART_LEN1]; |
| uint16_t dfaClean[PART_LEN1]; |
| uint16_t* ptrDfaClean = dfaClean; |
| const uint16_t* far_spectrum_ptr = NULL; |
| |
| // 32 byte aligned buffers (with +8 or +16). |
| int16_t fft_buf[PART_LEN4 + 2 + 16]; // +2 to make a loop safe. |
| int32_t echoEst32_buf[PART_LEN1 + 8]; |
| int32_t dfw_buf[PART_LEN2 + 8]; |
| int32_t efw_buf[PART_LEN2 + 8]; |
| |
| int16_t* fft = (int16_t*)(((uint32_t)fft_buf + 31) & ~31); |
| int32_t* echoEst32 = (int32_t*)(((uint32_t)echoEst32_buf + 31) & ~31); |
| ComplexInt16* dfw = (ComplexInt16*)(((uint32_t)dfw_buf + 31) & ~31); |
| ComplexInt16* efw = (ComplexInt16*)(((uint32_t)efw_buf + 31) & ~31); |
| |
| int16_t hnl[PART_LEN1]; |
| int16_t numPosCoef = 0; |
| int delay; |
| int16_t tmp16no1; |
| int16_t tmp16no2; |
| int16_t mu; |
| int16_t supGain; |
| int16_t zeros32, zeros16; |
| int16_t zerosDBufNoisy, zerosDBufClean, zerosXBuf; |
| int far_q; |
| int16_t resolutionDiff, qDomainDiff, dfa_clean_q_domain_diff; |
| |
| const int kMinPrefBand = 4; |
| const int kMaxPrefBand = 24; |
| int32_t avgHnl32 = 0; |
| |
| int32_t temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8; |
| int16_t* ptr; |
| int16_t* ptr1; |
| int16_t* er_ptr; |
| int16_t* dr_ptr; |
| |
| ptr = &hnl[0]; |
| ptr1 = &hnl[0]; |
| er_ptr = &efw[0].real; |
| dr_ptr = &dfw[0].real; |
| |
| // Determine startup state. There are three states: |
| // (0) the first CONV_LEN blocks |
| // (1) another CONV_LEN blocks |
| // (2) the rest |
| |
| if (aecm->startupState < 2) { |
| aecm->startupState = |
| (aecm->totCount >= CONV_LEN) + (aecm->totCount >= CONV_LEN2); |
| } |
| // END: Determine startup state |
| |
| // Buffer near and far end signals |
| memcpy(aecm->xBuf + PART_LEN, farend, sizeof(int16_t) * PART_LEN); |
| memcpy(aecm->dBufNoisy + PART_LEN, nearendNoisy, sizeof(int16_t) * PART_LEN); |
| if (nearendClean != NULL) { |
| memcpy(aecm->dBufClean + PART_LEN, nearendClean, |
| sizeof(int16_t) * PART_LEN); |
| } |
| |
| // Transform far end signal from time domain to frequency domain. |
| far_q = TimeToFrequencyDomain(aecm, aecm->xBuf, dfw, xfa, &xfaSum); |
| |
| // Transform noisy near end signal from time domain to frequency domain. |
| zerosDBufNoisy = |
| TimeToFrequencyDomain(aecm, aecm->dBufNoisy, dfw, dfaNoisy, &dfaNoisySum); |
| aecm->dfaNoisyQDomainOld = aecm->dfaNoisyQDomain; |
| aecm->dfaNoisyQDomain = (int16_t)zerosDBufNoisy; |
| |
| if (nearendClean == NULL) { |
| ptrDfaClean = dfaNoisy; |
| aecm->dfaCleanQDomainOld = aecm->dfaNoisyQDomainOld; |
| aecm->dfaCleanQDomain = aecm->dfaNoisyQDomain; |
| dfaCleanSum = dfaNoisySum; |
| } else { |
| // Transform clean near end signal from time domain to frequency domain. |
| zerosDBufClean = TimeToFrequencyDomain(aecm, aecm->dBufClean, dfw, dfaClean, |
| &dfaCleanSum); |
| aecm->dfaCleanQDomainOld = aecm->dfaCleanQDomain; |
| aecm->dfaCleanQDomain = (int16_t)zerosDBufClean; |
| } |
| |
| // Get the delay |
| // Save far-end history and estimate delay |
| WebRtcAecm_UpdateFarHistory(aecm, xfa, far_q); |
| |
| if (WebRtc_AddFarSpectrumFix(aecm->delay_estimator_farend, xfa, PART_LEN1, |
| far_q) == -1) { |
| return -1; |
| } |
| delay = WebRtc_DelayEstimatorProcessFix(aecm->delay_estimator, dfaNoisy, |
| PART_LEN1, zerosDBufNoisy); |
| if (delay == -1) { |
| return -1; |
| } else if (delay == -2) { |
| // If the delay is unknown, we assume zero. |
| // NOTE: this will have to be adjusted if we ever add lookahead. |
| delay = 0; |
| } |
| |
| if (aecm->fixedDelay >= 0) { |
| // Use fixed delay |
| delay = aecm->fixedDelay; |
| } |
| |
| // Get aligned far end spectrum |
| far_spectrum_ptr = WebRtcAecm_AlignedFarend(aecm, &far_q, delay); |
| zerosXBuf = (int16_t)far_q; |
| |
| if (far_spectrum_ptr == NULL) { |
| return -1; |
| } |
| |
| // Calculate log(energy) and update energy threshold levels |
| WebRtcAecm_CalcEnergies(aecm, far_spectrum_ptr, zerosXBuf, dfaNoisySum, |
| echoEst32); |
| // Calculate stepsize |
| mu = WebRtcAecm_CalcStepSize(aecm); |
| |
| // Update counters |
| aecm->totCount++; |
| |
| // This is the channel estimation algorithm. |
| // It is base on NLMS but has a variable step length, |
| // which was calculated above. |
| WebRtcAecm_UpdateChannel(aecm, far_spectrum_ptr, zerosXBuf, dfaNoisy, mu, |
| echoEst32); |
| |
| supGain = WebRtcAecm_CalcSuppressionGain(aecm); |
| |
| // Calculate Wiener filter hnl[] |
| for (i = 0; i < PART_LEN1; i++) { |
| // Far end signal through channel estimate in Q8 |
| // How much can we shift right to preserve resolution |
| tmp32no1 = echoEst32[i] - aecm->echoFilt[i]; |
| aecm->echoFilt[i] += |
| rtc::dchecked_cast<int32_t>((int64_t{tmp32no1} * 50) >> 8); |
| |
| zeros32 = WebRtcSpl_NormW32(aecm->echoFilt[i]) + 1; |
| zeros16 = WebRtcSpl_NormW16(supGain) + 1; |
| if (zeros32 + zeros16 > 16) { |
| // Multiplication is safe |
| // Result in |
| // Q(RESOLUTION_CHANNEL+RESOLUTION_SUPGAIN+aecm->xfaQDomainBuf[diff]) |
| echoEst32Gained = |
| WEBRTC_SPL_UMUL_32_16((uint32_t)aecm->echoFilt[i], (uint16_t)supGain); |
| resolutionDiff = 14 - RESOLUTION_CHANNEL16 - RESOLUTION_SUPGAIN; |
| resolutionDiff += (aecm->dfaCleanQDomain - zerosXBuf); |
| } else { |
| tmp16no1 = 17 - zeros32 - zeros16; |
| resolutionDiff = |
| 14 + tmp16no1 - RESOLUTION_CHANNEL16 - RESOLUTION_SUPGAIN; |
| resolutionDiff += (aecm->dfaCleanQDomain - zerosXBuf); |
| if (zeros32 > tmp16no1) { |
| echoEst32Gained = WEBRTC_SPL_UMUL_32_16((uint32_t)aecm->echoFilt[i], |
| supGain >> tmp16no1); |
| } else { |
| // Result in Q-(RESOLUTION_CHANNEL+RESOLUTION_SUPGAIN-16) |
| echoEst32Gained = (aecm->echoFilt[i] >> tmp16no1) * supGain; |
| } |
| } |
| |
| zeros16 = WebRtcSpl_NormW16(aecm->nearFilt[i]); |
| RTC_DCHECK_GE(zeros16, 0); // |zeros16| is a norm, hence non-negative. |
| dfa_clean_q_domain_diff = aecm->dfaCleanQDomain - aecm->dfaCleanQDomainOld; |
| if (zeros16 < dfa_clean_q_domain_diff && aecm->nearFilt[i]) { |
| tmp16no1 = aecm->nearFilt[i] << zeros16; |
| qDomainDiff = zeros16 - dfa_clean_q_domain_diff; |
| tmp16no2 = ptrDfaClean[i] >> -qDomainDiff; |
| } else { |
| tmp16no1 = dfa_clean_q_domain_diff < 0 |
| ? aecm->nearFilt[i] >> -dfa_clean_q_domain_diff |
| : aecm->nearFilt[i] << dfa_clean_q_domain_diff; |
| qDomainDiff = 0; |
| tmp16no2 = ptrDfaClean[i]; |
| } |
| |
| tmp32no1 = (int32_t)(tmp16no2 - tmp16no1); |
| tmp16no2 = (int16_t)(tmp32no1 >> 4); |
| tmp16no2 += tmp16no1; |
| zeros16 = WebRtcSpl_NormW16(tmp16no2); |
| if ((tmp16no2) & (-qDomainDiff > zeros16)) { |
| aecm->nearFilt[i] = WEBRTC_SPL_WORD16_MAX; |
| } else { |
| aecm->nearFilt[i] = |
| qDomainDiff < 0 ? tmp16no2 << -qDomainDiff : tmp16no2 >> qDomainDiff; |
| } |
| |
| // Wiener filter coefficients, resulting hnl in Q14 |
| if (echoEst32Gained == 0) { |
| hnl[i] = ONE_Q14; |
| numPosCoef++; |
| } else if (aecm->nearFilt[i] == 0) { |
| hnl[i] = 0; |
| } else { |
| // Multiply the suppression gain |
| // Rounding |
| echoEst32Gained += (uint32_t)(aecm->nearFilt[i] >> 1); |
| tmpU32 = |
| WebRtcSpl_DivU32U16(echoEst32Gained, (uint16_t)aecm->nearFilt[i]); |
| |
| // Current resolution is |
| // Q-(RESOLUTION_CHANNEL + RESOLUTION_SUPGAIN |
| // - max(0, 17 - zeros16 - zeros32)) |
| // Make sure we are in Q14 |
| tmp32no1 = (int32_t)WEBRTC_SPL_SHIFT_W32(tmpU32, resolutionDiff); |
| if (tmp32no1 > ONE_Q14) { |
| hnl[i] = 0; |
| } else if (tmp32no1 < 0) { |
| hnl[i] = ONE_Q14; |
| numPosCoef++; |
| } else { |
| // 1-echoEst/dfa |
| hnl[i] = ONE_Q14 - (int16_t)tmp32no1; |
| if (hnl[i] <= 0) { |
| hnl[i] = 0; |
| } else { |
| numPosCoef++; |
| } |
| } |
| } |
| } |
| |
| // Only in wideband. Prevent the gain in upper band from being larger than |
| // in lower band. |
| if (aecm->mult == 2) { |
| // TODO(bjornv): Investigate if the scaling of hnl[i] below can cause |
| // speech distortion in double-talk. |
| for (i = 0; i < (PART_LEN1 >> 3); i++) { |
| __asm __volatile( |
| "lh %[temp1], 0(%[ptr1]) \n\t" |
| "lh %[temp2], 2(%[ptr1]) \n\t" |
| "lh %[temp3], 4(%[ptr1]) \n\t" |
| "lh %[temp4], 6(%[ptr1]) \n\t" |
| "lh %[temp5], 8(%[ptr1]) \n\t" |
| "lh %[temp6], 10(%[ptr1]) \n\t" |
| "lh %[temp7], 12(%[ptr1]) \n\t" |
| "lh %[temp8], 14(%[ptr1]) \n\t" |
| "mul %[temp1], %[temp1], %[temp1] \n\t" |
| "mul %[temp2], %[temp2], %[temp2] \n\t" |
| "mul %[temp3], %[temp3], %[temp3] \n\t" |
| "mul %[temp4], %[temp4], %[temp4] \n\t" |
| "mul %[temp5], %[temp5], %[temp5] \n\t" |
| "mul %[temp6], %[temp6], %[temp6] \n\t" |
| "mul %[temp7], %[temp7], %[temp7] \n\t" |
| "mul %[temp8], %[temp8], %[temp8] \n\t" |
| "sra %[temp1], %[temp1], 14 \n\t" |
| "sra %[temp2], %[temp2], 14 \n\t" |
| "sra %[temp3], %[temp3], 14 \n\t" |
| "sra %[temp4], %[temp4], 14 \n\t" |
| "sra %[temp5], %[temp5], 14 \n\t" |
| "sra %[temp6], %[temp6], 14 \n\t" |
| "sra %[temp7], %[temp7], 14 \n\t" |
| "sra %[temp8], %[temp8], 14 \n\t" |
| "sh %[temp1], 0(%[ptr1]) \n\t" |
| "sh %[temp2], 2(%[ptr1]) \n\t" |
| "sh %[temp3], 4(%[ptr1]) \n\t" |
| "sh %[temp4], 6(%[ptr1]) \n\t" |
| "sh %[temp5], 8(%[ptr1]) \n\t" |
| "sh %[temp6], 10(%[ptr1]) \n\t" |
| "sh %[temp7], 12(%[ptr1]) \n\t" |
| "sh %[temp8], 14(%[ptr1]) \n\t" |
| "addiu %[ptr1], %[ptr1], 16 \n\t" |
| : [temp1] "=&r"(temp1), [temp2] "=&r"(temp2), [temp3] "=&r"(temp3), |
| [temp4] "=&r"(temp4), [temp5] "=&r"(temp5), [temp6] "=&r"(temp6), |
| [temp7] "=&r"(temp7), [temp8] "=&r"(temp8), [ptr1] "+r"(ptr1) |
| : |
| : "memory", "hi", "lo"); |
| } |
| for (i = 0; i < (PART_LEN1 & 7); i++) { |
| __asm __volatile( |
| "lh %[temp1], 0(%[ptr1]) \n\t" |
| "mul %[temp1], %[temp1], %[temp1] \n\t" |
| "sra %[temp1], %[temp1], 14 \n\t" |
| "sh %[temp1], 0(%[ptr1]) \n\t" |
| "addiu %[ptr1], %[ptr1], 2 \n\t" |
| : [temp1] "=&r"(temp1), [ptr1] "+r"(ptr1) |
| : |
| : "memory", "hi", "lo"); |
| } |
| |
| for (i = kMinPrefBand; i <= kMaxPrefBand; i++) { |
| avgHnl32 += (int32_t)hnl[i]; |
| } |
| |
| RTC_DCHECK_GT(kMaxPrefBand - kMinPrefBand + 1, 0); |
| avgHnl32 /= (kMaxPrefBand - kMinPrefBand + 1); |
| |
| for (i = kMaxPrefBand; i < PART_LEN1; i++) { |
| if (hnl[i] > (int16_t)avgHnl32) { |
| hnl[i] = (int16_t)avgHnl32; |
| } |
| } |
| } |
| |
| // Calculate NLP gain, result is in Q14 |
| if (aecm->nlpFlag) { |
| if (numPosCoef < 3) { |
| for (i = 0; i < PART_LEN1; i++) { |
| efw[i].real = 0; |
| efw[i].imag = 0; |
| hnl[i] = 0; |
| } |
| } else { |
| for (i = 0; i < PART_LEN1; i++) { |
| #if defined(MIPS_DSP_R1_LE) |
| __asm __volatile( |
| ".set push \n\t" |
| ".set noreorder \n\t" |
| "lh %[temp1], 0(%[ptr]) \n\t" |
| "lh %[temp2], 0(%[dr_ptr]) \n\t" |
| "slti %[temp4], %[temp1], 0x4001 \n\t" |
| "beqz %[temp4], 3f \n\t" |
| " lh %[temp3], 2(%[dr_ptr]) \n\t" |
| "slti %[temp5], %[temp1], 3277 \n\t" |
| "bnez %[temp5], 2f \n\t" |
| " addiu %[dr_ptr], %[dr_ptr], 4 \n\t" |
| "mul %[temp2], %[temp2], %[temp1] \n\t" |
| "mul %[temp3], %[temp3], %[temp1] \n\t" |
| "shra_r.w %[temp2], %[temp2], 14 \n\t" |
| "shra_r.w %[temp3], %[temp3], 14 \n\t" |
| "b 4f \n\t" |
| " nop \n\t" |
| "2: \n\t" |
| "addu %[temp1], $zero, $zero \n\t" |
| "addu %[temp2], $zero, $zero \n\t" |
| "addu %[temp3], $zero, $zero \n\t" |
| "b 1f \n\t" |
| " nop \n\t" |
| "3: \n\t" |
| "addiu %[temp1], $0, 0x4000 \n\t" |
| "1: \n\t" |
| "sh %[temp1], 0(%[ptr]) \n\t" |
| "4: \n\t" |
| "sh %[temp2], 0(%[er_ptr]) \n\t" |
| "sh %[temp3], 2(%[er_ptr]) \n\t" |
| "addiu %[ptr], %[ptr], 2 \n\t" |
| "addiu %[er_ptr], %[er_ptr], 4 \n\t" |
| ".set pop \n\t" |
| : [temp1] "=&r"(temp1), [temp2] "=&r"(temp2), [temp3] "=&r"(temp3), |
| [temp4] "=&r"(temp4), [temp5] "=&r"(temp5), [ptr] "+r"(ptr), |
| [er_ptr] "+r"(er_ptr), [dr_ptr] "+r"(dr_ptr) |
| : |
| : "memory", "hi", "lo"); |
| #else |
| __asm __volatile( |
| ".set push \n\t" |
| ".set noreorder \n\t" |
| "lh %[temp1], 0(%[ptr]) \n\t" |
| "lh %[temp2], 0(%[dr_ptr]) \n\t" |
| "slti %[temp4], %[temp1], 0x4001 \n\t" |
| "beqz %[temp4], 3f \n\t" |
| " lh %[temp3], 2(%[dr_ptr]) \n\t" |
| "slti %[temp5], %[temp1], 3277 \n\t" |
| "bnez %[temp5], 2f \n\t" |
| " addiu %[dr_ptr], %[dr_ptr], 4 \n\t" |
| "mul %[temp2], %[temp2], %[temp1] \n\t" |
| "mul %[temp3], %[temp3], %[temp1] \n\t" |
| "addiu %[temp2], %[temp2], 0x2000 \n\t" |
| "addiu %[temp3], %[temp3], 0x2000 \n\t" |
| "sra %[temp2], %[temp2], 14 \n\t" |
| "sra %[temp3], %[temp3], 14 \n\t" |
| "b 4f \n\t" |
| " nop \n\t" |
| "2: \n\t" |
| "addu %[temp1], $zero, $zero \n\t" |
| "addu %[temp2], $zero, $zero \n\t" |
| "addu %[temp3], $zero, $zero \n\t" |
| "b 1f \n\t" |
| " nop \n\t" |
| "3: \n\t" |
| "addiu %[temp1], $0, 0x4000 \n\t" |
| "1: \n\t" |
| "sh %[temp1], 0(%[ptr]) \n\t" |
| "4: \n\t" |
| "sh %[temp2], 0(%[er_ptr]) \n\t" |
| "sh %[temp3], 2(%[er_ptr]) \n\t" |
| "addiu %[ptr], %[ptr], 2 \n\t" |
| "addiu %[er_ptr], %[er_ptr], 4 \n\t" |
| ".set pop \n\t" |
| : [temp1] "=&r"(temp1), [temp2] "=&r"(temp2), [temp3] "=&r"(temp3), |
| [temp4] "=&r"(temp4), [temp5] "=&r"(temp5), [ptr] "+r"(ptr), |
| [er_ptr] "+r"(er_ptr), [dr_ptr] "+r"(dr_ptr) |
| : |
| : "memory", "hi", "lo"); |
| #endif |
| } |
| } |
| } else { |
| // multiply with Wiener coefficients |
| for (i = 0; i < PART_LEN1; i++) { |
| efw[i].real = (int16_t)( |
| WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(dfw[i].real, hnl[i], 14)); |
| efw[i].imag = (int16_t)( |
| WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(dfw[i].imag, hnl[i], 14)); |
| } |
| } |
| |
| if (aecm->cngMode == AecmTrue) { |
| ComfortNoise(aecm, ptrDfaClean, efw, hnl); |
| } |
| |
| InverseFFTAndWindow(aecm, fft, efw, output, nearendClean); |
| |
| return 0; |
| } |
| |
| // Generate comfort noise and add to output signal. |
| static void ComfortNoise(AecmCore* aecm, |
| const uint16_t* dfa, |
| ComplexInt16* out, |
| const int16_t* lambda) { |
| int16_t i; |
| int16_t tmp16, tmp161, tmp162, tmp163, nrsh1, nrsh2; |
| int32_t tmp32, tmp321, tnoise, tnoise1; |
| int32_t tmp322, tmp323, *tmp1; |
| int16_t* dfap; |
| int16_t* lambdap; |
| const int32_t c2049 = 2049; |
| const int32_t c359 = 359; |
| const int32_t c114 = ONE_Q14; |
| |
| int16_t randW16[PART_LEN]; |
| int16_t uReal[PART_LEN1]; |
| int16_t uImag[PART_LEN1]; |
| int32_t outLShift32; |
| |
| int16_t shiftFromNearToNoise = kNoiseEstQDomain - aecm->dfaCleanQDomain; |
| int16_t minTrackShift = 9; |
| |
| RTC_DCHECK_GE(shiftFromNearToNoise, 0); |
| RTC_DCHECK_LT(shiftFromNearToNoise, 16); |
| |
| if (aecm->noiseEstCtr < 100) { |
| // Track the minimum more quickly initially. |
| aecm->noiseEstCtr++; |
| minTrackShift = 6; |
| } |
| |
| // Generate a uniform random array on [0 2^15-1]. |
| WebRtcSpl_RandUArray(randW16, PART_LEN, &aecm->seed); |
| int16_t* randW16p = (int16_t*)randW16; |
| #if defined(MIPS_DSP_R1_LE) |
| int16_t* kCosTablep = (int16_t*)WebRtcAecm_kCosTable; |
| int16_t* kSinTablep = (int16_t*)WebRtcAecm_kSinTable; |
| #endif // #if defined(MIPS_DSP_R1_LE) |
| tmp1 = (int32_t*)aecm->noiseEst + 1; |
| dfap = (int16_t*)dfa + 1; |
| lambdap = (int16_t*)lambda + 1; |
| // Estimate noise power. |
| for (i = 1; i < PART_LEN1; i += 2) { |
| // Shift to the noise domain. |
| __asm __volatile( |
| "lh %[tmp32], 0(%[dfap]) \n\t" |
| "lw %[tnoise], 0(%[tmp1]) \n\t" |
| "sllv %[outLShift32], %[tmp32], %[shiftFromNearToNoise] \n\t" |
| : [tmp32] "=&r"(tmp32), [outLShift32] "=r"(outLShift32), |
| [tnoise] "=&r"(tnoise) |
| : [tmp1] "r"(tmp1), [dfap] "r"(dfap), |
| [shiftFromNearToNoise] "r"(shiftFromNearToNoise) |
| : "memory"); |
| |
| if (outLShift32 < tnoise) { |
| // Reset "too low" counter |
| aecm->noiseEstTooLowCtr[i] = 0; |
| // Track the minimum. |
| if (tnoise < (1 << minTrackShift)) { |
| // For small values, decrease noiseEst[i] every |
| // |kNoiseEstIncCount| block. The regular approach below can not |
| // go further down due to truncation. |
| aecm->noiseEstTooHighCtr[i]++; |
| if (aecm->noiseEstTooHighCtr[i] >= kNoiseEstIncCount) { |
| tnoise--; |
| aecm->noiseEstTooHighCtr[i] = 0; // Reset the counter |
| } |
| } else { |
| __asm __volatile( |
| "subu %[tmp32], %[tnoise], %[outLShift32] \n\t" |
| "srav %[tmp32], %[tmp32], %[minTrackShift] \n\t" |
| "subu %[tnoise], %[tnoise], %[tmp32] \n\t" |
| : [tmp32] "=&r"(tmp32), [tnoise] "+r"(tnoise) |
| : |
| [outLShift32] "r"(outLShift32), [minTrackShift] "r"(minTrackShift)); |
| } |
| } else { |
| // Reset "too high" counter |
| aecm->noiseEstTooHighCtr[i] = 0; |
| // Ramp slowly upwards until we hit the minimum again. |
| if ((tnoise >> 19) <= 0) { |
| if ((tnoise >> 11) > 0) { |
| // Large enough for relative increase |
| __asm __volatile( |
| "mul %[tnoise], %[tnoise], %[c2049] \n\t" |
| "sra %[tnoise], %[tnoise], 11 \n\t" |
| : [tnoise] "+r"(tnoise) |
| : [c2049] "r"(c2049) |
| : "hi", "lo"); |
| } else { |
| // Make incremental increases based on size every |
| // |kNoiseEstIncCount| block |
| aecm->noiseEstTooLowCtr[i]++; |
| if (aecm->noiseEstTooLowCtr[i] >= kNoiseEstIncCount) { |
| __asm __volatile( |
| "sra %[tmp32], %[tnoise], 9 \n\t" |
| "addi %[tnoise], %[tnoise], 1 \n\t" |
| "addu %[tnoise], %[tnoise], %[tmp32] \n\t" |
| : [tnoise] "+r"(tnoise), [tmp32] "=&r"(tmp32) |
| :); |
| aecm->noiseEstTooLowCtr[i] = 0; // Reset counter |
| } |
| } |
| } else { |
| // Avoid overflow. |
| // Multiplication with 2049 will cause wrap around. Scale |
| // down first and then multiply |
| __asm __volatile( |
| "sra %[tnoise], %[tnoise], 11 \n\t" |
| "mul %[tnoise], %[tnoise], %[c2049] \n\t" |
| : [tnoise] "+r"(tnoise) |
| : [c2049] "r"(c2049) |
| : "hi", "lo"); |
| } |
| } |
| |
| // Shift to the noise domain. |
| __asm __volatile( |
| "lh %[tmp32], 2(%[dfap]) \n\t" |
| "lw %[tnoise1], 4(%[tmp1]) \n\t" |
| "addiu %[dfap], %[dfap], 4 \n\t" |
| "sllv %[outLShift32], %[tmp32], %[shiftFromNearToNoise] \n\t" |
| : [tmp32] "=&r"(tmp32), [dfap] "+r"(dfap), |
| [outLShift32] "=r"(outLShift32), [tnoise1] "=&r"(tnoise1) |
| : [tmp1] "r"(tmp1), [shiftFromNearToNoise] "r"(shiftFromNearToNoise) |
| : "memory"); |
| |
| if (outLShift32 < tnoise1) { |
| // Reset "too low" counter |
| aecm->noiseEstTooLowCtr[i + 1] = 0; |
| // Track the minimum. |
| if (tnoise1 < (1 << minTrackShift)) { |
| // For small values, decrease noiseEst[i] every |
| // |kNoiseEstIncCount| block. The regular approach below can not |
| // go further down due to truncation. |
| aecm->noiseEstTooHighCtr[i + 1]++; |
| if (aecm->noiseEstTooHighCtr[i + 1] >= kNoiseEstIncCount) { |
| tnoise1--; |
| aecm->noiseEstTooHighCtr[i + 1] = 0; // Reset the counter |
| } |
| } else { |
| __asm __volatile( |
| "subu %[tmp32], %[tnoise1], %[outLShift32] \n\t" |
| "srav %[tmp32], %[tmp32], %[minTrackShift] \n\t" |
| "subu %[tnoise1], %[tnoise1], %[tmp32] \n\t" |
| : [tmp32] "=&r"(tmp32), [tnoise1] "+r"(tnoise1) |
| : |
| [outLShift32] "r"(outLShift32), [minTrackShift] "r"(minTrackShift)); |
| } |
| } else { |
| // Reset "too high" counter |
| aecm->noiseEstTooHighCtr[i + 1] = 0; |
| // Ramp slowly upwards until we hit the minimum again. |
| if ((tnoise1 >> 19) <= 0) { |
| if ((tnoise1 >> 11) > 0) { |
| // Large enough for relative increase |
| __asm __volatile( |
| "mul %[tnoise1], %[tnoise1], %[c2049] \n\t" |
| "sra %[tnoise1], %[tnoise1], 11 \n\t" |
| : [tnoise1] "+r"(tnoise1) |
| : [c2049] "r"(c2049) |
| : "hi", "lo"); |
| } else { |
| // Make incremental increases based on size every |
| // |kNoiseEstIncCount| block |
| aecm->noiseEstTooLowCtr[i + 1]++; |
| if (aecm->noiseEstTooLowCtr[i + 1] >= kNoiseEstIncCount) { |
| __asm __volatile( |
| "sra %[tmp32], %[tnoise1], 9 \n\t" |
| "addi %[tnoise1], %[tnoise1], 1 \n\t" |
| "addu %[tnoise1], %[tnoise1], %[tmp32] \n\t" |
| : [tnoise1] "+r"(tnoise1), [tmp32] "=&r"(tmp32) |
| :); |
| aecm->noiseEstTooLowCtr[i + 1] = 0; // Reset counter |
| } |
| } |
| } else { |
| // Avoid overflow. |
| // Multiplication with 2049 will cause wrap around. Scale |
| // down first and then multiply |
| __asm __volatile( |
| "sra %[tnoise1], %[tnoise1], 11 \n\t" |
| "mul %[tnoise1], %[tnoise1], %[c2049] \n\t" |
| : [tnoise1] "+r"(tnoise1) |
| : [c2049] "r"(c2049) |
| : "hi", "lo"); |
| } |
| } |
| |
| __asm __volatile( |
| "lh %[tmp16], 0(%[lambdap]) \n\t" |
| "lh %[tmp161], 2(%[lambdap]) \n\t" |
| "sw %[tnoise], 0(%[tmp1]) \n\t" |
| "sw %[tnoise1], 4(%[tmp1]) \n\t" |
| "subu %[tmp16], %[c114], %[tmp16] \n\t" |
| "subu %[tmp161], %[c114], %[tmp161] \n\t" |
| "srav %[tmp32], %[tnoise], %[shiftFromNearToNoise] \n\t" |
| "srav %[tmp321], %[tnoise1], %[shiftFromNearToNoise] \n\t" |
| "addiu %[lambdap], %[lambdap], 4 \n\t" |
| "addiu %[tmp1], %[tmp1], 8 \n\t" |
| : [tmp16] "=&r"(tmp16), [tmp161] "=&r"(tmp161), [tmp1] "+r"(tmp1), |
| [tmp32] "=&r"(tmp32), [tmp321] "=&r"(tmp321), [lambdap] "+r"(lambdap) |
| : [tnoise] "r"(tnoise), [tnoise1] "r"(tnoise1), [c114] "r"(c114), |
| [shiftFromNearToNoise] "r"(shiftFromNearToNoise) |
| : "memory"); |
| |
| if (tmp32 > 32767) { |
| tmp32 = 32767; |
| aecm->noiseEst[i] = tmp32 << shiftFromNearToNoise; |
| } |
| if (tmp321 > 32767) { |
| tmp321 = 32767; |
| aecm->noiseEst[i + 1] = tmp321 << shiftFromNearToNoise; |
| } |
| |
| __asm __volatile( |
| "mul %[tmp32], %[tmp32], %[tmp16] \n\t" |
| "mul %[tmp321], %[tmp321], %[tmp161] \n\t" |
| "sra %[nrsh1], %[tmp32], 14 \n\t" |
| "sra %[nrsh2], %[tmp321], 14 \n\t" |
| : [nrsh1] "=&r"(nrsh1), [nrsh2] "=r"(nrsh2) |
| : [tmp16] "r"(tmp16), [tmp161] "r"(tmp161), [tmp32] "r"(tmp32), |
| [tmp321] "r"(tmp321) |
| : "memory", "hi", "lo"); |
| |
| __asm __volatile( |
| "lh %[tmp32], 0(%[randW16p]) \n\t" |
| "lh %[tmp321], 2(%[randW16p]) \n\t" |
| "addiu %[randW16p], %[randW16p], 4 \n\t" |
| "mul %[tmp32], %[tmp32], %[c359] \n\t" |
| "mul %[tmp321], %[tmp321], %[c359] \n\t" |
| "sra %[tmp16], %[tmp32], 15 \n\t" |
| "sra %[tmp161], %[tmp321], 15 \n\t" |
| : [randW16p] "+r"(randW16p), [tmp32] "=&r"(tmp32), [tmp16] "=r"(tmp16), |
| [tmp161] "=r"(tmp161), [tmp321] "=&r"(tmp321) |
| : [c359] "r"(c359) |
| : "memory", "hi", "lo"); |
| |
| #if !defined(MIPS_DSP_R1_LE) |
| tmp32 = WebRtcAecm_kCosTable[tmp16]; |
| tmp321 = WebRtcAecm_kSinTable[tmp16]; |
| tmp322 = WebRtcAecm_kCosTable[tmp161]; |
| tmp323 = WebRtcAecm_kSinTable[tmp161]; |
| #else |
| __asm __volatile( |
| "sll %[tmp16], %[tmp16], 1 \n\t" |
| "sll %[tmp161], %[tmp161], 1 \n\t" |
| "lhx %[tmp32], %[tmp16](%[kCosTablep]) \n\t" |
| "lhx %[tmp321], %[tmp16](%[kSinTablep]) \n\t" |
| "lhx %[tmp322], %[tmp161](%[kCosTablep]) \n\t" |
| "lhx %[tmp323], %[tmp161](%[kSinTablep]) \n\t" |
| : [tmp32] "=&r"(tmp32), [tmp321] "=&r"(tmp321), [tmp322] "=&r"(tmp322), |
| [tmp323] "=&r"(tmp323) |
| : [kCosTablep] "r"(kCosTablep), [tmp16] "r"(tmp16), |
| [tmp161] "r"(tmp161), [kSinTablep] "r"(kSinTablep) |
| : "memory"); |
| #endif |
| __asm __volatile( |
| "mul %[tmp32], %[tmp32], %[nrsh1] \n\t" |
| "negu %[tmp162], %[nrsh1] \n\t" |
| "mul %[tmp322], %[tmp322], %[nrsh2] \n\t" |
| "negu %[tmp163], %[nrsh2] \n\t" |
| "sra %[tmp32], %[tmp32], 13 \n\t" |
| "mul %[tmp321], %[tmp321], %[tmp162] \n\t" |
| "sra %[tmp322], %[tmp322], 13 \n\t" |
| "mul %[tmp323], %[tmp323], %[tmp163] \n\t" |
| "sra %[tmp321], %[tmp321], 13 \n\t" |
| "sra %[tmp323], %[tmp323], 13 \n\t" |
| : [tmp32] "+r"(tmp32), [tmp321] "+r"(tmp321), [tmp162] "=&r"(tmp162), |
| [tmp322] "+r"(tmp322), [tmp323] "+r"(tmp323), [tmp163] "=&r"(tmp163) |
| : [nrsh1] "r"(nrsh1), [nrsh2] "r"(nrsh2) |
| : "hi", "lo"); |
| // Tables are in Q13. |
| uReal[i] = (int16_t)tmp32; |
| uImag[i] = (int16_t)tmp321; |
| uReal[i + 1] = (int16_t)tmp322; |
| uImag[i + 1] = (int16_t)tmp323; |
| } |
| |
| int32_t tt, sgn; |
| tt = out[0].real; |
| sgn = ((int)tt) >> 31; |
| out[0].real = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| tt = out[0].imag; |
| sgn = ((int)tt) >> 31; |
| out[0].imag = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| for (i = 1; i < PART_LEN; i++) { |
| tt = out[i].real + uReal[i]; |
| sgn = ((int)tt) >> 31; |
| out[i].real = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| tt = out[i].imag + uImag[i]; |
| sgn = ((int)tt) >> 31; |
| out[i].imag = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| } |
| tt = out[PART_LEN].real + uReal[PART_LEN]; |
| sgn = ((int)tt) >> 31; |
| out[PART_LEN].real = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| tt = out[PART_LEN].imag; |
| sgn = ((int)tt) >> 31; |
| out[PART_LEN].imag = sgn == (int16_t)(tt >> 15) ? (int16_t)tt : (16384 ^ sgn); |
| } |
