• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
Process(const int16_t * input,size_t length,Modes last_mode,int16_t * external_mute_factor_array,AudioMultiVector * output)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