Using ring buffer for AudioVector in NetEq.

webrtc/modules/audio_coding/neteq/audio_multi_vector.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 88 matching lines @@
 }
 
 void AudioMultiVector::PushBackFromIndex(const AudioMultiVector& append_this,
                                          size_t index) {
   assert(index < append_this.Size());
   index = std::min(index, append_this.Size() - 1);
   size_t length = append_this.Size() - index;
   assert(num_channels_ == append_this.num_channels_);
   if (num_channels_ == append_this.num_channels_) {
     for (size_t i = 0; i < num_channels_; ++i) {
-      channels_[i]->PushBack(&append_this[i][index], length);
+      channels_[i]->PushBack(append_this[i], length, index);
     }
   }
 }
 
 void AudioMultiVector::PopFront(size_t length) {
   for (size_t i = 0; i < num_channels_; ++i) {
     channels_[i]->PopFront(length);
   }
 }
 
 void AudioMultiVector::PopBack(size_t length) {
   for (size_t i = 0; i < num_channels_; ++i) {
     channels_[i]->PopBack(length);
   }
 }
 
 size_t AudioMultiVector::ReadInterleaved(size_t length,
                                          int16_t* destination) const {
   return ReadInterleavedFromIndex(0, length, destination);
 }
 
 size_t AudioMultiVector::ReadInterleavedFromIndex(size_t start_index,
                                                   size_t length,
                                                   int16_t* destination) const {
   RTC_DCHECK(destination);
   size_t index = 0;  // Number of elements written to |destination| so far.
-  assert(start_index <= Size());
+  RTC_DCHECK_LE(start_index, Size());
   start_index = std::min(start_index, Size());
   if (length + start_index > Size()) {
     length = Size() - start_index;
   }
   if (num_channels_ == 1) {
     // Special case to avoid the nested for loop below.
-    memcpy(destination, &(*this)[0][start_index], length * sizeof(int16_t));
+    (*this)[0].CopyTo(length, start_index, destination);
     return length;
   }
   for (size_t i = 0; i < length; ++i) {
     for (size_t channel = 0; channel < num_channels_; ++channel) {
       destination[index] = (*this)[channel][i + start_index];
       ++index;
     }
   }
   return index;
 }
 
 size_t AudioMultiVector::ReadInterleavedFromEnd(size_t length,
                                                 int16_t* destination) const {
   length = std::min(length, Size());  // Cannot read more than Size() elements.
   return ReadInterleavedFromIndex(Size() - length, length, destination);
 }
 
 void AudioMultiVector::OverwriteAt(const AudioMultiVector& insert_this,
                                    size_t length,
                                    size_t position) {
   assert(num_channels_ == insert_this.num_channels_);
   // Cap |length| at the length of |insert_this|.
   assert(length <= insert_this.Size());
   length = std::min(length, insert_this.Size());
   if (num_channels_ == insert_this.num_channels_) {
     for (size_t i = 0; i < num_channels_; ++i) {
-      channels_[i]->OverwriteAt(&insert_this[i][0], length, position);
+      channels_[i]->OverwriteAt(insert_this[i], length, position);
     }
   }
 }
 
 void AudioMultiVector::CrossFade(const AudioMultiVector& append_this,
                                  size_t fade_length) {
   assert(num_channels_ == append_this.num_channels_);
   if (num_channels_ == append_this.num_channels_) {
     for (size_t i = 0; i < num_channels_; ++i) {
       channels_[i]->CrossFade(append_this[i], fade_length);
@@ skipping 32 matching lines @@
 
 const AudioVector& AudioMultiVector::operator[](size_t index) const {
   return *(channels_[index]);
 }
 
 AudioVector& AudioMultiVector::operator[](size_t index) {
   return *(channels_[index]);
 }
 
 }  // namespace webrtc