updated webrtc

Author: mooncake4132

.travis.yml

@@ -4,6 +4,8 @@ python:
   - "3.3"
   - "3.4"
   - "3.5"
+  - "3.6"
+  - "3.7"
 # command to install dependencies
 install: "pip install -e .[dev]"
 # command to run tests

cbits/pywebrtcvad.c

@@ -17,12 +17,8 @@ static void vad_free(PyObject* vadptr)
 
 static PyObject* vad_create(PyObject *self, PyObject *args)
 {
-  VadInst *handle;
-  PyObject *vadptr;
-  if (WebRtcVad_Create(&handle)) {
-    return NULL;
-  }
-  vadptr = PyCapsule_New(handle, "WebRtcVadPtr", vad_free);
+  VadInst *handle = WebRtcVad_Create();
+  PyObject *vadptr = PyCapsule_New(handle, "WebRtcVadPtr", vad_free);
   return Py_BuildValue("O", vadptr);
 }
 

cbits/webrtc/common_audio/signal_processing/complex_fft.c

@@ -17,6 +17,7 @@
 
 #include "webrtc/common_audio/signal_processing/complex_fft_tables.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
+#include "webrtc/rtc_base/system/arch.h"
 
 #define CFFTSFT 14
 #define CFFTRND 1
@@ -126,18 +127,16 @@ int WebRtcSpl_ComplexFFT(int16_t frfi[], int stages, int mode)
                          [wri]"r"(wri),
                          [cfftrnd]"r"(CFFTRND));
 #else
-                    tr32 = WEBRTC_SPL_MUL_16_16(wr, frfi[2 * j])
-                            - WEBRTC_SPL_MUL_16_16(wi, frfi[2 * j + 1]) + CFFTRND;
+                    tr32 = wr * frfi[2 * j] - wi * frfi[2 * j + 1] + CFFTRND;
 
-                    ti32 = WEBRTC_SPL_MUL_16_16(wr, frfi[2 * j + 1])
-                            + WEBRTC_SPL_MUL_16_16(wi, frfi[2 * j]) + CFFTRND;
+                    ti32 = wr * frfi[2 * j + 1] + wi * frfi[2 * j] + CFFTRND;
 #endif
 
                     tr32 >>= 15 - CFFTSFT;
                     ti32 >>= 15 - CFFTSFT;
 
-                    qr32 = ((int32_t)frfi[2 * i]) << CFFTSFT;
-                    qi32 = ((int32_t)frfi[2 * i + 1]) << CFFTSFT;
+                    qr32 = ((int32_t)frfi[2 * i]) * (1 << CFFTSFT);
+                    qi32 = ((int32_t)frfi[2 * i + 1]) * (1 << CFFTSFT);
 
                     frfi[2 * j] = (int16_t)(
                         (qr32 - tr32 + CFFTRND2) >> (1 + CFFTSFT));
@@ -159,15 +158,16 @@ int WebRtcSpl_ComplexFFT(int16_t frfi[], int stages, int mode)
 
 int WebRtcSpl_ComplexIFFT(int16_t frfi[], int stages, int mode)
 {
-    int i, j, l, k, istep, n, m, scale, shift;
+    size_t i, j, l, istep, n, m;
+    int k, scale, shift;
     int16_t wr, wi;
     int32_t tr32, ti32, qr32, qi32;
     int32_t tmp32, round2;
 
     /* The 1024-value is a constant given from the size of kSinTable1024[],
      * and should not be changed depending on the input parameter 'stages'
      */
-    n = 1 << stages;
+    n = ((size_t)1) << stages;
     if (n > 1024)
         return -1;
 
@@ -183,7 +183,7 @@ int WebRtcSpl_ComplexIFFT(int16_t frfi[], int stages, int mode)
         shift = 0;
         round2 = 8192;
 
-        tmp32 = (int32_t)WebRtcSpl_MaxAbsValueW16(frfi, 2 * n);
+        tmp32 = WebRtcSpl_MaxAbsValueW16(frfi, 2 * n);
         if (tmp32 > 13573)
         {
             shift++;
@@ -270,17 +270,15 @@ int WebRtcSpl_ComplexIFFT(int16_t frfi[], int stages, int mode)
                     );
 #else
 
-                    tr32 = WEBRTC_SPL_MUL_16_16(wr, frfi[2 * j])
-                            - WEBRTC_SPL_MUL_16_16(wi, frfi[2 * j + 1]) + CIFFTRND;
+                    tr32 = wr * frfi[2 * j] - wi * frfi[2 * j + 1] + CIFFTRND;
 
-                    ti32 = WEBRTC_SPL_MUL_16_16(wr, frfi[2 * j + 1])
-                            + WEBRTC_SPL_MUL_16_16(wi, frfi[2 * j]) + CIFFTRND;
+                    ti32 = wr * frfi[2 * j + 1] + wi * frfi[2 * j] + CIFFTRND;
 #endif
                     tr32 >>= 15 - CIFFTSFT;
                     ti32 >>= 15 - CIFFTSFT;
 
-                    qr32 = ((int32_t)frfi[2 * i]) << CIFFTSFT;
-                    qi32 = ((int32_t)frfi[2 * i + 1]) << CIFFTSFT;
+                    qr32 = ((int32_t)frfi[2 * i]) * (1 << CIFFTSFT);
+                    qi32 = ((int32_t)frfi[2 * i + 1]) * (1 << CIFFTSFT);
 
                     frfi[2 * j] = (int16_t)(
                         (qr32 - tr32 + round2) >> (shift + CIFFTSFT));

cbits/webrtc/common_audio/signal_processing/complex_fft_tables.h

@@ -14,18 +14,17 @@
 void WebRtcSpl_CrossCorrelationC(int32_t* cross_correlation,
                                  const int16_t* seq1,
                                  const int16_t* seq2,
-                                 int16_t dim_seq,
-                                 int16_t dim_cross_correlation,
-                                 int16_t right_shifts,
-                                 int16_t step_seq2) {
-  int i = 0, j = 0;
+                                 size_t dim_seq,
+                                 size_t dim_cross_correlation,
+                                 int right_shifts,
+                                 int step_seq2) {
+  size_t i = 0, j = 0;
 
   for (i = 0; i < dim_cross_correlation; i++) {
-    *cross_correlation = 0;
-    /* Unrolling doesn't seem to improve performance. */
-    for (j = 0; j < dim_seq; j++) {
-      *cross_correlation += (seq1[j] * seq2[step_seq2 * i + j]) >> right_shifts;
-    }
-    cross_correlation++;
+    int32_t corr = 0;
+    for (j = 0; j < dim_seq; j++)
+      corr += (seq1[j] * seq2[j]) >> right_shifts;
+    seq2 += step_seq2;
+    *cross_correlation++ = corr;
   }
 }

cbits/webrtc/common_audio/signal_processing/cross_correlation.c

@@ -22,6 +22,7 @@
  */
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
+#include "webrtc/rtc_base/sanitizer.h"
 
 uint32_t WebRtcSpl_DivU32U16(uint32_t num, uint16_t den)
 {
@@ -97,7 +98,8 @@ int32_t WebRtcSpl_DivResultInQ31(int32_t num, int32_t den)
     return div;
 }
 
-int32_t WebRtcSpl_DivW32HiLow(int32_t num, int16_t den_hi, int16_t den_low)
+int32_t RTC_NO_SANITIZE("signed-integer-overflow")  // bugs.webrtc.org/5486
+WebRtcSpl_DivW32HiLow(int32_t num, int16_t den_hi, int16_t den_low)
 {
     int16_t approx, tmp_hi, tmp_low, num_hi, num_low;
     int32_t tmpW32;
@@ -106,19 +108,18 @@ int32_t WebRtcSpl_DivW32HiLow(int32_t num, int16_t den_hi, int16_t den_low)
     // result in Q14 (Note: 3FFFFFFF = 0.5 in Q30)
 
     // tmpW32 = 1/den = approx * (2.0 - den * approx) (in Q30)
-    tmpW32 = (WEBRTC_SPL_MUL_16_16(den_hi, approx) << 1)
-            + ((WEBRTC_SPL_MUL_16_16(den_low, approx) >> 15) << 1);
+    tmpW32 = (den_hi * approx << 1) + ((den_low * approx >> 15) << 1);
     // tmpW32 = den * approx
 
     tmpW32 = (int32_t)0x7fffffffL - tmpW32; // result in Q30 (tmpW32 = 2.0-(den*approx))
+    // UBSan: 2147483647 - -2 cannot be represented in type 'int'
 
     // Store tmpW32 in hi and low format
     tmp_hi = (int16_t)(tmpW32 >> 16);
     tmp_low = (int16_t)((tmpW32 - ((int32_t)tmp_hi << 16)) >> 1);
 
     // tmpW32 = 1/den in Q29
-    tmpW32 = ((WEBRTC_SPL_MUL_16_16(tmp_hi, approx) + (WEBRTC_SPL_MUL_16_16(tmp_low, approx)
-            >> 15)) << 1);
+    tmpW32 = (tmp_hi * approx + (tmp_low * approx >> 15)) << 1;
 
     // 1/den in hi and low format
     tmp_hi = (int16_t)(tmpW32 >> 16);
@@ -130,8 +131,8 @@ int32_t WebRtcSpl_DivW32HiLow(int32_t num, int16_t den_hi, int16_t den_low)
 
     // num * (1/den) by 32 bit multiplication (result in Q28)
 
-    tmpW32 = (WEBRTC_SPL_MUL_16_16(num_hi, tmp_hi) + (WEBRTC_SPL_MUL_16_16(num_hi, tmp_low)
-            >> 15) + (WEBRTC_SPL_MUL_16_16(num_low, tmp_hi) >> 15));
+    tmpW32 = num_hi * tmp_hi + (num_hi * tmp_low >> 15) +
+        (num_low * tmp_hi >> 15);
 
     // Put result in Q31 (convert from Q28)
     tmpW32 = WEBRTC_SPL_LSHIFT_W32(tmpW32, 3);

cbits/webrtc/common_audio/signal_processing/division_operations.c

@@ -0,0 +1,34 @@
+/*
+ *  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 "webrtc/common_audio/signal_processing/dot_product_with_scale.h"
+
+#include "webrtc/rtc_base/numerics/safe_conversions.h"
+
+int32_t WebRtcSpl_DotProductWithScale(const int16_t* vector1,
+                                      const int16_t* vector2,
+                                      size_t length,
+                                      int scaling) {
+  int64_t sum = 0;
+  size_t i = 0;
+
+  /* Unroll the loop to improve performance. */
+  for (i = 0; i + 3 < length; i += 4) {
+    sum += (vector1[i + 0] * vector2[i + 0]) >> scaling;
+    sum += (vector1[i + 1] * vector2[i + 1]) >> scaling;
+    sum += (vector1[i + 2] * vector2[i + 2]) >> scaling;
+    sum += (vector1[i + 3] * vector2[i + 3]) >> scaling;
+  }
+  for (; i < length; i++) {
+    sum += (vector1[i] * vector2[i]) >> scaling;
+  }
+
+  return rtc::saturated_cast<int32_t>(sum);
+}

cbits/webrtc/common_audio/signal_processing/dot_product_with_scale.cc

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef COMMON_AUDIO_SIGNAL_PROCESSING_DOT_PRODUCT_WITH_SCALE_H_
+#define COMMON_AUDIO_SIGNAL_PROCESSING_DOT_PRODUCT_WITH_SCALE_H_
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Calculates the dot product between two (int16_t) vectors.
+//
+// Input:
+//      - vector1       : Vector 1
+//      - vector2       : Vector 2
+//      - vector_length : Number of samples used in the dot product
+//      - scaling       : The number of right bit shifts to apply on each term
+//                        during calculation to avoid overflow, i.e., the
+//                        output will be in Q(-|scaling|)
+//
+// Return value         : The dot product in Q(-scaling)
+int32_t WebRtcSpl_DotProductWithScale(const int16_t* vector1,
+                                      const int16_t* vector2,
+                                      size_t length,
+                                      int scaling);
+
+#ifdef __cplusplus
+}
+#endif  // __cplusplus
+#endif  // COMMON_AUDIO_SIGNAL_PROCESSING_DOT_PRODUCT_WITH_SCALE_H_

cbits/webrtc/common_audio/signal_processing/dot_product_with_scale.h

@@ -10,32 +10,45 @@
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 
+#include "webrtc/rtc_base/checks.h"
+#include "webrtc/rtc_base/sanitizer.h"
+
 // TODO(Bjornv): Change the function parameter order to WebRTC code style.
 // C version of WebRtcSpl_DownsampleFast() for generic platforms.
 int WebRtcSpl_DownsampleFastC(const int16_t* data_in,
-                              int data_in_length,
+                              size_t data_in_length,
                               int16_t* data_out,
-                              int data_out_length,
+                              size_t data_out_length,
                               const int16_t* __restrict coefficients,
-                              int coefficients_length,
+                              size_t coefficients_length,
                               int factor,
-                              int delay) {
-  int i = 0;
-  int j = 0;
+                              size_t delay) {
+  int16_t* const original_data_out = data_out;
+  size_t i = 0;
+  size_t j = 0;
   int32_t out_s32 = 0;
-  int endpos = delay + factor * (data_out_length - 1) + 1;
+  size_t endpos = delay + factor * (data_out_length - 1) + 1;
 
   // Return error if any of the running conditions doesn't meet.
-  if (data_out_length <= 0 || coefficients_length <= 0
+  if (data_out_length == 0 || coefficients_length == 0
                            || data_in_length < endpos) {
     return -1;
   }
 
+  rtc_MsanCheckInitialized(coefficients, sizeof(coefficients[0]),
+                           coefficients_length);
+
   for (i = delay; i < endpos; i += factor) {
     out_s32 = 2048;  // Round value, 0.5 in Q12.
 
     for (j = 0; j < coefficients_length; j++) {
-      out_s32 += coefficients[j] * data_in[i - j];  // Q12.
+      // Negative overflow is permitted here, because this is
+      // auto-regressive filters, and the state for each batch run is
+      // stored in the "negative" positions of the output vector.
+      rtc_MsanCheckInitialized(&data_in[(ptrdiff_t) i - (ptrdiff_t) j],
+          sizeof(data_in[0]), 1);
+      // out_s32 is in Q12 domain.
+      out_s32 += coefficients[j] * data_in[(ptrdiff_t) i - (ptrdiff_t) j];
     }
 
     out_s32 >>= 12;  // Q0.
@@ -44,5 +57,9 @@ int WebRtcSpl_DownsampleFastC(const int16_t* data_in,
     *data_out++ = WebRtcSpl_SatW32ToW16(out_s32);
   }
 
+  RTC_DCHECK_EQ(original_data_out + data_out_length, data_out);
+  rtc_MsanCheckInitialized(original_data_out, sizeof(original_data_out[0]),
+                           data_out_length);
+
   return 0;
 }

cbits/webrtc/common_audio/signal_processing/downsample_fast.c

@@ -17,18 +17,21 @@
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 
-int32_t WebRtcSpl_Energy(int16_t* vector, int vector_length, int* scale_factor)
+int32_t WebRtcSpl_Energy(int16_t* vector,
+                         size_t vector_length,
+                         int* scale_factor)
 {
     int32_t en = 0;
-    int i;
-    int scaling = WebRtcSpl_GetScalingSquare(vector, vector_length, vector_length);
-    int looptimes = vector_length;
+    size_t i;
+    int scaling =
+        WebRtcSpl_GetScalingSquare(vector, vector_length, vector_length);
+    size_t looptimes = vector_length;
     int16_t *vectorptr = vector;
 
     for (i = 0; i < looptimes; i++)
     {
-        en += WEBRTC_SPL_MUL_16_16_RSFT(*vectorptr, *vectorptr, scaling);
-        vectorptr++;
+      en += (*vectorptr * *vectorptr) >> scaling;
+      vectorptr++;
     }
     *scale_factor = scaling;
 

cbits/webrtc/common_audio/signal_processing/energy.c

@@ -18,16 +18,16 @@
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 
 int16_t WebRtcSpl_GetScalingSquare(int16_t* in_vector,
-                                   int in_vector_length,
-                                   int times)
+                                   size_t in_vector_length,
+                                   size_t times)
 {
-    int16_t nbits = WebRtcSpl_GetSizeInBits(times);
-    int i;
+    int16_t nbits = WebRtcSpl_GetSizeInBits((uint32_t)times);
+    size_t i;
     int16_t smax = -1;
     int16_t sabs;
     int16_t *sptr = in_vector;
     int16_t t;
-    int looptimes = in_vector_length;
+    size_t looptimes = in_vector_length;
 
     for (i = looptimes; i > 0; i--)
     {