Avoiding overflow in cross correlation in NetEq.

webrtc/modules/audio_coding/neteq/merge.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.
  */
 
 #include "webrtc/modules/audio_coding/neteq/merge.h"
 
 #include <assert.h>
 #include <string.h>  // memmove, memcpy, memset, size_t
 
 #include <algorithm>  // min, max
 #include <memory>
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/neteq/audio_multi_vector.h"
+#include "webrtc/modules/audio_coding/neteq/cross_correlation.h"
 #include "webrtc/modules/audio_coding/neteq/dsp_helper.h"
 #include "webrtc/modules/audio_coding/neteq/expand.h"
 #include "webrtc/modules/audio_coding/neteq/sync_buffer.h"
 
 namespace webrtc {
 
 Merge::Merge(int fs_hz,
              size_t num_channels,
              Expand* expand,
              SyncBuffer* sync_buffer)
@@ skipping 25 matching lines @@
   input_vector.PushBackInterleaved(input, input_length);
   size_t input_length_per_channel = input_vector.Size();
   assert(input_length_per_channel == input_length / num_channels_);
 
   size_t best_correlation_index = 0;
   size_t output_length = 0;
 
   for (size_t channel = 0; channel < num_channels_; ++channel) {
     int16_t* input_channel = &input_vector[channel][0];
     int16_t* expanded_channel = &expanded_[channel][0];
-    int16_t expanded_max, input_max;
     int16_t new_mute_factor = SignalScaling(
-        input_channel, input_length_per_channel, expanded_channel,
-        &expanded_max, &input_max);
+        input_channel, input_length_per_channel, expanded_channel);
 
     // Adjust muting factor (product of "main" muting factor and expand muting
     // factor).
     int16_t* external_mute_factor = &external_mute_factor_array[channel];
     *external_mute_factor =
         (*external_mute_factor * expand_->MuteFactor(channel)) >> 14;
 
     // Update |external_mute_factor| if it is lower than |new_mute_factor|.
     if (new_mute_factor > *external_mute_factor) {
       *external_mute_factor = std::min(new_mute_factor,
                                        static_cast<int16_t>(16384));
     }
 
     if (channel == 0) {
       // Downsample, correlate, and find strongest correlation period for the
       // master (i.e., first) channel only.
       // Downsample to 4kHz sample rate.
       Downsample(input_channel, input_length_per_channel, expanded_channel,
                  expanded_length);
 
       // Calculate the lag of the strongest correlation period.
       best_correlation_index = CorrelateAndPeakSearch(
-          expanded_max, input_max, old_length,
-          input_length_per_channel, expand_period);
+          old_length, input_length_per_channel, expand_period);
     }
 
     static const int kTempDataSize = 3600;
     int16_t temp_data[kTempDataSize];  // TODO(hlundin) Remove this.
     int16_t* decoded_output = temp_data + best_correlation_index;
 
     // Mute the new decoded data if needed (and unmute it linearly).
     // This is the overlapping part of expanded_signal.
     size_t interpolation_length = std::min(
         kMaxCorrelationLength * fs_mult_,
@@ skipping 93 matching lines @@
       expanded_.PushBack(expanded_temp);
     }
     // Trim the length to exactly |required_length|.
     expanded_.PopBack(expanded_.Size() - required_length);
   }
   assert(expanded_.Size() >= required_length);
   return required_length;
 }
 
 int16_t Merge::SignalScaling(const int16_t* input, size_t input_length,
-                             const int16_t* expanded_signal,
-                             int16_t* expanded_max, int16_t* input_max) const {
+                             const int16_t* expanded_signal) const {
   // Adjust muting factor if new vector is more or less of the BGN energy.
   const size_t mod_input_length =
       std::min(static_cast<size_t>(64 * fs_mult_), input_length);
-  *expanded_max = WebRtcSpl_MaxAbsValueW16(expanded_signal, mod_input_length);
-  *input_max = WebRtcSpl_MaxAbsValueW16(input, mod_input_length);
+  const int16_t expanded_max =
+      WebRtcSpl_MaxAbsValueW16(expanded_signal, mod_input_length);
+  const int16_t input_max = WebRtcSpl_MaxAbsValueW16(input, mod_input_length);
 
   // Calculate energy of expanded signal.
   // |log_fs_mult| is log2(fs_mult_), but is not exact for 48000 Hz.
   int log_fs_mult = 30 - WebRtcSpl_NormW32(fs_mult_);
   int expanded_shift = 6 + log_fs_mult
-      - WebRtcSpl_NormW32(*expanded_max * *expanded_max);
+      - WebRtcSpl_NormW32(expanded_max * expanded_max);
   expanded_shift = std::max(expanded_shift, 0);
   int32_t energy_expanded = WebRtcSpl_DotProductWithScale(expanded_signal,
                                                           expanded_signal,
                                                           mod_input_length,
                                                           expanded_shift);
 
   // Calculate energy of input signal.
-  int input_shift = 6 + log_fs_mult -
-      WebRtcSpl_NormW32(*input_max * *input_max);
+  int input_shift = 6 + log_fs_mult - WebRtcSpl_NormW32(input_max * input_max);
   input_shift = std::max(input_shift, 0);
   int32_t energy_input = WebRtcSpl_DotProductWithScale(input, input,
                                                        mod_input_length,
                                                        input_shift);
 
   // Align to the same Q-domain.
   if (input_shift > expanded_shift) {
     energy_expanded = energy_expanded >> (input_shift - expanded_shift);
   } else {
     energy_input = energy_input >> (expanded_shift - input_shift);
@@ skipping 61 matching lines @@
            sizeof(int16_t) * (kInputDownsampLength - downsamp_temp_len));
   } else {
     WebRtcSpl_DownsampleFast(&input[signal_offset],
                              input_length - signal_offset, input_downsampled_,
                              kInputDownsampLength, filter_coefficients,
                              num_coefficients, decimation_factor,
                              kCompensateDelay);
   }
 }
 
-size_t Merge::CorrelateAndPeakSearch(int16_t expanded_max, int16_t input_max,
-                                     size_t start_position, size_t input_length,
+size_t Merge::CorrelateAndPeakSearch(size_t start_position, size_t input_length,
                                      size_t expand_period) const {
   // Calculate correlation without any normalization.
   const size_t max_corr_length = kMaxCorrelationLength;
   size_t stop_position_downsamp =
       std::min(max_corr_length, expand_->max_lag() / (fs_mult_ * 2) + 1);
-  int correlation_shift = 0;
-  if (expanded_max * input_max > 26843546) {
-    correlation_shift = 3;
-  }
 
   int32_t correlation[kMaxCorrelationLength];
-  WebRtcSpl_CrossCorrelation(correlation, input_downsampled_,
-                             expanded_downsampled_, kInputDownsampLength,
-                             stop_position_downsamp, correlation_shift, 1);
+  CrossCorrelationWithAutoShift(input_downsampled_, expanded_downsampled_,
+                                kInputDownsampLength, stop_position_downsamp, 1,
+                                correlation);
 
   // Normalize correlation to 14 bits and copy to a 16-bit array.
   const size_t pad_length = expand_->overlap_length() - 1;
   const size_t correlation_buffer_size = 2 * pad_length + kMaxCorrelationLength;
   std::unique_ptr<int16_t[]> correlation16(
       new int16_t[correlation_buffer_size]);
   memset(correlation16.get(), 0, correlation_buffer_size * sizeof(int16_t));
   int16_t* correlation_ptr = &correlation16[pad_length];
   int32_t max_correlation = WebRtcSpl_MaxAbsValueW32(correlation,
                                                      stop_position_downsamp);
@@ skipping 38 matching lines @@
   }
   return best_correlation_index;
 }
 
 size_t Merge::RequiredFutureSamples() {
   return fs_hz_ / 100 * num_channels_;  // 10 ms.
 }
 
 
 }  // namespace webrtc