tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

webrtc_vad.c (3083B)

      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 "common_audio/vad/include/webrtc_vad.h"
     12 
     13 #include <stdlib.h>
     14 #include <string.h>
     15 
     16 #include "common_audio/signal_processing/include/signal_processing_library.h"
     17 #include "common_audio/vad/vad_core.h"
     18 
     19 static const int kInitCheck = 42;
     20 static const int kValidRates[] = {8000, 16000, 32000, 48000};
     21 static const size_t kRatesSize = sizeof(kValidRates) / sizeof(*kValidRates);
     22 static const int kMaxFrameLengthMs = 30;
     23 
     24 VadInst* WebRtcVad_Create(void) {
     25  VadInstT* self = (VadInstT*)malloc(sizeof(VadInstT));
     26 
     27  self->init_flag = 0;
     28 
     29  return (VadInst*)self;
     30 }
     31 
     32 void WebRtcVad_Free(VadInst* handle) {
     33  free(handle);
     34 }
     35 
     36 // TODO(bjornv): Move WebRtcVad_InitCore() code here.
     37 int WebRtcVad_Init(VadInst* handle) {
     38  // Initialize the core VAD component.
     39  return WebRtcVad_InitCore((VadInstT*)handle);
     40 }
     41 
     42 // TODO(bjornv): Move WebRtcVad_set_mode_core() code here.
     43 int WebRtcVad_set_mode(VadInst* handle, int mode) {
     44  VadInstT* self = (VadInstT*)handle;
     45 
     46  if (handle == NULL) {
     47    return -1;
     48  }
     49  if (self->init_flag != kInitCheck) {
     50    return -1;
     51  }
     52 
     53  return WebRtcVad_set_mode_core(self, mode);
     54 }
     55 
     56 int WebRtcVad_Process(VadInst* handle,
     57                      int fs,
     58                      const int16_t* audio_frame,
     59                      size_t frame_length) {
     60  int vad = -1;
     61  VadInstT* self = (VadInstT*)handle;
     62 
     63  if (handle == NULL) {
     64    return -1;
     65  }
     66 
     67  if (self->init_flag != kInitCheck) {
     68    return -1;
     69  }
     70  if (audio_frame == NULL) {
     71    return -1;
     72  }
     73  if (WebRtcVad_ValidRateAndFrameLength(fs, frame_length) != 0) {
     74    return -1;
     75  }
     76 
     77  if (fs == 48000) {
     78    vad = WebRtcVad_CalcVad48khz(self, audio_frame, frame_length);
     79  } else if (fs == 32000) {
     80    vad = WebRtcVad_CalcVad32khz(self, audio_frame, frame_length);
     81  } else if (fs == 16000) {
     82    vad = WebRtcVad_CalcVad16khz(self, audio_frame, frame_length);
     83  } else if (fs == 8000) {
     84    vad = WebRtcVad_CalcVad8khz(self, audio_frame, frame_length);
     85  }
     86 
     87  if (vad > 0) {
     88    vad = 1;
     89  }
     90  return vad;
     91 }
     92 
     93 int WebRtcVad_ValidRateAndFrameLength(int rate, size_t frame_length) {
     94  int return_value = -1;
     95  size_t i;
     96  int valid_length_ms;
     97  size_t valid_length;
     98 
     99  // We only allow 10, 20 or 30 ms frames. Loop through valid frame rates and
    100  // see if we have a matching pair.
    101  for (i = 0; i < kRatesSize; i++) {
    102    if (kValidRates[i] == rate) {
    103      for (valid_length_ms = 10; valid_length_ms <= kMaxFrameLengthMs;
    104           valid_length_ms += 10) {
    105        valid_length = (size_t)(kValidRates[i] / 1000 * valid_length_ms);
    106        if (frame_length == valid_length) {
    107          return_value = 0;
    108          break;
    109        }
    110      }
    111      break;
    112    }
    113  }
    114 
    115  return return_value;
    116 }