1/*
2 *  Copyright (c) 2011 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/*
12 * This file includes the implementation of the internal filterbank associated functions.
13 * For function description, see vad_filterbank.h.
14 */
15
16#include "vad_filterbank.h"
17
18#include "signal_processing_library.h"
19#include "typedefs.h"
20#include "vad_defines.h"
21
22// Constant 160*log10(2) in Q9
23static const int16_t kLogConst = 24660;
24
25// Coefficients used by WebRtcVad_HpOutput, Q14
26static const int16_t kHpZeroCoefs[3] = { 6631, -13262, 6631 };
27static const int16_t kHpPoleCoefs[3] = { 16384, -7756, 5620 };
28
29// Allpass filter coefficients, upper and lower, in Q15
30// Upper: 0.64, Lower: 0.17
31static const int16_t kAllPassCoefsQ15[2] = { 20972, 5571 };
32
33// Adjustment for division with two in WebRtcVad_SplitFilter
34static const int16_t kOffsetVector[6] = { 368, 368, 272, 176, 176, 176 };
35
36void WebRtcVad_HpOutput(int16_t* in_vector,
37                        int in_vector_length,
38                        int16_t* filter_state,
39                        int16_t* out_vector) {
40  int i;
41  int16_t* in_ptr = in_vector;
42  int16_t* out_ptr = out_vector;
43  int32_t tmp32 = 0;
44
45
46  // The sum of the absolute values of the impulse response:
47  // The zero/pole-filter has a max amplification of a single sample of: 1.4546
48  // Impulse response: 0.4047 -0.6179 -0.0266  0.1993  0.1035  -0.0194
49  // The all-zero section has a max amplification of a single sample of: 1.6189
50  // Impulse response: 0.4047 -0.8094  0.4047  0       0        0
51  // The all-pole section has a max amplification of a single sample of: 1.9931
52  // Impulse response: 1.0000  0.4734 -0.1189 -0.2187 -0.0627   0.04532
53
54  for (i = 0; i < in_vector_length; i++) {
55    // all-zero section (filter coefficients in Q14)
56    tmp32 = (int32_t) WEBRTC_SPL_MUL_16_16(kHpZeroCoefs[0], (*in_ptr));
57    tmp32 += (int32_t) WEBRTC_SPL_MUL_16_16(kHpZeroCoefs[1], filter_state[0]);
58    tmp32 += (int32_t) WEBRTC_SPL_MUL_16_16(kHpZeroCoefs[2],
59                                            filter_state[1]);  // Q14
60    filter_state[1] = filter_state[0];
61    filter_state[0] = *in_ptr++;
62
63    // all-pole section
64    tmp32 -= (int32_t) WEBRTC_SPL_MUL_16_16(kHpPoleCoefs[1],
65                                            filter_state[2]);  // Q14
66    tmp32 -= (int32_t) WEBRTC_SPL_MUL_16_16(kHpPoleCoefs[2], filter_state[3]);
67    filter_state[3] = filter_state[2];
68    filter_state[2] = (int16_t) WEBRTC_SPL_RSHIFT_W32 (tmp32, 14);
69    *out_ptr++ = filter_state[2];
70  }
71}
72
73void WebRtcVad_Allpass(int16_t* in_vector,
74                       int16_t filter_coefficients,
75                       int vector_length,
76                       int16_t* filter_state,
77                       int16_t* out_vector) {
78  // The filter can only cause overflow (in the w16 output variable)
79  // if more than 4 consecutive input numbers are of maximum value and
80  // has the the same sign as the impulse responses first taps.
81  // First 6 taps of the impulse response: 0.6399 0.5905 -0.3779
82  // 0.2418 -0.1547 0.0990
83
84  int i;
85  int16_t tmp16 = 0;
86  int32_t tmp32 = 0, in32 = 0;
87  int32_t state32 = WEBRTC_SPL_LSHIFT_W32((int32_t) (*filter_state), 16); // Q31
88
89  for (i = 0; i < vector_length; i++) {
90    tmp32 = state32 + WEBRTC_SPL_MUL_16_16(filter_coefficients, (*in_vector));
91    tmp16 = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32, 16);
92    *out_vector++ = tmp16;
93    in32 = WEBRTC_SPL_LSHIFT_W32(((int32_t) (*in_vector)), 14);
94    state32 = in32 - WEBRTC_SPL_MUL_16_16(filter_coefficients, tmp16);
95    state32 = WEBRTC_SPL_LSHIFT_W32(state32, 1);
96    in_vector += 2;
97  }
98
99  *filter_state = (int16_t) WEBRTC_SPL_RSHIFT_W32(state32, 16);
100}
101
102void WebRtcVad_SplitFilter(int16_t* in_vector,
103                           int in_vector_length,
104                           int16_t* upper_state,
105                           int16_t* lower_state,
106                           int16_t* out_vector_hp,
107                           int16_t* out_vector_lp) {
108  int16_t tmp_out;
109  int i;
110  int half_length = WEBRTC_SPL_RSHIFT_W16(in_vector_length, 1);
111
112  // All-pass filtering upper branch
113  WebRtcVad_Allpass(&in_vector[0], kAllPassCoefsQ15[0], half_length,
114                    upper_state, out_vector_hp);
115
116  // All-pass filtering lower branch
117  WebRtcVad_Allpass(&in_vector[1], kAllPassCoefsQ15[1], half_length,
118                    lower_state, out_vector_lp);
119
120  // Make LP and HP signals
121  for (i = 0; i < half_length; i++) {
122    tmp_out = *out_vector_hp;
123    *out_vector_hp++ -= *out_vector_lp;
124    *out_vector_lp++ += tmp_out;
125  }
126}
127
128int16_t WebRtcVad_get_features(VadInstT* inst,
129                               int16_t* in_vector,
130                               int frame_size,
131                               int16_t* out_vector) {
132  int16_t power = 0;
133  // We expect |frame_size| to be 80, 160 or 240 samples, which corresponds to
134  // 10, 20 or 30 ms in 8 kHz. Therefore, the intermediate downsampled data will
135  // have at most 120 samples after the first split and at most 60 samples after
136  // the second split.
137  int16_t hp_120[120], lp_120[120];
138  int16_t hp_60[60], lp_60[60];
139  // Initialize variables for the first SplitFilter().
140  int length = frame_size;
141  int frequency_band = 0;
142  int16_t* in_ptr = in_vector;
143  int16_t* hp_out_ptr = hp_120;
144  int16_t* lp_out_ptr = lp_120;
145
146  // Split at 2000 Hz and downsample
147  WebRtcVad_SplitFilter(in_ptr, length, &inst->upper_state[frequency_band],
148                        &inst->lower_state[frequency_band], hp_out_ptr,
149                        lp_out_ptr);
150
151  // Split at 3000 Hz and downsample
152  frequency_band = 1;
153  in_ptr = hp_120;
154  hp_out_ptr = hp_60;
155  lp_out_ptr = lp_60;
156  length = WEBRTC_SPL_RSHIFT_W16(frame_size, 1);
157
158  WebRtcVad_SplitFilter(in_ptr, length, &inst->upper_state[frequency_band],
159                        &inst->lower_state[frequency_band], hp_out_ptr,
160                        lp_out_ptr);
161
162  // Energy in 3000 Hz - 4000 Hz
163  length = WEBRTC_SPL_RSHIFT_W16(length, 1);
164  WebRtcVad_LogOfEnergy(hp_60, length, kOffsetVector[5], &power,
165                        &out_vector[5]);
166
167  // Energy in 2000 Hz - 3000 Hz
168  WebRtcVad_LogOfEnergy(lp_60, length, kOffsetVector[4], &power,
169                        &out_vector[4]);
170
171  // Split at 1000 Hz and downsample
172  frequency_band = 2;
173  in_ptr = lp_120;
174  hp_out_ptr = hp_60;
175  lp_out_ptr = lp_60;
176  length = WEBRTC_SPL_RSHIFT_W16(frame_size, 1);
177  WebRtcVad_SplitFilter(in_ptr, length, &inst->upper_state[frequency_band],
178                        &inst->lower_state[frequency_band], hp_out_ptr,
179                        lp_out_ptr);
180
181  // Energy in 1000 Hz - 2000 Hz
182  length = WEBRTC_SPL_RSHIFT_W16(length, 1);
183  WebRtcVad_LogOfEnergy(hp_60, length, kOffsetVector[3], &power,
184                        &out_vector[3]);
185
186  // Split at 500 Hz
187  frequency_band = 3;
188  in_ptr = lp_60;
189  hp_out_ptr = hp_120;
190  lp_out_ptr = lp_120;
191
192  WebRtcVad_SplitFilter(in_ptr, length, &inst->upper_state[frequency_band],
193                        &inst->lower_state[frequency_band], hp_out_ptr,
194                        lp_out_ptr);
195
196  // Energy in 500 Hz - 1000 Hz
197  length = WEBRTC_SPL_RSHIFT_W16(length, 1);
198  WebRtcVad_LogOfEnergy(hp_120, length, kOffsetVector[2], &power,
199                        &out_vector[2]);
200
201  // Split at 250 Hz
202  frequency_band = 4;
203  in_ptr = lp_120;
204  hp_out_ptr = hp_60;
205  lp_out_ptr = lp_60;
206
207  WebRtcVad_SplitFilter(in_ptr, length, &inst->upper_state[frequency_band],
208                        &inst->lower_state[frequency_band], hp_out_ptr,
209                        lp_out_ptr);
210
211  // Energy in 250 Hz - 500 Hz
212  length = WEBRTC_SPL_RSHIFT_W16(length, 1);
213  WebRtcVad_LogOfEnergy(hp_60, length, kOffsetVector[1], &power,
214                        &out_vector[1]);
215
216  // Remove DC and LFs
217  WebRtcVad_HpOutput(lp_60, length, inst->hp_filter_state, hp_120);
218
219  // Power in 80 Hz - 250 Hz
220  WebRtcVad_LogOfEnergy(hp_120, length, kOffsetVector[0], &power,
221                        &out_vector[0]);
222
223  return power;
224}
225
226void WebRtcVad_LogOfEnergy(int16_t* vector,
227                           int vector_length,
228                           int16_t offset,
229                           int16_t* power,
230                           int16_t* log_energy) {
231  int shfts = 0, shfts2 = 0;
232  int16_t energy_s16 = 0;
233  int16_t zeros = 0, frac = 0, log2 = 0;
234  int32_t energy = WebRtcSpl_Energy(vector, vector_length, &shfts);
235
236  if (energy > 0) {
237
238    shfts2 = 16 - WebRtcSpl_NormW32(energy);
239    shfts += shfts2;
240    // "shfts" is the total number of right shifts that has been done to
241    // energy_s16.
242    energy_s16 = (int16_t) WEBRTC_SPL_SHIFT_W32(energy, -shfts2);
243
244    // Find:
245    // 160*log10(energy_s16*2^shfts) = 160*log10(2)*log2(energy_s16*2^shfts) =
246    // 160*log10(2)*(log2(energy_s16) + log2(2^shfts)) =
247    // 160*log10(2)*(log2(energy_s16) + shfts)
248
249    zeros = WebRtcSpl_NormU32(energy_s16);
250    frac = (int16_t) (((uint32_t) ((int32_t) (energy_s16) << zeros)
251        & 0x7FFFFFFF) >> 21);
252    log2 = (int16_t) (((31 - zeros) << 10) + frac);
253
254    *log_energy = (int16_t) WEBRTC_SPL_MUL_16_16_RSFT(kLogConst, log2, 19)
255        + (int16_t) WEBRTC_SPL_MUL_16_16_RSFT(shfts, kLogConst, 9);
256
257    if (*log_energy < 0) {
258      *log_energy = 0;
259    }
260  } else {
261    *log_energy = 0;
262    shfts = -15;
263    energy_s16 = 0;
264  }
265
266  *log_energy += offset;
267
268  // Total power in frame
269  if (*power <= MIN_ENERGY) {
270    if (shfts > 0) {
271      *power += MIN_ENERGY + 1;
272    } else if (WEBRTC_SPL_SHIFT_W16(energy_s16, shfts) > MIN_ENERGY) {
273      *power += MIN_ENERGY + 1;
274    } else {
275      *power += WEBRTC_SPL_SHIFT_W16(energy_s16, shfts);
276    }
277  }
278}
279