1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "webrtc/modules/audio_coding/neteq/normal.h" 12 13 #include <string.h> // memset, memcpy 14 15 #include <algorithm> // min 16 17 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h" 18 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h" 19 #include "webrtc/modules/audio_coding/codecs/cng/webrtc_cng.h" 20 #include "webrtc/modules/audio_coding/neteq/audio_multi_vector.h" 21 #include "webrtc/modules/audio_coding/neteq/background_noise.h" 22 #include "webrtc/modules/audio_coding/neteq/decoder_database.h" 23 #include "webrtc/modules/audio_coding/neteq/expand.h" 24 25 namespace webrtc { 26 27 int Normal::Process(const int16_t* input, 28 size_t length, 29 Modes last_mode, 30 int16_t* external_mute_factor_array, 31 AudioMultiVector* output) { 32 if (length == 0) { 33 // Nothing to process. 34 output->Clear(); 35 return static_cast<int>(length); 36 } 37 38 assert(output->Empty()); 39 // Output should be empty at this point. 40 if (length % output->Channels() != 0) { 41 // The length does not match the number of channels. 42 output->Clear(); 43 return 0; 44 } 45 output->PushBackInterleaved(input, length); 46 int16_t* signal = &(*output)[0][0]; 47 48 const int fs_mult = fs_hz_ / 8000; 49 assert(fs_mult > 0); 50 // fs_shift = log2(fs_mult), rounded down. 51 // Note that |fs_shift| is not "exact" for 48 kHz. 52 // TODO(hlundin): Investigate this further. 53 const int fs_shift = 30 - WebRtcSpl_NormW32(fs_mult); 54 55 // Check if last RecOut call resulted in an Expand. If so, we have to take 56 // care of some cross-fading and unmuting. 57 if (last_mode == kModeExpand) { 58 // Generate interpolation data using Expand. 59 // First, set Expand parameters to appropriate values. 60 expand_->SetParametersForNormalAfterExpand(); 61 62 // Call Expand. 63 AudioMultiVector expanded(output->Channels()); 64 expand_->Process(&expanded); 65 expand_->Reset(); 66 67 for (size_t channel_ix = 0; channel_ix < output->Channels(); ++channel_ix) { 68 // Adjust muting factor (main muting factor times expand muting factor). 69 external_mute_factor_array[channel_ix] = static_cast<int16_t>( 70 (external_mute_factor_array[channel_ix] * 71 expand_->MuteFactor(channel_ix)) >> 14); 72 73 int16_t* signal = &(*output)[channel_ix][0]; 74 size_t length_per_channel = length / output->Channels(); 75 // Find largest absolute value in new data. 76 int16_t decoded_max = 77 WebRtcSpl_MaxAbsValueW16(signal, length_per_channel); 78 // Adjust muting factor if needed (to BGN level). 79 size_t energy_length = 80 std::min(static_cast<size_t>(fs_mult * 64), length_per_channel); 81 int scaling = 6 + fs_shift 82 - WebRtcSpl_NormW32(decoded_max * decoded_max); 83 scaling = std::max(scaling, 0); // |scaling| should always be >= 0. 84 int32_t energy = WebRtcSpl_DotProductWithScale(signal, signal, 85 energy_length, scaling); 86 int32_t scaled_energy_length = 87 static_cast<int32_t>(energy_length >> scaling); 88 if (scaled_energy_length > 0) { 89 energy = energy / scaled_energy_length; 90 } else { 91 energy = 0; 92 } 93 94 int mute_factor; 95 if ((energy != 0) && 96 (energy > background_noise_.Energy(channel_ix))) { 97 // Normalize new frame energy to 15 bits. 98 scaling = WebRtcSpl_NormW32(energy) - 16; 99 // We want background_noise_.energy() / energy in Q14. 100 int32_t bgn_energy = 101 background_noise_.Energy(channel_ix) << (scaling+14); 102 int16_t energy_scaled = static_cast<int16_t>(energy << scaling); 103 int32_t ratio = WebRtcSpl_DivW32W16(bgn_energy, energy_scaled); 104 mute_factor = WebRtcSpl_SqrtFloor(ratio << 14); 105 } else { 106 mute_factor = 16384; // 1.0 in Q14. 107 } 108 if (mute_factor > external_mute_factor_array[channel_ix]) { 109 external_mute_factor_array[channel_ix] = 110 static_cast<int16_t>(std::min(mute_factor, 16384)); 111 } 112 113 // If muted increase by 0.64 for every 20 ms (NB/WB 0.0040/0.0020 in Q14). 114 int increment = 64 / fs_mult; 115 for (size_t i = 0; i < length_per_channel; i++) { 116 // Scale with mute factor. 117 assert(channel_ix < output->Channels()); 118 assert(i < output->Size()); 119 int32_t scaled_signal = (*output)[channel_ix][i] * 120 external_mute_factor_array[channel_ix]; 121 // Shift 14 with proper rounding. 122 (*output)[channel_ix][i] = 123 static_cast<int16_t>((scaled_signal + 8192) >> 14); 124 // Increase mute_factor towards 16384. 125 external_mute_factor_array[channel_ix] = static_cast<int16_t>(std::min( 126 external_mute_factor_array[channel_ix] + increment, 16384)); 127 } 128 129 // Interpolate the expanded data into the new vector. 130 // (NB/WB/SWB32/SWB48 8/16/32/48 samples.) 131 assert(fs_shift < 3); // Will always be 0, 1, or, 2. 132 increment = 4 >> fs_shift; 133 int fraction = increment; 134 for (size_t i = 0; i < static_cast<size_t>(8 * fs_mult); i++) { 135 // TODO(hlundin): Add 16 instead of 8 for correct rounding. Keeping 8 136 // now for legacy bit-exactness. 137 assert(channel_ix < output->Channels()); 138 assert(i < output->Size()); 139 (*output)[channel_ix][i] = 140 static_cast<int16_t>((fraction * (*output)[channel_ix][i] + 141 (32 - fraction) * expanded[channel_ix][i] + 8) >> 5); 142 fraction += increment; 143 } 144 } 145 } else if (last_mode == kModeRfc3389Cng) { 146 assert(output->Channels() == 1); // Not adapted for multi-channel yet. 147 static const size_t kCngLength = 32; 148 int16_t cng_output[kCngLength]; 149 // Reset mute factor and start up fresh. 150 external_mute_factor_array[0] = 16384; 151 AudioDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder(); 152 153 if (cng_decoder) { 154 // Generate long enough for 32kHz. 155 if (WebRtcCng_Generate(cng_decoder->CngDecoderInstance(), cng_output, 156 kCngLength, 0) < 0) { 157 // Error returned; set return vector to all zeros. 158 memset(cng_output, 0, sizeof(cng_output)); 159 } 160 } else { 161 // If no CNG instance is defined, just copy from the decoded data. 162 // (This will result in interpolating the decoded with itself.) 163 memcpy(cng_output, signal, fs_mult * 8 * sizeof(int16_t)); 164 } 165 // Interpolate the CNG into the new vector. 166 // (NB/WB/SWB32/SWB48 8/16/32/48 samples.) 167 assert(fs_shift < 3); // Will always be 0, 1, or, 2. 168 int16_t increment = 4 >> fs_shift; 169 int16_t fraction = increment; 170 for (size_t i = 0; i < static_cast<size_t>(8 * fs_mult); i++) { 171 // TODO(hlundin): Add 16 instead of 8 for correct rounding. Keeping 8 now 172 // for legacy bit-exactness. 173 signal[i] = 174 (fraction * signal[i] + (32 - fraction) * cng_output[i] + 8) >> 5; 175 fraction += increment; 176 } 177 } else if (external_mute_factor_array[0] < 16384) { 178 // Previous was neither of Expand, FadeToBGN or RFC3389_CNG, but we are 179 // still ramping up from previous muting. 180 // If muted increase by 0.64 for every 20 ms (NB/WB 0.0040/0.0020 in Q14). 181 int increment = 64 / fs_mult; 182 size_t length_per_channel = length / output->Channels(); 183 for (size_t i = 0; i < length_per_channel; i++) { 184 for (size_t channel_ix = 0; channel_ix < output->Channels(); 185 ++channel_ix) { 186 // Scale with mute factor. 187 assert(channel_ix < output->Channels()); 188 assert(i < output->Size()); 189 int32_t scaled_signal = (*output)[channel_ix][i] * 190 external_mute_factor_array[channel_ix]; 191 // Shift 14 with proper rounding. 192 (*output)[channel_ix][i] = 193 static_cast<int16_t>((scaled_signal + 8192) >> 14); 194 // Increase mute_factor towards 16384. 195 external_mute_factor_array[channel_ix] = static_cast<int16_t>(std::min( 196 16384, external_mute_factor_array[channel_ix] + increment)); 197 } 198 } 199 } 200 201 return static_cast<int>(length); 202 } 203 204 } // namespace webrtc 205
