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/common_audio/vad/vad_sp.h"
12
13#include <assert.h>
14
15#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
16#include "webrtc/common_audio/vad/vad_core.h"
17#include "webrtc/typedefs.h"
18
19// Allpass filter coefficients, upper and lower, in Q13.
20// Upper: 0.64, Lower: 0.17.
21static const int16_t kAllPassCoefsQ13[2] = { 5243, 1392 };  // Q13.
22static const int16_t kSmoothingDown = 6553;  // 0.2 in Q15.
23static const int16_t kSmoothingUp = 32439;  // 0.99 in Q15.
24
25// TODO(bjornv): Move this function to vad_filterbank.c.
26// Downsampling filter based on splitting filter and allpass functions.
27void WebRtcVad_Downsampling(const int16_t* signal_in,
28                            int16_t* signal_out,
29                            int32_t* filter_state,
30                            int in_length) {
31  int16_t tmp16_1 = 0, tmp16_2 = 0;
32  int32_t tmp32_1 = filter_state[0];
33  int32_t tmp32_2 = filter_state[1];
34  int n = 0;
35  int half_length = (in_length >> 1);  // Downsampling by 2 gives half length.
36
37  // Filter coefficients in Q13, filter state in Q0.
38  for (n = 0; n < half_length; n++) {
39    // All-pass filtering upper branch.
40    tmp16_1 = (int16_t) ((tmp32_1 >> 1) +
41        WEBRTC_SPL_MUL_16_16_RSFT(kAllPassCoefsQ13[0], *signal_in, 14));
42    *signal_out = tmp16_1;
43    tmp32_1 = (int32_t) (*signal_in++) -
44        WEBRTC_SPL_MUL_16_16_RSFT(kAllPassCoefsQ13[0], tmp16_1, 12);
45
46    // All-pass filtering lower branch.
47    tmp16_2 = (int16_t) ((tmp32_2 >> 1) +
48        WEBRTC_SPL_MUL_16_16_RSFT(kAllPassCoefsQ13[1], *signal_in, 14));
49    *signal_out++ += tmp16_2;
50    tmp32_2 = (int32_t) (*signal_in++) -
51        WEBRTC_SPL_MUL_16_16_RSFT(kAllPassCoefsQ13[1], tmp16_2, 12);
52  }
53  // Store the filter states.
54  filter_state[0] = tmp32_1;
55  filter_state[1] = tmp32_2;
56}
57
58// Inserts |feature_value| into |low_value_vector|, if it is one of the 16
59// smallest values the last 100 frames. Then calculates and returns the median
60// of the five smallest values.
61int16_t WebRtcVad_FindMinimum(VadInstT* self,
62                              int16_t feature_value,
63                              int channel) {
64  int i = 0, j = 0;
65  int position = -1;
66  // Offset to beginning of the 16 minimum values in memory.
67  const int offset = (channel << 4);
68  int16_t current_median = 1600;
69  int16_t alpha = 0;
70  int32_t tmp32 = 0;
71  // Pointer to memory for the 16 minimum values and the age of each value of
72  // the |channel|.
73  int16_t* age = &self->index_vector[offset];
74  int16_t* smallest_values = &self->low_value_vector[offset];
75
76  assert(channel < kNumChannels);
77
78  // Each value in |smallest_values| is getting 1 loop older. Update |age|, and
79  // remove old values.
80  for (i = 0; i < 16; i++) {
81    if (age[i] != 100) {
82      age[i]++;
83    } else {
84      // Too old value. Remove from memory and shift larger values downwards.
85      for (j = i; j < 16; j++) {
86        smallest_values[j] = smallest_values[j + 1];
87        age[j] = age[j + 1];
88      }
89      age[15] = 101;
90      smallest_values[15] = 10000;
91    }
92  }
93
94  // Check if |feature_value| is smaller than any of the values in
95  // |smallest_values|. If so, find the |position| where to insert the new value
96  // (|feature_value|).
97  if (feature_value < smallest_values[7]) {
98    if (feature_value < smallest_values[3]) {
99      if (feature_value < smallest_values[1]) {
100        if (feature_value < smallest_values[0]) {
101          position = 0;
102        } else {
103          position = 1;
104        }
105      } else if (feature_value < smallest_values[2]) {
106        position = 2;
107      } else {
108        position = 3;
109      }
110    } else if (feature_value < smallest_values[5]) {
111      if (feature_value < smallest_values[4]) {
112        position = 4;
113      } else {
114        position = 5;
115      }
116    } else if (feature_value < smallest_values[6]) {
117      position = 6;
118    } else {
119      position = 7;
120    }
121  } else if (feature_value < smallest_values[15]) {
122    if (feature_value < smallest_values[11]) {
123      if (feature_value < smallest_values[9]) {
124        if (feature_value < smallest_values[8]) {
125          position = 8;
126        } else {
127          position = 9;
128        }
129      } else if (feature_value < smallest_values[10]) {
130        position = 10;
131      } else {
132        position = 11;
133      }
134    } else if (feature_value < smallest_values[13]) {
135      if (feature_value < smallest_values[12]) {
136        position = 12;
137      } else {
138        position = 13;
139      }
140    } else if (feature_value < smallest_values[14]) {
141      position = 14;
142    } else {
143      position = 15;
144    }
145  }
146
147  // If we have detected a new small value, insert it at the correct position
148  // and shift larger values up.
149  if (position > -1) {
150    for (i = 15; i > position; i--) {
151      smallest_values[i] = smallest_values[i - 1];
152      age[i] = age[i - 1];
153    }
154    smallest_values[position] = feature_value;
155    age[position] = 1;
156  }
157
158  // Get |current_median|.
159  if (self->frame_counter > 2) {
160    current_median = smallest_values[2];
161  } else if (self->frame_counter > 0) {
162    current_median = smallest_values[0];
163  }
164
165  // Smooth the median value.
166  if (self->frame_counter > 0) {
167    if (current_median < self->mean_value[channel]) {
168      alpha = kSmoothingDown;  // 0.2 in Q15.
169    } else {
170      alpha = kSmoothingUp;  // 0.99 in Q15.
171    }
172  }
173  tmp32 = WEBRTC_SPL_MUL_16_16(alpha + 1, self->mean_value[channel]);
174  tmp32 += WEBRTC_SPL_MUL_16_16(WEBRTC_SPL_WORD16_MAX - alpha, current_median);
175  tmp32 += 16384;
176  self->mean_value[channel] = (int16_t) (tmp32 >> 15);
177
178  return self->mean_value[channel];
179}
180