Adding 120 ms frame length support 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.
  */
 
@@ skipping 21 matching lines @@
     : fs_hz_(fs_hz),
       num_channels_(num_channels),
       fs_mult_(fs_hz_ / 8000),
       timestamps_per_call_(static_cast<size_t>(fs_hz_ / 100)),
       expand_(expand),
       sync_buffer_(sync_buffer),
       expanded_(num_channels_) {
   assert(num_channels_ > 0);
 }
 
+Merge::~Merge() = default;
+
 size_t Merge::Process(int16_t* input, size_t input_length,
                       int16_t* external_mute_factor_array,
                       AudioMultiVector* output) {
   // TODO(hlundin): Change to an enumerator and skip assert.
   assert(fs_hz_ == 8000 || fs_hz_ == 16000 || fs_hz_ ==  32000 ||
          fs_hz_ == 48000);
   assert(fs_hz_ <= kMaxSampleRate);  // Should not be possible.
 
   size_t old_length;
   size_t expand_period;
@@ skipping 32 matching lines @@
       // 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(
           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;
+    temp_data_.resize(input_length_per_channel + best_correlation_index);
+    int16_t* decoded_output = temp_data_.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_,
         expanded_length - best_correlation_index);
     interpolation_length = std::min(interpolation_length,
                                     input_length_per_channel);
     if (*external_mute_factor < 16384) {
       // Set a suitable muting slope (Q20). 0.004 for NB, 0.002 for WB,
@@ skipping 13 matching lines @@
       memmove(
           &decoded_output[interpolation_length],
           &input_channel[interpolation_length],
           sizeof(int16_t) * (input_length_per_channel - interpolation_length));
     }
 
     // Do overlap and mix linearly.
     int16_t increment =
         static_cast<int16_t>(16384 / (interpolation_length + 1));  // In Q14.
     int16_t mute_factor = 16384 - increment;
-    memmove(temp_data, expanded_channel,
+    memmove(temp_data_.data(), expanded_channel,
             sizeof(int16_t) * best_correlation_index);
     DspHelper::CrossFade(&expanded_channel[best_correlation_index],
                          input_channel, interpolation_length,
                          &mute_factor, increment, decoded_output);
 
     output_length = best_correlation_index + input_length_per_channel;
     if (channel == 0) {
       assert(output->Empty());  // Output should be empty at this point.
       output->AssertSize(output_length);
     } else {
       assert(output->Size() == output_length);
     }
-    memcpy(&(*output)[channel][0], temp_data,
-           sizeof(temp_data[0]) * output_length);
+    memcpy(&(*output)[channel][0], temp_data_.data(),
+           sizeof(temp_data_[0]) * output_length);
   }
 
   // Copy back the first part of the data to |sync_buffer_| and remove it from
   // |output|.
   sync_buffer_->ReplaceAtIndex(*output, old_length, sync_buffer_->next_index());
   output->PopFront(old_length);
 
   // Return new added length. |old_length| samples were borrowed from
   // |sync_buffer_|.
   return output_length - old_length;
@@ skipping 46 matching lines @@
   return required_length;
 }
 
 int16_t Merge::SignalScaling(const int16_t* input, size_t input_length,
                              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);
   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);
-  expanded_shift = std::max(expanded_shift, 0);
+  int32_t factor = (expanded_max * expanded_max) /

[minyue-webrtc, 2016/05/02 10:44:52]

first fix:

old code does give enough shifts, since log_fs_mult is not right for 48000 Hz

[hlundin-webrtc, 2016/05/02 11:28:15]

Acknowledged.

[minyue-webrtc, 2016/05/02 11:41:12]

ok. but I ought to modify my sentence as "old code does NOT give enough shifts".
I think you have realized it.

+      (std::numeric_limits<int32_t>::max() /
+          static_cast<int32_t>(mod_input_length));
+  const int expanded_shift = factor == 0 ? 0 : 31 - WebRtcSpl_NormW32(factor);
   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);
-  input_shift = std::max(input_shift, 0);
+  const int16_t input_max = WebRtcSpl_MaxAbsValueW16(input, mod_input_length);
+  factor = (input_max * input_max) / (std::numeric_limits<int32_t>::max() /
+      static_cast<int32_t>(mod_input_length));
+  const int input_shift = factor == 0 ? 0 : 31 - WebRtcSpl_NormW32(factor);
   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 129 matching lines @@
   }
   return best_correlation_index;
 }
 
 size_t Merge::RequiredFutureSamples() {
   return fs_hz_ / 100 * num_channels_;  // 10 ms.
 }
 
 
 }  // namespace webrtc