| /* |
| * Copyright (c) 2011 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. |
| */ |
| |
| /* |
| * This file contains the function for handling "normal" speech operation. |
| */ |
| #include "dsp.h" |
| |
| #include "signal_processing_library.h" |
| |
| #include "dsp_helpfunctions.h" |
| |
| /* Scratch usage: |
| |
| Type Name size startpos endpos |
| int16_t pw16_expanded 125*fs/8000 0 125*fs/8000-1 |
| |
| func WebRtcNetEQ_Expand 40+370*fs/8000 125*fs/8000 39+495*fs/8000 |
| |
| Total: 40+495*fs/8000 |
| */ |
| |
| #define SCRATCH_PW16_EXPANDED 0 |
| #if (defined(NETEQ_48KHZ_WIDEBAND)) |
| #define SCRATCH_NETEQ_EXPAND 756 |
| #elif (defined(NETEQ_32KHZ_WIDEBAND)) |
| #define SCRATCH_NETEQ_EXPAND 504 |
| #elif (defined(NETEQ_WIDEBAND)) |
| #define SCRATCH_NETEQ_EXPAND 252 |
| #else /* NB */ |
| #define SCRATCH_NETEQ_EXPAND 126 |
| #endif |
| |
| /**************************************************************************** |
| * WebRtcNetEQ_Normal(...) |
| * |
| * This function has the possibility to modify data that is played out in Normal |
| * mode, for example adjust the gain of the signal. The length of the signal |
| * can not be changed. |
| * |
| * Input: |
| * - inst : NetEq instance, i.e. the user that requests more |
| * speech/audio data |
| * - scratchPtr : Pointer to scratch vector |
| * - decoded : Pointer to vector of new data from decoder |
| * (Vector contents may be altered by the function) |
| * - len : Number of input samples |
| * |
| * Output: |
| * - inst : Updated user information |
| * - outData : Pointer to a memory space where the output data |
| * should be stored |
| * - pw16_len : Pointer to variable where the number of samples |
| * produced will be written |
| * |
| * Return value : >=0 - Number of samples written to outData |
| * -1 - Error |
| */ |
| |
| int WebRtcNetEQ_Normal(DSPInst_t *inst, |
| #ifdef SCRATCH |
| int16_t *pw16_scratchPtr, |
| #endif |
| int16_t *pw16_decoded, int16_t len, |
| int16_t *pw16_outData, int16_t *pw16_len) |
| { |
| |
| int i; |
| int16_t fs_mult; |
| int16_t fs_shift; |
| int32_t w32_En_speech; |
| int16_t enLen; |
| int16_t w16_muted; |
| int16_t w16_inc, w16_frac; |
| int16_t w16_tmp; |
| int32_t w32_tmp; |
| |
| /* Sanity check */ |
| if (len < 0) |
| { |
| /* Cannot have negative length of input vector */ |
| return (-1); |
| } |
| |
| if (len == 0) |
| { |
| /* Still got some data to play => continue with the same mode */ |
| *pw16_len = len; |
| return (len); |
| } |
| |
| fs_mult = WebRtcSpl_DivW32W16ResW16(inst->fs, 8000); |
| fs_shift = 30 - WebRtcSpl_NormW32(fs_mult); /* Note that this is not "exact" for 48kHz */ |
| |
| /* |
| * Check if last RecOut call resulted in an Expand or a FadeToBGN. If so, we have to take |
| * care of some cross-fading and unmuting. |
| */ |
| if (inst->w16_mode == MODE_EXPAND || inst->w16_mode == MODE_FADE_TO_BGN) |
| { |
| |
| /* Define memory where temporary result from Expand algorithm can be stored. */ |
| #ifdef SCRATCH |
| int16_t *pw16_expanded = pw16_scratchPtr + SCRATCH_PW16_EXPANDED; |
| #else |
| int16_t pw16_expanded[FSMULT * 125]; |
| #endif |
| int16_t expandedLen = 0; |
| int16_t w16_decodedMax; |
| |
| /* Find largest value in new data */ |
| w16_decodedMax = WebRtcSpl_MaxAbsValueW16(pw16_decoded, (int16_t) len); |
| |
| /* Generate interpolation data using Expand */ |
| /* First, set Expand parameters to appropriate values. */ |
| inst->ExpandInst.w16_lagsPosition = 0; |
| inst->ExpandInst.w16_lagsDirection = 0; |
| inst->ExpandInst.w16_stopMuting = 1; /* Do not mute signal any more */ |
| |
| /* Call Expand */ |
| WebRtcNetEQ_Expand(inst, |
| #ifdef SCRATCH |
| pw16_scratchPtr + SCRATCH_NETEQ_EXPAND, |
| #endif |
| pw16_expanded, &expandedLen, (int16_t) (inst->w16_mode == MODE_FADE_TO_BGN)); |
| |
| inst->ExpandInst.w16_stopMuting = 0; /* Restore value */ |
| inst->ExpandInst.w16_consecExp = 0; /* Last was not Expand any more */ |
| |
| /* Adjust muting factor (main muting factor times expand muting factor) */ |
| if (inst->w16_mode == MODE_FADE_TO_BGN) |
| { |
| /* If last mode was FadeToBGN, the mute factor should be zero. */ |
| inst->w16_muteFactor = 0; |
| } |
| else |
| { |
| /* w16_muteFactor * w16_expandMuteFactor */ |
| inst->w16_muteFactor |
| = (int16_t) WEBRTC_SPL_MUL_16_16_RSFT(inst->w16_muteFactor, |
| inst->ExpandInst.w16_expandMuteFactor, 14); |
| } |
| |
| /* Adjust muting factor if needed (to BGN level) */ |
| enLen = WEBRTC_SPL_MIN(fs_mult<<6, len); /* min( fs_mult * 64, len ) */ |
| w16_tmp = 6 + fs_shift - WebRtcSpl_NormW32( |
| WEBRTC_SPL_MUL_16_16(w16_decodedMax, w16_decodedMax)); |
| w16_tmp = WEBRTC_SPL_MAX(w16_tmp, 0); |
| w32_En_speech = WebRtcNetEQ_DotW16W16(pw16_decoded, pw16_decoded, enLen, w16_tmp); |
| w32_En_speech = WebRtcSpl_DivW32W16(w32_En_speech, (int16_t) (enLen >> w16_tmp)); |
| |
| if ((w32_En_speech != 0) && (w32_En_speech > inst->BGNInst.w32_energy)) |
| { |
| /* Normalize new frame energy to 15 bits */ |
| w16_tmp = WebRtcSpl_NormW32(w32_En_speech) - 16; |
| /* we want inst->BGNInst.energy/En_speech in Q14 */ |
| w32_tmp = WEBRTC_SPL_SHIFT_W32(inst->BGNInst.w32_energy, (w16_tmp+14)); |
| w16_tmp = (int16_t) WEBRTC_SPL_SHIFT_W32(w32_En_speech, w16_tmp); |
| w16_tmp = (int16_t) WebRtcSpl_DivW32W16(w32_tmp, w16_tmp); |
| w16_muted = (int16_t) WebRtcSpl_SqrtFloor( |
| WEBRTC_SPL_LSHIFT_W32((int32_t) w16_tmp, |
| 14)); /* w16_muted in Q14 (sqrt(Q28)) */ |
| } |
| else |
| { |
| w16_muted = 16384; /* 1.0 in Q14 */ |
| } |
| if (w16_muted > inst->w16_muteFactor) |
| { |
| inst->w16_muteFactor = WEBRTC_SPL_MIN(w16_muted, 16384); |
| } |
| |
| /* If muted increase by 0.64 for every 20 ms (NB/WB 0.0040/0.0020 in Q14) */ |
| w16_inc = WebRtcSpl_DivW32W16ResW16(64, fs_mult); |
| for (i = 0; i < len; i++) |
| { |
| /* scale with mute factor */ |
| w32_tmp = WEBRTC_SPL_MUL_16_16(pw16_decoded[i], inst->w16_muteFactor); |
| /* shift 14 with proper rounding */ |
| pw16_decoded[i] = (int16_t) WEBRTC_SPL_RSHIFT_W32((w32_tmp + 8192), 14); |
| /* increase mute_factor towards 16384 */ |
| inst->w16_muteFactor = WEBRTC_SPL_MIN(16384, (inst->w16_muteFactor+w16_inc)); |
| } |
| |
| /* |
| * Interpolate the expanded data into the new vector |
| * (NB/WB/SWB32/SWB40 8/16/32/32 samples) |
| */ |
| fs_shift = WEBRTC_SPL_MIN(3, fs_shift); /* Set to 3 for >32kHz */ |
| w16_inc = 4 >> fs_shift; |
| w16_frac = w16_inc; |
| for (i = 0; i < 8 * fs_mult; i++) |
| { |
| pw16_decoded[i] = (int16_t) WEBRTC_SPL_RSHIFT_W32( |
| (WEBRTC_SPL_MUL_16_16(w16_frac, pw16_decoded[i]) + |
| WEBRTC_SPL_MUL_16_16((32 - w16_frac), pw16_expanded[i]) + 8), |
| 5); |
| w16_frac += w16_inc; |
| } |
| |
| #ifdef NETEQ_CNG_CODEC |
| } |
| else if (inst->w16_mode==MODE_RFC3389CNG) |
| { /* previous was RFC 3389 CNG...*/ |
| int16_t pw16_CngInterp[32]; |
| /* Reset mute factor and start up fresh */ |
| inst->w16_muteFactor = 16384; |
| if (inst->CNG_Codec_inst != NULL) |
| { |
| /* Generate long enough for 32kHz */ |
| if(WebRtcCng_Generate(inst->CNG_Codec_inst,pw16_CngInterp, 32, 0)<0) |
| { |
| /* error returned; set return vector to all zeros */ |
| WebRtcSpl_MemSetW16(pw16_CngInterp, 0, 32); |
| } |
| } |
| else |
| { |
| /* |
| * If no CNG instance is defined, just copy from the decoded data. |
| * (This will result in interpolating the decoded with itself.) |
| */ |
| WEBRTC_SPL_MEMCPY_W16(pw16_CngInterp, pw16_decoded, fs_mult * 8); |
| } |
| /* |
| * Interpolate the CNG into the new vector |
| * (NB/WB/SWB32kHz/SWB48kHz 8/16/32/32 samples) |
| */ |
| fs_shift = WEBRTC_SPL_MIN(3, fs_shift); /* Set to 3 for >32kHz */ |
| w16_inc = 4>>fs_shift; |
| w16_frac = w16_inc; |
| for (i = 0; i < 8 * fs_mult; i++) |
| { |
| pw16_decoded[i] = (int16_t) WEBRTC_SPL_RSHIFT_W32( |
| (WEBRTC_SPL_MUL_16_16(w16_frac, pw16_decoded[i]) + |
| WEBRTC_SPL_MUL_16_16((32-w16_frac), pw16_CngInterp[i]) + 8), |
| 5); |
| w16_frac += w16_inc; |
| } |
| #endif |
| |
| } |
| else if (inst->w16_muteFactor < 16384) |
| { |
| /* |
| * Previous was neither of Expand, FadeToBGN or RFC3389_CNG, but we are still |
| * ramping up from previous muting. |
| * If muted increase by 0.64 for every 20 ms (NB/WB 0.0040/0.0020 in Q14) |
| */ |
| w16_inc = WebRtcSpl_DivW32W16ResW16(64, fs_mult); |
| for (i = 0; i < len; i++) |
| { |
| /* scale with mute factor */ |
| w32_tmp = WEBRTC_SPL_MUL_16_16(pw16_decoded[i], inst->w16_muteFactor); |
| /* shift 14 with proper rounding */ |
| pw16_decoded[i] = (int16_t) WEBRTC_SPL_RSHIFT_W32((w32_tmp + 8192), 14); |
| /* increase mute_factor towards 16384 */ |
| inst->w16_muteFactor = WEBRTC_SPL_MIN(16384, (inst->w16_muteFactor+w16_inc)); |
| } |
| } |
| |
| /* Copy data to other buffer */WEBRTC_SPL_MEMMOVE_W16(pw16_outData, pw16_decoded, len); |
| |
| inst->w16_mode = MODE_NORMAL; |
| *pw16_len = len; |
| return (len); |
| |
| } |
| |
| #undef SCRATCH_PW16_EXPANDED |
| #undef SCRATCH_NETEQ_EXPAND |
| |
