tor-browser

vad_core.c (26200B)

---

/*
*  Copyright (c) 2012 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.
*/

#include "common_audio/vad/vad_core.h"

#include "common_audio/signal_processing/include/signal_processing_library.h"
#include "common_audio/vad/vad_filterbank.h"
#include "common_audio/vad/vad_gmm.h"
#include "common_audio/vad/vad_sp.h"
#include "rtc_base/sanitizer.h"

// Spectrum Weighting
static const int16_t kSpectrumWeight[kNumChannels] = {6, 8, 10, 12, 14, 16};
static const int16_t kNoiseUpdateConst = 655;    // Q15
static const int16_t kSpeechUpdateConst = 6554;  // Q15
static const int16_t kBackEta = 154;             // Q8
// Minimum difference between the two models, Q5
static const int16_t kMinimumDifference[kNumChannels] = {544, 544, 576,
                                                        576, 576, 576};
// Upper limit of mean value for speech model, Q7
static const int16_t kMaximumSpeech[kNumChannels] = {11392, 11392, 11520,
                                                    11520, 11520, 11520};
// Minimum value for mean value
static const int16_t kMinimumMean[kNumGaussians] = {640, 768};
// Upper limit of mean value for noise model, Q7
static const int16_t kMaximumNoise[kNumChannels] = {9216, 9088, 8960,
                                                   8832, 8704, 8576};
// Start values for the Gaussian models, Q7
// Weights for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataWeights[kTableSize] = {34, 62, 72, 66, 53, 25,
                                                     94, 66, 56, 62, 75, 103};
// Weights for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataWeights[kTableSize] = {48, 82, 45, 87, 50, 47,
                                                      80, 46, 83, 41, 78, 81};
// Means for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataMeans[kTableSize] = {
   6738, 4892, 7065, 6715, 6771, 3369, 7646, 3863, 7820, 7266, 5020, 4362};
// Means for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataMeans[kTableSize] = {8306,  10085, 10078, 11823,
                                                    11843, 6309,  9473,  9571,
                                                    10879, 7581,  8180,  7483};
// Stds for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataStds[kTableSize] = {
   378, 1064, 493, 582, 688, 593, 474, 697, 475, 688, 421, 455};
// Stds for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataStds[kTableSize] = {
   555, 505, 567, 524, 585, 1231, 509, 828, 492, 1540, 1079, 850};

// Constants used in GmmProbability().
//
// Maximum number of counted speech (VAD = 1) frames in a row.
static const int16_t kMaxSpeechFrames = 6;
// Minimum standard deviation for both speech and noise.
static const int16_t kMinStd = 384;

// Constants in WebRtcVad_InitCore().
// Default aggressiveness mode.
static const short kDefaultMode = 0;
static const int kInitCheck = 42;

// Constants used in WebRtcVad_set_mode_core().
//
// Thresholds for different frame lengths (10 ms, 20 ms and 30 ms).
//
// Mode 0, Quality.
static const int16_t kOverHangMax1Q[3] = {8, 4, 3};
static const int16_t kOverHangMax2Q[3] = {14, 7, 5};
static const int16_t kLocalThresholdQ[3] = {24, 21, 24};
static const int16_t kGlobalThresholdQ[3] = {57, 48, 57};
// Mode 1, Low bitrate.
static const int16_t kOverHangMax1LBR[3] = {8, 4, 3};
static const int16_t kOverHangMax2LBR[3] = {14, 7, 5};
static const int16_t kLocalThresholdLBR[3] = {37, 32, 37};
static const int16_t kGlobalThresholdLBR[3] = {100, 80, 100};
// Mode 2, Aggressive.
static const int16_t kOverHangMax1AGG[3] = {6, 3, 2};
static const int16_t kOverHangMax2AGG[3] = {9, 5, 3};
static const int16_t kLocalThresholdAGG[3] = {82, 78, 82};
static const int16_t kGlobalThresholdAGG[3] = {285, 260, 285};
// Mode 3, Very aggressive.
static const int16_t kOverHangMax1VAG[3] = {6, 3, 2};
static const int16_t kOverHangMax2VAG[3] = {9, 5, 3};
static const int16_t kLocalThresholdVAG[3] = {94, 94, 94};
static const int16_t kGlobalThresholdVAG[3] = {1100, 1050, 1100};

// Calculates the weighted average w.r.t. number of Gaussians. The `data` are
// updated with an `offset` before averaging.
//
// - data     [i/o] : Data to average.
// - offset   [i]   : An offset added to `data`.
// - weights  [i]   : Weights used for averaging.
//
// returns          : The weighted average.
static int32_t WeightedAverage(int16_t* data,
                              int16_t offset,
                              const int16_t* weights) {
 int k;
 int32_t weighted_average = 0;

 for (k = 0; k < kNumGaussians; k++) {
   data[k * kNumChannels] += offset;
   weighted_average += data[k * kNumChannels] * weights[k * kNumChannels];
 }
 return weighted_average;
}

// An s16 x s32 -> s32 multiplication that's allowed to overflow. (It's still
// undefined behavior, so not a good idea; this just makes UBSan ignore the
// violation, so that our old code can continue to do what it's always been
// doing.)
static inline int32_t RTC_NO_SANITIZE("signed-integer-overflow")
   OverflowingMulS16ByS32ToS32(int16_t a, int32_t b) {
 return a * b;
}

// Calculates the probabilities for both speech and background noise using
// Gaussian Mixture Models (GMM). A hypothesis-test is performed to decide which
// type of signal is most probable.
//
// - self           [i/o] : Pointer to VAD instance
// - features       [i]   : Feature vector of length `kNumChannels`
//                          = log10(energy in frequency band)
// - total_power    [i]   : Total power in audio frame.
// - frame_length   [i]   : Number of input samples
//
// - returns              : the VAD decision (0 - noise, 1 - speech).
static int16_t GmmProbability(VadInstT* self,
                             int16_t* features,
                             int16_t total_power,
                             size_t frame_length) {
 int channel, k;
 int16_t feature_minimum;
 int16_t h0, h1;
 int16_t log_likelihood_ratio;
 int16_t vadflag = 0;
 int16_t shifts_h0, shifts_h1;
 int16_t tmp_s16, tmp1_s16, tmp2_s16;
 int16_t diff;
 int gaussian;
 int16_t nmk, nmk2, nmk3, smk, smk2, nsk, ssk;
 int16_t delt, ndelt;
 int16_t maxspe, maxmu;
 int16_t deltaN[kTableSize], deltaS[kTableSize];
 int16_t ngprvec[kTableSize] = {0};  // Conditional probability = 0.
 int16_t sgprvec[kTableSize] = {0};  // Conditional probability = 0.
 int32_t h0_test, h1_test;
 int32_t tmp1_s32, tmp2_s32;
 int32_t sum_log_likelihood_ratios = 0;
 int32_t noise_global_mean, speech_global_mean;
 int32_t noise_probability[kNumGaussians], speech_probability[kNumGaussians];
 int16_t overhead1, overhead2, individualTest, totalTest;

 // Set various thresholds based on frame lengths (80, 160 or 240 samples).
 if (frame_length == 80) {
   overhead1 = self->over_hang_max_1[0];
   overhead2 = self->over_hang_max_2[0];
   individualTest = self->individual[0];
   totalTest = self->total[0];
 } else if (frame_length == 160) {
   overhead1 = self->over_hang_max_1[1];
   overhead2 = self->over_hang_max_2[1];
   individualTest = self->individual[1];
   totalTest = self->total[1];
 } else {
   overhead1 = self->over_hang_max_1[2];
   overhead2 = self->over_hang_max_2[2];
   individualTest = self->individual[2];
   totalTest = self->total[2];
 }

 if (total_power > kMinEnergy) {
   // The signal power of current frame is large enough for processing. The
   // processing consists of two parts:
   // 1) Calculating the likelihood of speech and thereby a VAD decision.
   // 2) Updating the underlying model, w.r.t., the decision made.

   // The detection scheme is an LRT with hypothesis
   // H0: Noise
   // H1: Speech
   //
   // We combine a global LRT with local tests, for each frequency sub-band,
   // here defined as `channel`.
   for (channel = 0; channel < kNumChannels; channel++) {
     // For each channel we model the probability with a GMM consisting of
     // `kNumGaussians`, with different means and standard deviations depending
     // on H0 or H1.
     h0_test = 0;
     h1_test = 0;
     for (k = 0; k < kNumGaussians; k++) {
       gaussian = channel + k * kNumChannels;
       // Probability under H0, that is, probability of frame being noise.
       // Value given in Q27 = Q7 * Q20.
       tmp1_s32 = WebRtcVad_GaussianProbability(
           features[channel], self->noise_means[gaussian],
           self->noise_stds[gaussian], &deltaN[gaussian]);
       noise_probability[k] = kNoiseDataWeights[gaussian] * tmp1_s32;
       h0_test += noise_probability[k];  // Q27

       // Probability under H1, that is, probability of frame being speech.
       // Value given in Q27 = Q7 * Q20.
       tmp1_s32 = WebRtcVad_GaussianProbability(
           features[channel], self->speech_means[gaussian],
           self->speech_stds[gaussian], &deltaS[gaussian]);
       speech_probability[k] = kSpeechDataWeights[gaussian] * tmp1_s32;
       h1_test += speech_probability[k];  // Q27
     }

     // Calculate the log likelihood ratio: log2(Pr{X|H1} / Pr{X|H1}).
     // Approximation:
     // log2(Pr{X|H1} / Pr{X|H1}) = log2(Pr{X|H1}*2^Q) - log2(Pr{X|H1}*2^Q)
     //                           = log2(h1_test) - log2(h0_test)
     //                           = log2(2^(31-shifts_h1)*(1+b1))
     //                             - log2(2^(31-shifts_h0)*(1+b0))
     //                           = shifts_h0 - shifts_h1
     //                             + log2(1+b1) - log2(1+b0)
     //                          ~= shifts_h0 - shifts_h1
     //
     // Note that b0 and b1 are values less than 1, hence, 0 <= log2(1+b0) < 1.
     // Further, b0 and b1 are independent and on the average the two terms
     // cancel.
     shifts_h0 = WebRtcSpl_NormW32(h0_test);
     shifts_h1 = WebRtcSpl_NormW32(h1_test);
     if (h0_test == 0) {
       shifts_h0 = 31;
     }
     if (h1_test == 0) {
       shifts_h1 = 31;
     }
     log_likelihood_ratio = shifts_h0 - shifts_h1;

     // Update `sum_log_likelihood_ratios` with spectrum weighting. This is
     // used for the global VAD decision.
     sum_log_likelihood_ratios +=
         (int32_t)(log_likelihood_ratio * kSpectrumWeight[channel]);

     // Local VAD decision.
     if ((log_likelihood_ratio * 4) > individualTest) {
       vadflag = 1;
     }

     // TODO(bjornv): The conditional probabilities below are applied on the
     // hard coded number of Gaussians set to two. Find a way to generalize.
     // Calculate local noise probabilities used later when updating the GMM.
     h0 = (int16_t)(h0_test >> 12);  // Q15
     if (h0 > 0) {
       // High probability of noise. Assign conditional probabilities for each
       // Gaussian in the GMM.
       tmp1_s32 = (noise_probability[0] & 0xFFFFF000) << 2;            // Q29
       ngprvec[channel] = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, h0);  // Q14
       ngprvec[channel + kNumChannels] = 16384 - ngprvec[channel];
     } else {
       // Low noise probability. Assign conditional probability 1 to the first
       // Gaussian and 0 to the rest (which is already set at initialization).
       ngprvec[channel] = 16384;
     }

     // Calculate local speech probabilities used later when updating the GMM.
     h1 = (int16_t)(h1_test >> 12);  // Q15
     if (h1 > 0) {
       // High probability of speech. Assign conditional probabilities for each
       // Gaussian in the GMM. Otherwise use the initialized values, i.e., 0.
       tmp1_s32 = (speech_probability[0] & 0xFFFFF000) << 2;           // Q29
       sgprvec[channel] = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, h1);  // Q14
       sgprvec[channel + kNumChannels] = 16384 - sgprvec[channel];
     }
   }

   // Make a global VAD decision.
   vadflag |= (sum_log_likelihood_ratios >= totalTest);

   // Update the model parameters.
   maxspe = 12800;
   for (channel = 0; channel < kNumChannels; channel++) {
     // Get minimum value in past which is used for long term correction in Q4.
     feature_minimum = WebRtcVad_FindMinimum(self, features[channel], channel);

     // Compute the "global" mean, that is the sum of the two means weighted.
     noise_global_mean = WeightedAverage(&self->noise_means[channel], 0,
                                         &kNoiseDataWeights[channel]);
     tmp1_s16 = (int16_t)(noise_global_mean >> 6);  // Q8

     for (k = 0; k < kNumGaussians; k++) {
       gaussian = channel + k * kNumChannels;

       nmk = self->noise_means[gaussian];
       smk = self->speech_means[gaussian];
       nsk = self->noise_stds[gaussian];
       ssk = self->speech_stds[gaussian];

       // Update noise mean vector if the frame consists of noise only.
       nmk2 = nmk;
       if (!vadflag) {
         // deltaN = (x-mu)/sigma^2
         // ngprvec[k] = `noise_probability[k]` /
         //   (`noise_probability[0]` + `noise_probability[1]`)

         // (Q14 * Q11 >> 11) = Q14.
         delt = (int16_t)((ngprvec[gaussian] * deltaN[gaussian]) >> 11);
         // Q7 + (Q14 * Q15 >> 22) = Q7.
         nmk2 = nmk + (int16_t)((delt * kNoiseUpdateConst) >> 22);
       }

       // Long term correction of the noise mean.
       // Q8 - Q8 = Q8.
       ndelt = (feature_minimum << 4) - tmp1_s16;
       // Q7 + (Q8 * Q8) >> 9 = Q7.
       nmk3 = nmk2 + (int16_t)((ndelt * kBackEta) >> 9);

       // Control that the noise mean does not drift to much.
       tmp_s16 = (int16_t)((k + 5) << 7);
       if (nmk3 < tmp_s16) {
         nmk3 = tmp_s16;
       }
       tmp_s16 = (int16_t)((72 + k - channel) << 7);
       if (nmk3 > tmp_s16) {
         nmk3 = tmp_s16;
       }
       self->noise_means[gaussian] = nmk3;

       if (vadflag) {
         // Update speech mean vector:
         // `deltaS` = (x-mu)/sigma^2
         // sgprvec[k] = `speech_probability[k]` /
         //   (`speech_probability[0]` + `speech_probability[1]`)

         // (Q14 * Q11) >> 11 = Q14.
         delt = (int16_t)((sgprvec[gaussian] * deltaS[gaussian]) >> 11);
         // Q14 * Q15 >> 21 = Q8.
         tmp_s16 = (int16_t)((delt * kSpeechUpdateConst) >> 21);
         // Q7 + (Q8 >> 1) = Q7. With rounding.
         smk2 = smk + ((tmp_s16 + 1) >> 1);

         // Control that the speech mean does not drift to much.
         maxmu = maxspe + 640;
         if (smk2 < kMinimumMean[k]) {
           smk2 = kMinimumMean[k];
         }
         if (smk2 > maxmu) {
           smk2 = maxmu;
         }
         self->speech_means[gaussian] = smk2;  // Q7.

         // (Q7 >> 3) = Q4. With rounding.
         tmp_s16 = ((smk + 4) >> 3);

         tmp_s16 = features[channel] - tmp_s16;  // Q4
         // (Q11 * Q4 >> 3) = Q12.
         tmp1_s32 = (deltaS[gaussian] * tmp_s16) >> 3;
         tmp2_s32 = tmp1_s32 - 4096;
         tmp_s16 = sgprvec[gaussian] >> 2;
         // (Q14 >> 2) * Q12 = Q24.
         tmp1_s32 = tmp_s16 * tmp2_s32;

         tmp2_s32 = tmp1_s32 >> 4;  // Q20

         // 0.1 * Q20 / Q7 = Q13.
         if (tmp2_s32 > 0) {
           tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(tmp2_s32, ssk * 10);
         } else {
           tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(-tmp2_s32, ssk * 10);
           tmp_s16 = -tmp_s16;
         }
         // Divide by 4 giving an update factor of 0.025 (= 0.1 / 4).
         // Note that division by 4 equals shift by 2, hence,
         // (Q13 >> 8) = (Q13 >> 6) / 4 = Q7.
         tmp_s16 += 128;  // Rounding.
         ssk += (tmp_s16 >> 8);
         if (ssk < kMinStd) {
           ssk = kMinStd;
         }
         self->speech_stds[gaussian] = ssk;
       } else {
         // Update GMM variance vectors.
         // deltaN * (features[channel] - nmk) - 1
         // Q4 - (Q7 >> 3) = Q4.
         tmp_s16 = features[channel] - (nmk >> 3);
         // (Q11 * Q4 >> 3) = Q12.
         tmp1_s32 = (deltaN[gaussian] * tmp_s16) >> 3;
         tmp1_s32 -= 4096;

         // (Q14 >> 2) * Q12 = Q24.
         tmp_s16 = (ngprvec[gaussian] + 2) >> 2;
         tmp2_s32 = OverflowingMulS16ByS32ToS32(tmp_s16, tmp1_s32);
         // Q20  * approx 0.001 (2^-10=0.0009766), hence,
         // (Q24 >> 14) = (Q24 >> 4) / 2^10 = Q20.
         tmp1_s32 = tmp2_s32 >> 14;

         // Q20 / Q7 = Q13.
         if (tmp1_s32 > 0) {
           tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, nsk);
         } else {
           tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(-tmp1_s32, nsk);
           tmp_s16 = -tmp_s16;
         }
         tmp_s16 += 32;        // Rounding
         nsk += tmp_s16 >> 6;  // Q13 >> 6 = Q7.
         if (nsk < kMinStd) {
           nsk = kMinStd;
         }
         self->noise_stds[gaussian] = nsk;
       }
     }

     // Separate models if they are too close.
     // `noise_global_mean` in Q14 (= Q7 * Q7).
     noise_global_mean = WeightedAverage(&self->noise_means[channel], 0,
                                         &kNoiseDataWeights[channel]);

     // `speech_global_mean` in Q14 (= Q7 * Q7).
     speech_global_mean = WeightedAverage(&self->speech_means[channel], 0,
                                          &kSpeechDataWeights[channel]);

     // `diff` = "global" speech mean - "global" noise mean.
     // (Q14 >> 9) - (Q14 >> 9) = Q5.
     diff = (int16_t)(speech_global_mean >> 9) -
            (int16_t)(noise_global_mean >> 9);
     if (diff < kMinimumDifference[channel]) {
       tmp_s16 = kMinimumDifference[channel] - diff;

       // `tmp1_s16` = ~0.8 * (kMinimumDifference - diff) in Q7.
       // `tmp2_s16` = ~0.2 * (kMinimumDifference - diff) in Q7.
       tmp1_s16 = (int16_t)((13 * tmp_s16) >> 2);
       tmp2_s16 = (int16_t)((3 * tmp_s16) >> 2);

       // Move Gaussian means for speech model by `tmp1_s16` and update
       // `speech_global_mean`. Note that `self->speech_means[channel]` is
       // changed after the call.
       speech_global_mean =
           WeightedAverage(&self->speech_means[channel], tmp1_s16,
                           &kSpeechDataWeights[channel]);

       // Move Gaussian means for noise model by -`tmp2_s16` and update
       // `noise_global_mean`. Note that `self->noise_means[channel]` is
       // changed after the call.
       noise_global_mean =
           WeightedAverage(&self->noise_means[channel], -tmp2_s16,
                           &kNoiseDataWeights[channel]);
     }

     // Control that the speech & noise means do not drift to much.
     maxspe = kMaximumSpeech[channel];
     tmp2_s16 = (int16_t)(speech_global_mean >> 7);
     if (tmp2_s16 > maxspe) {
       // Upper limit of speech model.
       tmp2_s16 -= maxspe;

       for (k = 0; k < kNumGaussians; k++) {
         self->speech_means[channel + k * kNumChannels] -= tmp2_s16;
       }
     }

     tmp2_s16 = (int16_t)(noise_global_mean >> 7);
     if (tmp2_s16 > kMaximumNoise[channel]) {
       tmp2_s16 -= kMaximumNoise[channel];

       for (k = 0; k < kNumGaussians; k++) {
         self->noise_means[channel + k * kNumChannels] -= tmp2_s16;
       }
     }
   }
   self->frame_counter++;
 }

 // Smooth with respect to transition hysteresis.
 if (!vadflag) {
   if (self->over_hang > 0) {
     vadflag = 2 + self->over_hang;
     self->over_hang--;
   }
   self->num_of_speech = 0;
 } else {
   self->num_of_speech++;
   if (self->num_of_speech > kMaxSpeechFrames) {
     self->num_of_speech = kMaxSpeechFrames;
     self->over_hang = overhead2;
   } else {
     self->over_hang = overhead1;
   }
 }
 return vadflag;
}

// Initialize the VAD. Set aggressiveness mode to default value.
int WebRtcVad_InitCore(VadInstT* self) {
 int i;

 if (self == NULL) {
   return -1;
 }

 // Initialization of general struct variables.
 self->vad = 1;  // Speech active (=1).
 self->frame_counter = 0;
 self->over_hang = 0;
 self->num_of_speech = 0;

 // Initialization of downsampling filter state.
 memset(self->downsampling_filter_states, 0,
        sizeof(self->downsampling_filter_states));

 // Initialization of 48 to 8 kHz downsampling.
 WebRtcSpl_ResetResample48khzTo8khz(&self->state_48_to_8);

 // Read initial PDF parameters.
 for (i = 0; i < kTableSize; i++) {
   self->noise_means[i] = kNoiseDataMeans[i];
   self->speech_means[i] = kSpeechDataMeans[i];
   self->noise_stds[i] = kNoiseDataStds[i];
   self->speech_stds[i] = kSpeechDataStds[i];
 }

 // Initialize Index and Minimum value vectors.
 for (i = 0; i < 16 * kNumChannels; i++) {
   self->low_value_vector[i] = 10000;
   self->index_vector[i] = 0;
 }

 // Initialize splitting filter states.
 memset(self->upper_state, 0, sizeof(self->upper_state));
 memset(self->lower_state, 0, sizeof(self->lower_state));

 // Initialize high pass filter states.
 memset(self->hp_filter_state, 0, sizeof(self->hp_filter_state));

 // Initialize mean value memory, for WebRtcVad_FindMinimum().
 for (i = 0; i < kNumChannels; i++) {
   self->mean_value[i] = 1600;
 }

 // Set aggressiveness mode to default (=`kDefaultMode`).
 if (WebRtcVad_set_mode_core(self, kDefaultMode) != 0) {
   return -1;
 }

 self->init_flag = kInitCheck;

 return 0;
}

// Set aggressiveness mode
int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
 int return_value = 0;

 switch (mode) {
   case 0:
     // Quality mode.
     memcpy(self->over_hang_max_1, kOverHangMax1Q,
            sizeof(self->over_hang_max_1));
     memcpy(self->over_hang_max_2, kOverHangMax2Q,
            sizeof(self->over_hang_max_2));
     memcpy(self->individual, kLocalThresholdQ, sizeof(self->individual));
     memcpy(self->total, kGlobalThresholdQ, sizeof(self->total));
     break;
   case 1:
     // Low bitrate mode.
     memcpy(self->over_hang_max_1, kOverHangMax1LBR,
            sizeof(self->over_hang_max_1));
     memcpy(self->over_hang_max_2, kOverHangMax2LBR,
            sizeof(self->over_hang_max_2));
     memcpy(self->individual, kLocalThresholdLBR, sizeof(self->individual));
     memcpy(self->total, kGlobalThresholdLBR, sizeof(self->total));
     break;
   case 2:
     // Aggressive mode.
     memcpy(self->over_hang_max_1, kOverHangMax1AGG,
            sizeof(self->over_hang_max_1));
     memcpy(self->over_hang_max_2, kOverHangMax2AGG,
            sizeof(self->over_hang_max_2));
     memcpy(self->individual, kLocalThresholdAGG, sizeof(self->individual));
     memcpy(self->total, kGlobalThresholdAGG, sizeof(self->total));
     break;
   case 3:
     // Very aggressive mode.
     memcpy(self->over_hang_max_1, kOverHangMax1VAG,
            sizeof(self->over_hang_max_1));
     memcpy(self->over_hang_max_2, kOverHangMax2VAG,
            sizeof(self->over_hang_max_2));
     memcpy(self->individual, kLocalThresholdVAG, sizeof(self->individual));
     memcpy(self->total, kGlobalThresholdVAG, sizeof(self->total));
     break;
   default:
     return_value = -1;
     break;
 }

 return return_value;
}

// Calculate VAD decision by first extracting feature values and then calculate
// probability for both speech and background noise.

int WebRtcVad_CalcVad48khz(VadInstT* inst,
                          const int16_t* speech_frame,
                          size_t frame_length) {
 int vad;
 size_t i;
 int16_t speech_nb[240];  // 30 ms in 8 kHz.
 // `tmp_mem` is a temporary memory used by resample function, length is
 // frame length in 10 ms (480 samples) + 256 extra.
 int32_t tmp_mem[480 + 256] = {0};
 const size_t kFrameLen10ms48khz = 480;
 const size_t kFrameLen10ms8khz = 80;
 size_t num_10ms_frames = frame_length / kFrameLen10ms48khz;

 for (i = 0; i < num_10ms_frames; i++) {
   WebRtcSpl_Resample48khzTo8khz(speech_frame,
                                 &speech_nb[i * kFrameLen10ms8khz],
                                 &inst->state_48_to_8, tmp_mem);
 }

 // Do VAD on an 8 kHz signal
 vad = WebRtcVad_CalcVad8khz(inst, speech_nb, frame_length / 6);

 return vad;
}

int WebRtcVad_CalcVad32khz(VadInstT* inst,
                          const int16_t* speech_frame,
                          size_t frame_length) {
 size_t len;
 int vad;
 int16_t speechWB[480];  // Downsampled speech frame: 960 samples (30ms in SWB)
 int16_t speechNB[240];  // Downsampled speech frame: 480 samples (30ms in WB)

 // Downsample signal 32->16->8 before doing VAD
 WebRtcVad_Downsampling(speech_frame, speechWB,
                        &(inst->downsampling_filter_states[2]), frame_length);
 len = frame_length / 2;

 WebRtcVad_Downsampling(speechWB, speechNB, inst->downsampling_filter_states,
                        len);
 len /= 2;

 // Do VAD on an 8 kHz signal
 vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);

 return vad;
}

int WebRtcVad_CalcVad16khz(VadInstT* inst,
                          const int16_t* speech_frame,
                          size_t frame_length) {
 size_t len;
 int vad;
 int16_t speechNB[240];  // Downsampled speech frame: 480 samples (30ms in WB)

 // Wideband: Downsample signal before doing VAD
 WebRtcVad_Downsampling(speech_frame, speechNB,
                        inst->downsampling_filter_states, frame_length);

 len = frame_length / 2;
 vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);

 return vad;
}

int WebRtcVad_CalcVad8khz(VadInstT* inst,
                         const int16_t* speech_frame,
                         size_t frame_length) {
 int16_t feature_vector[kNumChannels], total_power;

 // Get power in the bands
 total_power = WebRtcVad_CalculateFeatures(inst, speech_frame, frame_length,
                                           feature_vector);

 // Make a VAD
 inst->vad = GmmProbability(inst, feature_vector, total_power, frame_length);

 return inst->vad;
}