Fix for integer overflow in NetEq.

webrtc/modules/audio_coding/neteq/expand.cc

 /*
  *  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.
  */
 
@@ skipping 657 matching lines @@
            &(audio_history[signal_length - kUnvoicedLpcOrder]),
            sizeof(int16_t) * kUnvoicedLpcOrder);
     memcpy(unvoiced_vector - kUnvoicedLpcOrder,
            &(audio_history[signal_length - 128 - kUnvoicedLpcOrder]),
            sizeof(int16_t) * kUnvoicedLpcOrder);
     WebRtcSpl_FilterMAFastQ12(&audio_history[signal_length - 128],
                               unvoiced_vector,
                               parameters.ar_filter,
                               kUnvoicedLpcOrder + 1,
                               128);
-    int16_t unvoiced_prescale;
-    if (WebRtcSpl_MaxAbsValueW16(unvoiced_vector, 128) > 4000) {
-      unvoiced_prescale = 4;
-    } else {
-      unvoiced_prescale = 0;
+    const int16_t unvoiced_max_abs =
+        WebRtcSpl_MaxAbsValueW16(unvoiced_vector, 128);
+    // Pick the smallest n such that 2^n > unvoiced_max_abs; then the maximum
+    // value of the dot product is less than 2^7 * 2^(2*n) = 2^(2*n + 7), so to
+    // prevent overflows we want 2n + 7 <= 31, which means we should shift by
+    // 2n + 7 - 31 bits, if this value is greater than zero.
+    int unvoiced_prescale =
+        std::max(0, 2 * WebRtcSpl_GetSizeInBits(unvoiced_max_abs) - 24);
+    // Since WebRtcSpl_MaxAbsValueW16 returns 2^15 - 1 when the input contains
+    // -2^15, we have to increase the prescale in that case to avoid the
+    // possibility of overflow.
+    if (unvoiced_max_abs == WEBRTC_SPL_WORD16_MAX) {
+      unvoiced_prescale++;

[kwiberg-webrtc, 2016/12/16 10:23:32]

Wouldn't you need to add 2, not just 1? And it's probably easier to follow if
you modify unvoiced_abs_max earlier:

  const int unvoiced_max_abs = [&]{
    const int16_t max_abs = WebRtcSpl_MaxAbsValueW16(unvoiced_vector, 128);
    // Since WebRtcSpl_MaxAbsValueW16 returns 2^15 - 1 when the input contains
    // -2^15, we have to conservatively bump the return value by 1
    // if it is 2^15 - 1.
    return max_abs == WEBRTC_SPL_WORD16_MAX ? max_abs + 1 : max_abs;
  }();

[ivoc, 2016/12/16 11:45:01]

The worst case is if the whole array is filled with -2^15, in that case the
value of the dot product will be 2^7 * 2^15 * 2^15, which is 2^37. If we shift
this by 7 (which is what the +1 will do), the sum will be 2^30, which can easily
be represented as a 32-bit int. With a shift of 6 it would be 2^31 and it
overflows by 1, because int32 only goes up to 2^31 - 1. 

Your method looks nicer however, so I'll use that instead.

     }
+
     int32_t unvoiced_energy = WebRtcSpl_DotProductWithScale(unvoiced_vector,
                                                             unvoiced_vector,
                                                             128,
                                                             unvoiced_prescale);
 
     // Normalize |unvoiced_energy| to 28 or 29 bits to preserve sqrt() accuracy.
     int16_t unvoiced_scale = WebRtcSpl_NormW32(unvoiced_energy) - 3;
     // Make sure we do an odd number of shifts since we already have 7 shifts
     // from dividing with 128 earlier. This will make the total scale factor
     // even, which is suitable for the sqrt.
@@ skipping 267 matching lines @@
   const size_t kMaxRandSamples = RandomVector::kRandomTableSize;
   while (samples_generated < length) {
     size_t rand_length = std::min(length - samples_generated, kMaxRandSamples);
     random_vector_->IncreaseSeedIncrement(seed_increment);
     random_vector_->Generate(rand_length, &random_vector[samples_generated]);
     samples_generated += rand_length;
   }
 }
 
 }  // namespace webrtc