Using ring buffer for AudioVector 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 45 matching lines @@
 
   // Transfer input signal to an AudioMultiVector.
   AudioMultiVector input_vector(num_channels_);
   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;
 
+  std::unique_ptr<int16_t[]> input_channel(
+      new int16_t[input_length_per_channel]);
+  std::unique_ptr<int16_t[]> expanded_channel(new int16_t[expanded_length]);
   for (size_t channel = 0; channel < num_channels_; ++channel) {
-    int16_t* input_channel = &input_vector[channel][0];
-    int16_t* expanded_channel = &expanded_[channel][0];
+    input_vector[channel].CopyTo(
+        input_length_per_channel, 0, input_channel.get());
+    expanded_[channel].CopyTo(expanded_length, 0, expanded_channel.get());
+
     int16_t new_mute_factor = SignalScaling(
-        input_channel, input_length_per_channel, expanded_channel);
+        input_channel.get(), input_length_per_channel, expanded_channel.get());
 
     // 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);
+      Downsample(input_channel.get(), input_length_per_channel,
+                 expanded_channel.get(), expanded_length);
 
       // Calculate the lag of the strongest correlation period.
       best_correlation_index = CorrelateAndPeakSearch(
           old_length, input_length_per_channel, expand_period);
     }
 
     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,
       // and so on.
       int increment = 4194 / fs_mult_;
       *external_mute_factor =
-          static_cast<int16_t>(DspHelper::RampSignal(input_channel,
+          static_cast<int16_t>(DspHelper::RampSignal(input_channel.get(),
                                                      interpolation_length,
                                                      *external_mute_factor,
                                                      increment));
       DspHelper::UnmuteSignal(&input_channel[interpolation_length],
                               input_length_per_channel - interpolation_length,
                               external_mute_factor, increment,
                               &decoded_output[interpolation_length]);
     } else {
       // No muting needed.
       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_.data(), expanded_channel,
+    memmove(temp_data_.data(), expanded_channel.get(),
             sizeof(int16_t) * best_correlation_index);
     DspHelper::CrossFade(&expanded_channel[best_correlation_index],
-                         input_channel, interpolation_length,
+                         input_channel.get(), 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_.data(),
-           sizeof(temp_data_[0]) * output_length);
+    (*output)[channel].OverwriteAt(temp_data_.data(), output_length, 0);
   }
 
   // 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 209 matching lines @@
   }
   return best_correlation_index;
 }
 
 size_t Merge::RequiredFutureSamples() {
   return fs_hz_ / 100 * num_channels_;  // 10 ms.
 }
 
 
 }  // namespace webrtc