Now using rtc::Buffer in FineAudioBuffer

webrtc/modules/audio_device/fine_audio_buffer.cc

 /*
  *  Copyright (c) 2013 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 18 matching lines @@
       samples_per_10_ms_(static_cast<size_t>(sample_rate_ * 10 / 1000)),
       bytes_per_10_ms_(samples_per_10_ms_ * sizeof(int16_t)),
       playout_cached_buffer_start_(0),
       playout_cached_bytes_(0),
       // Allocate extra space on the recording side to reduce the number of
       // memmove() calls.
       required_record_buffer_size_bytes_(
           5 * (desired_frame_size_bytes + bytes_per_10_ms_)),
       record_cached_bytes_(0),
       record_read_pos_(0),
-      record_write_pos_(0) {
+      record_buffer_(0, required_record_buffer_size_bytes_) {
   playout_cache_buffer_.reset(new int8_t[bytes_per_10_ms_]);
-  record_cache_buffer_.reset(new int8_t[required_record_buffer_size_bytes_]);
-  memset(record_cache_buffer_.get(), 0, required_record_buffer_size_bytes_);
 }
 
 FineAudioBuffer::~FineAudioBuffer() {}
 
 size_t FineAudioBuffer::RequiredPlayoutBufferSizeBytes() {
   // It is possible that we store the desired frame size - 1 samples. Since new
   // audio frames are pulled in chunks of 10ms we will need a buffer that can
   // hold desired_frame_size - 1 + 10ms of data. We omit the - 1.
   return desired_frame_size_bytes_ + bytes_per_10_ms_;
 }
 
 void FineAudioBuffer::ResetPlayout() {
   playout_cached_buffer_start_ = 0;
   playout_cached_bytes_ = 0;
   memset(playout_cache_buffer_.get(), 0, bytes_per_10_ms_);
 }
 
 void FineAudioBuffer::ResetRecord() {
   record_cached_bytes_ = 0;
   record_read_pos_ = 0;
-  record_write_pos_ = 0;
-  memset(record_cache_buffer_.get(), 0, required_record_buffer_size_bytes_);
+  record_buffer_.Clear();
 }
 
 void FineAudioBuffer::GetPlayoutData(int8_t* buffer) {
   if (desired_frame_size_bytes_ <= playout_cached_bytes_) {
     memcpy(buffer, &playout_cache_buffer_.get()[playout_cached_buffer_start_],
            desired_frame_size_bytes_);
     playout_cached_buffer_start_ += desired_frame_size_bytes_;
     playout_cached_bytes_ -= desired_frame_size_bytes_;
     RTC_CHECK_LT(playout_cached_buffer_start_ + playout_cached_bytes_,
                  bytes_per_10_ms_);
@@ skipping 36 matching lines @@
   memcpy(playout_cache_buffer_.get(), cache_ptr, playout_cached_bytes_);
 }
 
 void FineAudioBuffer::DeliverRecordedData(const int8_t* buffer,
                                           size_t size_in_bytes,
                                           int playout_delay_ms,
                                           int record_delay_ms) {
   // Check if the temporary buffer can store the incoming buffer. If not,
   // move the remaining (old) bytes to the beginning of the temporary buffer
   // and start adding new samples after the old samples.
-  if (record_write_pos_ + size_in_bytes > required_record_buffer_size_bytes_) {
+  if (record_buffer_.size() +  size_in_bytes > record_buffer_.capacity()) {
     if (record_cached_bytes_ > 0) {
-      memmove(record_cache_buffer_.get(),
-              record_cache_buffer_.get() + record_read_pos_,
+      memmove(record_buffer_.data(),
+              record_buffer_.data() + record_read_pos_,
               record_cached_bytes_);
     }
-    record_write_pos_ = record_cached_bytes_;
+    record_buffer_.SetSize(record_cached_bytes_);
     record_read_pos_ = 0;
   }
   // Add recorded samples to a temporary buffer.
-  memcpy(record_cache_buffer_.get() + record_write_pos_, buffer, size_in_bytes);
-  record_write_pos_ += size_in_bytes;
+  record_buffer_.AppendData(buffer, size_in_bytes);

[kwiberg-webrtc, 2017/02/22 15:25:39]

I don't think this is quite right. .capacity() is only useful if you want to
know when the Buffer will do internal reallocations.

What I think you should do when new data arrives is this:

  record_buffer_.AppendData(buffer, size_in_bytes);

Predictably, this will append new data to the Buffer, growing it if necessary.
And when consuming x bytes of data:

  DCHECK(x <= record_buffer_.size());
  DoSomething(record_buffer_.data(), x);
  memmove(record_buffer_.data(), record_buffer_.data() + x,
          record_buffer_.size() - x);
  record_buffer_.SetSize(record_buffer_.size() - x);

This will use the first x bytes of data, then move the remaining data to the
front and truncate the Buffer.

No separate read or write position is needed; you always read from the beginning
of the Buffer, and write at the end.

Of course, there are ways to optimize this so that you need to memmove less, but
this is the straightforward way of doing it.

[henrika_webrtc, 2017/02/22 16:30:25]

Great comments. Will fix!

   record_cached_bytes_ += size_in_bytes;
   // Consume samples in temporary buffer in chunks of 10ms until there is not
   // enough data left. The number of remaining bytes in the cache is given by
   // |record_cached_bytes_| after this while loop is done.
   while (record_cached_bytes_ >= bytes_per_10_ms_) {
     device_buffer_->SetRecordedBuffer(
-        record_cache_buffer_.get() + record_read_pos_, samples_per_10_ms_);
+        record_buffer_.data() + record_read_pos_, samples_per_10_ms_);
     device_buffer_->SetVQEData(playout_delay_ms, record_delay_ms, 0);
     device_buffer_->DeliverRecordedData();
     // Read next chunk of 10ms data.
     record_read_pos_ += bytes_per_10_ms_;
     // Reduce number of cached bytes with the consumed amount.
     record_cached_bytes_ -= bytes_per_10_ms_;
   }
 }
 
 }  // namespace webrtc