Using ring buffer for AudioVector 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 94 matching lines @@
   // Copy lag+overlap data.
   size_t expansion_vector_position = expansion_vector_length - current_lag -
       overlap_length_;
   size_t temp_length = current_lag + overlap_length_;
   for (size_t channel_ix = 0; channel_ix < num_channels_; ++channel_ix) {
     ChannelParameters& parameters = channel_parameters_[channel_ix];
     if (current_lag_index_ == 0) {
       // Use only expand_vector0.
       assert(expansion_vector_position + temp_length <=
              parameters.expand_vector0.Size());
-      memcpy(voiced_vector_storage,
-             &parameters.expand_vector0[expansion_vector_position],
-             sizeof(int16_t) * temp_length);
+      parameters.expand_vector0.CopyTo(temp_length, expansion_vector_position,
+                                       voiced_vector_storage);
     } else if (current_lag_index_ == 1) {
+      std::unique_ptr<int16_t[]> temp_0(new int16_t[temp_length]);
+      parameters.expand_vector0.CopyTo(temp_length, expansion_vector_position,
+                                       temp_0.get());
+      std::unique_ptr<int16_t[]> temp_1(new int16_t[temp_length]);
+      parameters.expand_vector1.CopyTo(temp_length, expansion_vector_position,
+                                       temp_1.get());
       // Mix 3/4 of expand_vector0 with 1/4 of expand_vector1.
-      WebRtcSpl_ScaleAndAddVectorsWithRound(
-          &parameters.expand_vector0[expansion_vector_position], 3,
-          &parameters.expand_vector1[expansion_vector_position], 1, 2,
-          voiced_vector_storage, temp_length);
+      WebRtcSpl_ScaleAndAddVectorsWithRound(temp_0.get(), 3, temp_1.get(), 1, 2,
+                                            voiced_vector_storage, temp_length);
     } else if (current_lag_index_ == 2) {
       // Mix 1/2 of expand_vector0 with 1/2 of expand_vector1.
       assert(expansion_vector_position + temp_length <=
              parameters.expand_vector0.Size());
       assert(expansion_vector_position + temp_length <=
              parameters.expand_vector1.Size());
-      WebRtcSpl_ScaleAndAddVectorsWithRound(
-          &parameters.expand_vector0[expansion_vector_position], 1,
-          &parameters.expand_vector1[expansion_vector_position], 1, 1,
-          voiced_vector_storage, temp_length);
+
+      std::unique_ptr<int16_t[]> temp_0(new int16_t[temp_length]);
+      parameters.expand_vector0.CopyTo(temp_length, expansion_vector_position,
+                                       temp_0.get());
+      std::unique_ptr<int16_t[]> temp_1(new int16_t[temp_length]);
+      parameters.expand_vector1.CopyTo(temp_length, expansion_vector_position,
+                                       temp_1.get());
+      WebRtcSpl_ScaleAndAddVectorsWithRound(temp_0.get(), 1, temp_1.get(), 1, 1,
+                                            voiced_vector_storage, temp_length);
     }
 
     // Get tapering window parameters. Values are in Q15.
     int16_t muting_window, muting_window_increment;
     int16_t unmuting_window, unmuting_window_increment;
     if (fs_hz_ == 8000) {
       muting_window = DspHelper::kMuteFactorStart8kHz;
       muting_window_increment = DspHelper::kMuteFactorIncrement8kHz;
       unmuting_window = DspHelper::kUnmuteFactorStart8kHz;
       unmuting_window_increment = DspHelper::kUnmuteFactorIncrement8kHz;
@@ skipping 148 matching lines @@
 
     // Add background noise to the combined voiced-unvoiced signal.
     for (size_t i = 0; i < current_lag; i++) {
       temp_data[i] = temp_data[i] + noise_vector[i];
     }
     if (channel_ix == 0) {
       output->AssertSize(current_lag);
     } else {
       assert(output->Size() == current_lag);
     }
-    memcpy(&(*output)[channel_ix][0], temp_data,
-           sizeof(temp_data[0]) * current_lag);
+    (*output)[channel_ix].OverwriteAt(temp_data, current_lag, 0);
   }
 
   // Increase call number and cap it.
   consecutive_expands_ = consecutive_expands_ >= kMaxConsecutiveExpands ?
       kMaxConsecutiveExpands : consecutive_expands_ + 1;
   expand_duration_samples_ += output->Size();
   // Clamp the duration counter at 2 seconds.
   expand_duration_samples_ =
       std::min(expand_duration_samples_, rtc::checked_cast<size_t>(fs_hz_ * 2));
   return 0;
@@ skipping 52 matching lines @@
   int fs_mult = fs_hz_ / 8000;
 
   // Pre-calculate common multiplications with fs_mult.
   size_t fs_mult_4 = static_cast<size_t>(fs_mult * 4);
   size_t fs_mult_20 = static_cast<size_t>(fs_mult * 20);
   size_t fs_mult_120 = static_cast<size_t>(fs_mult * 120);
   size_t fs_mult_dist_len = fs_mult * kDistortionLength;
   size_t fs_mult_lpc_analysis_len = fs_mult * kLpcAnalysisLength;
 
   const size_t signal_length = static_cast<size_t>(256 * fs_mult);
-  const int16_t* audio_history =
-      &(*sync_buffer_)[0][sync_buffer_->Size() - signal_length];
+
+  const size_t audio_history_position = sync_buffer_->Size() - signal_length;
+  std::unique_ptr<int16_t[]> audio_history(new int16_t[signal_length]);
+  (*sync_buffer_)[0].CopyTo(signal_length, audio_history_position,
+                            audio_history.get());
 
   // Initialize.
   InitializeForAnExpandPeriod();
 
   // Calculate correlation in downsampled domain (4 kHz sample rate).
   size_t correlation_length = 51;  // TODO(hlundin): Legacy bit-exactness.
   // If it is decided to break bit-exactness |correlation_length| should be
   // initialized to the return value of Correlation().
-  Correlation(audio_history, signal_length, correlation_vector);
+  Correlation(audio_history.get(), signal_length, correlation_vector);
 
   // Find peaks in correlation vector.
   DspHelper::PeakDetection(correlation_vector, correlation_length,
                            kNumCorrelationCandidates, fs_mult,
                            best_correlation_index, best_correlation);
 
   // Adjust peak locations; cross-correlation lags start at 2.5 ms
   // (20 * fs_mult samples).
   best_correlation_index[0] += fs_mult_20;
   best_correlation_index[1] += fs_mult_20;
@@ skipping 136 matching lines @@
       amplitude_ratio =
           static_cast<int16_t>(WebRtcSpl_SqrtFloor(energy_ratio << 13));
       // Copy the two vectors and give them the same energy.
       parameters.expand_vector0.Clear();
       parameters.expand_vector0.PushBack(vector1, expansion_length);
       parameters.expand_vector1.Clear();
       if (parameters.expand_vector1.Size() < expansion_length) {
         parameters.expand_vector1.Extend(
             expansion_length - parameters.expand_vector1.Size());
       }
-      WebRtcSpl_AffineTransformVector(&parameters.expand_vector1[0],
+      std::unique_ptr<int16_t[]> temp_1(new int16_t[expansion_length]);
+      WebRtcSpl_AffineTransformVector(temp_1.get(),
                                       const_cast<int16_t*>(vector2),
                                       amplitude_ratio,
                                       4096,
                                       13,
                                       expansion_length);
+      parameters.expand_vector1.OverwriteAt(temp_1.get(), expansion_length, 0);
     } else {
       // Energy change constraint not fulfilled. Only use last vector.
       parameters.expand_vector0.Clear();
       parameters.expand_vector0.PushBack(vector1, expansion_length);
       // Copy from expand_vector0 to expand_vector1.
       parameters.expand_vector0.CopyTo(&parameters.expand_vector1);
       // Set the energy_ratio since it is used by muting slope.
       if ((energy1 / 4 < energy2) || (energy2 == 0)) {
         amplitude_ratio = 4096;  // 0.5 in Q13.
       } else {
@@ skipping 379 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