Now uses rtc::Buffer in AudioDeviceBuffer

webrtc/modules/audio_device/audio_device_buffer.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 @@
     kTimerIntervalInSeconds * rtc::kNumMillisecsPerSec;
 
 AudioDeviceBuffer::AudioDeviceBuffer()
     : audio_transport_cb_(nullptr),
       task_queue_(kTimerQueueName),
       timer_has_started_(false),
       rec_sample_rate_(0),
       play_sample_rate_(0),
       rec_channels_(0),
       play_channels_(0),
-      rec_channel_(AudioDeviceModule::kChannelBoth),
       rec_bytes_per_sample_(0),
       play_bytes_per_sample_(0),
-      rec_samples_per_10ms_(0),
-      rec_bytes_per_10ms_(0),
-      play_samples_per_10ms_(0),
-      play_bytes_per_10ms_(0),
       current_mic_level_(0),
       new_mic_level_(0),
       typing_status_(false),
       play_delay_ms_(0),
       rec_delay_ms_(0),
       clock_drift_(0),
       num_stat_reports_(0),
       rec_callbacks_(0),
       last_rec_callbacks_(0),
       play_callbacks_(0),
       last_play_callbacks_(0),
       rec_samples_(0),
       last_rec_samples_(0),
       play_samples_(0),
       last_play_samples_(0),
       last_log_stat_time_(0),
       max_rec_level_(0),
       max_play_level_(0),
       num_rec_level_is_zero_(0) {
   LOG(INFO) << "AudioDeviceBuffer::ctor";
-  // TODO(henrika): improve buffer handling and ensure that we don't allocate
-  // more than what is required.
-  play_buffer_.reset(new int8_t[kMaxBufferSizeBytes]);
-  rec_buffer_.reset(new int8_t[kMaxBufferSizeBytes]);
 }
 
 AudioDeviceBuffer::~AudioDeviceBuffer() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(INFO) << "AudioDeviceBuffer::~dtor";
 
   size_t total_diff_time = 0;
   int num_measurements = 0;
   LOG(INFO) << "[playout diff time => #measurements]";
   for (size_t diff = 0; diff < arraysize(playout_diff_times_); ++diff) {
@@ skipping 18 matching lines @@
   // and reading these members on the creating thread feels safe.
   if (rec_callbacks_ > 0 && num_stat_reports_ > 0) {
     RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.RecordedOnlyZeros",
     static_cast<int>(num_stat_reports_ == num_rec_level_is_zero_));
   }
 }
 
 int32_t AudioDeviceBuffer::RegisterAudioCallback(
     AudioTransport* audio_callback) {
   LOG(INFO) << __FUNCTION__;
-  rtc::CritScope lock(&_critSectCb);
+  rtc::CritScope lock(&lock_cb_);
   audio_transport_cb_ = audio_callback;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::InitPlayout() {
   LOG(INFO) << __FUNCTION__;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ResetPlayStats();
   if (!timer_has_started_) {
     StartTimer();
     timer_has_started_ = true;
   }
   return 0;
 }
 
 int32_t AudioDeviceBuffer::InitRecording() {
   LOG(INFO) << __FUNCTION__;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ResetRecStats();
   if (!timer_has_started_) {
     StartTimer();
     timer_has_started_ = true;
   }
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) {
   LOG(INFO) << "SetRecordingSampleRate(" << fsHz << ")";
-  rtc::CritScope lock(&_critSect);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rec_sample_rate_ = fsHz;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetPlayoutSampleRate(uint32_t fsHz) {
   LOG(INFO) << "SetPlayoutSampleRate(" << fsHz << ")";
-  rtc::CritScope lock(&_critSect);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   play_sample_rate_ = fsHz;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::RecordingSampleRate() const {
   return rec_sample_rate_;
 }
 
 int32_t AudioDeviceBuffer::PlayoutSampleRate() const {
   return play_sample_rate_;
 }
 
 int32_t AudioDeviceBuffer::SetRecordingChannels(size_t channels) {
   LOG(INFO) << "SetRecordingChannels(" << channels << ")";
-  rtc::CritScope lock(&_critSect);
+  rtc::CritScope lock(&lock_);
   rec_channels_ = channels;
-  rec_bytes_per_sample_ =
-      2 * channels;  // 16 bits per sample in mono, 32 bits in stereo
+  rec_bytes_per_sample_ = sizeof(int16_t) * channels;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetPlayoutChannels(size_t channels) {
   LOG(INFO) << "SetPlayoutChannels(" << channels << ")";
-  rtc::CritScope lock(&_critSect);
+  rtc::CritScope lock(&lock_);
   play_channels_ = channels;
-  // 16 bits per sample in mono, 32 bits in stereo
-  play_bytes_per_sample_ = 2 * channels;
+  play_bytes_per_sample_ = sizeof(int16_t) * channels;
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetRecordingChannel(
     const AudioDeviceModule::ChannelType channel) {
-  rtc::CritScope lock(&_critSect);
-
-  if (rec_channels_ == 1) {
-    return -1;
-  }
-
-  if (channel == AudioDeviceModule::kChannelBoth) {
-    // two bytes per channel
-    rec_bytes_per_sample_ = 4;
-  } else {
-    // only utilize one out of two possible channels (left or right)
-    rec_bytes_per_sample_ = 2;
-  }
-  rec_channel_ = channel;
-
-  return 0;
+  LOG(INFO) << "SetRecordingChannel(" << channel << ")";
+  LOG(LS_WARNING) << "Not implemented";
+  // Add DCHECK to ensure that user does not try to use this API with a non-
+  // default parameter.
+  RTC_DCHECK_EQ(channel, AudioDeviceModule::kChannelBoth);
+  return -1;
 }
 
 int32_t AudioDeviceBuffer::RecordingChannel(
     AudioDeviceModule::ChannelType& channel) const {
-  channel = rec_channel_;
-  return 0;
+  LOG(LS_WARNING) << "Not implemented";
+  return -1;
 }
 
 size_t AudioDeviceBuffer::RecordingChannels() const {
   return rec_channels_;
 }
 
 size_t AudioDeviceBuffer::PlayoutChannels() const {
   return play_channels_;
 }
 
@@ skipping 36 matching lines @@
   return 0;
 }
 
 int32_t AudioDeviceBuffer::StopOutputFileRecording() {
   LOG(LS_WARNING) << "Not implemented";
   return 0;
 }
 
 int32_t AudioDeviceBuffer::SetRecordedBuffer(const void* audio_buffer,
                                              size_t num_samples) {
-  UpdateRecordingParameters();
-  // WebRTC can only receive audio in 10ms chunks, hence we fail if the native
-  // audio layer tries to deliver something else.
-  RTC_CHECK_EQ(num_samples, rec_samples_per_10ms_);
-
-  rtc::CritScope lock(&_critSect);
-
-  if (rec_channel_ == AudioDeviceModule::kChannelBoth) {
-    // Copy the complete input buffer to the local buffer.
-    memcpy(&rec_buffer_[0], audio_buffer, rec_bytes_per_10ms_);
-  } else {
-    int16_t* ptr16In = (int16_t*)audio_buffer;
-    int16_t* ptr16Out = (int16_t*)&rec_buffer_[0];
-    if (AudioDeviceModule::kChannelRight == rec_channel_) {
-      ptr16In++;
-    }
-    // Exctract left or right channel from input buffer to the local buffer.
-    for (size_t i = 0; i < rec_samples_per_10ms_; i++) {
-      *ptr16Out = *ptr16In;
-      ptr16Out++;
-      ptr16In++;
-      ptr16In++;
-    }
+  const size_t rec_bytes_per_sample = [&] {
+    rtc::CritScope lock(&lock_);
+    return rec_bytes_per_sample_;
+  }();
+  // Copy the complete input buffer to the local buffer.
+  const size_t size_in_bytes = num_samples * rec_bytes_per_sample;
+  const size_t old_size = rec_buffer_.size();
+  rec_buffer_.SetData(static_cast<const uint8_t*>(audio_buffer), size_in_bytes);
+  // Keep track of the size of the recording buffer. Only updated when the
+  // size changes, which is a rare event.
+  if (old_size != rec_buffer_.size()) {
+    LOG(LS_INFO) << "Size of recording buffer: " << rec_buffer_.size();
   }
-
   // Update some stats but do it on the task queue to ensure that the members
   // are modified and read on the same thread.
   task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::UpdateRecStats, this,
                                  audio_buffer, num_samples));
   return 0;
 }
 
 int32_t AudioDeviceBuffer::DeliverRecordedData() {
-  rtc::CritScope lock(&_critSectCb);
-
+  rtc::CritScope lock(&lock_cb_);
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
-
-  int32_t res(0);
-  uint32_t newMicLevel(0);
-  uint32_t totalDelayMS = play_delay_ms_ + rec_delay_ms_;
-  res = audio_transport_cb_->RecordedDataIsAvailable(
-      &rec_buffer_[0], rec_samples_per_10ms_, rec_bytes_per_sample_,
-      rec_channels_, rec_sample_rate_, totalDelayMS, clock_drift_,
-      current_mic_level_, typing_status_, newMicLevel);
+  const size_t rec_bytes_per_sample = [&] {
+    rtc::CritScope lock(&lock_);
+    return rec_bytes_per_sample_;
+  }();
+  uint32_t new_mic_level(0);
+  uint32_t total_delay_ms = play_delay_ms_ + rec_delay_ms_;
+  size_t num_samples = rec_buffer_.size() / rec_bytes_per_sample;
+  int32_t res = audio_transport_cb_->RecordedDataIsAvailable(
+      rec_buffer_.data(), num_samples, rec_bytes_per_sample_, rec_channels_,
+      rec_sample_rate_, total_delay_ms, clock_drift_, current_mic_level_,
+      typing_status_, new_mic_level);
   if (res != -1) {
-    new_mic_level_ = newMicLevel;
+    new_mic_level_ = new_mic_level;
   } else {
     LOG(LS_ERROR) << "RecordedDataIsAvailable() failed";
   }
-
   return 0;
 }
 
 int32_t AudioDeviceBuffer::RequestPlayoutData(size_t num_samples) {
   // Measure time since last function call and update an array where the
   // position/index corresponds to time differences (in milliseconds) between
   // two successive playout callbacks, and the stored value is the number of
   // times a given time difference was found.
   int64_t now_time = rtc::TimeMillis();
   size_t diff_time = rtc::TimeDiff(now_time, last_playout_time_);
   // Truncate at 500ms to limit the size of the array.
   diff_time = std::min(kMaxDeltaTimeInMs, diff_time);
   last_playout_time_ = now_time;
   playout_diff_times_[diff_time]++;
 
-  UpdatePlayoutParameters();
-  // WebRTC can only provide audio in 10ms chunks, hence we fail if the native
-  // audio layer asks for something else.
-  RTC_CHECK_EQ(num_samples, play_samples_per_10ms_);
+  const size_t play_bytes_per_sample = [&] {
+    rtc::CritScope lock(&lock_);
+    return play_bytes_per_sample_;
+  }();
 
-  rtc::CritScope lock(&_critSectCb);
+  // The consumer can change the request size on the fly and we therefore
+  // resize the buffer accordingly. Also takes place at the first call to this
+  // method.
+  const size_t size_in_bytes = num_samples * play_bytes_per_sample;
+  if (play_buffer_.size() != size_in_bytes) {
+    play_buffer_.SetSize(size_in_bytes);
+    LOG(LS_INFO) << "Size of playout buffer: " << play_buffer_.size();
+  }
+
+  rtc::CritScope lock(&lock_cb_);
 
   // It is currently supported to start playout without a valid audio
   // transport object. Leads to warning and silence.
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
 
-  uint32_t res(0);
   int64_t elapsed_time_ms = -1;
   int64_t ntp_time_ms = -1;
   size_t num_samples_out(0);
-  res = audio_transport_cb_->NeedMorePlayData(
-      play_samples_per_10ms_, play_bytes_per_sample_, play_channels_,
-      play_sample_rate_, &play_buffer_[0], num_samples_out, &elapsed_time_ms,
-      &ntp_time_ms);
+  uint32_t res = audio_transport_cb_->NeedMorePlayData(
+      num_samples, play_bytes_per_sample_, play_channels_, play_sample_rate_,
+      play_buffer_.data(), num_samples_out, &elapsed_time_ms, &ntp_time_ms);
   if (res != 0) {
     LOG(LS_ERROR) << "NeedMorePlayData() failed";
   }
 
   // Update some stats but do it on the task queue to ensure that access of
   // members is serialized hence avoiding usage of locks.
   task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::UpdatePlayStats, this,
-                                 &play_buffer_[0], num_samples_out));
+                                 play_buffer_.data(), num_samples_out));
   return static_cast<int32_t>(num_samples_out);
 }
 
 int32_t AudioDeviceBuffer::GetPlayoutData(void* audio_buffer) {
-  rtc::CritScope lock(&_critSect);
-  memcpy(audio_buffer, &play_buffer_[0], play_bytes_per_10ms_);
-  return static_cast<int32_t>(play_samples_per_10ms_);
-}
-
-void AudioDeviceBuffer::UpdatePlayoutParameters() {
-  RTC_CHECK(play_bytes_per_sample_);
-  rtc::CritScope lock(&_critSect);
-  // Update the required buffer size given sample rate and number of channels.
-  play_samples_per_10ms_ = static_cast<size_t>(play_sample_rate_ * 10 / 1000);
-  play_bytes_per_10ms_ = play_bytes_per_sample_ * play_samples_per_10ms_;
-  RTC_DCHECK_LE(play_bytes_per_10ms_, kMaxBufferSizeBytes);
-}
-
-void AudioDeviceBuffer::UpdateRecordingParameters() {
-  RTC_CHECK(rec_bytes_per_sample_);
-  rtc::CritScope lock(&_critSect);
-  // Update the required buffer size given sample rate and number of channels.
-  rec_samples_per_10ms_ = static_cast<size_t>(rec_sample_rate_ * 10 / 1000);
-  rec_bytes_per_10ms_ = rec_bytes_per_sample_ * rec_samples_per_10ms_;
-  RTC_DCHECK_LE(rec_bytes_per_10ms_, kMaxBufferSizeBytes);
+  RTC_DCHECK_GT(play_buffer_.size(), 0u);
+  const size_t play_bytes_per_sample = [&] {
+    rtc::CritScope lock(&lock_);
+    return play_bytes_per_sample_;
+  }();
+  memcpy(audio_buffer, play_buffer_.data(), play_buffer_.size());
+  return static_cast<int32_t>(play_buffer_.size() / play_bytes_per_sample);
 }
 
 void AudioDeviceBuffer::StartTimer() {
   num_stat_reports_ = 0;
   last_log_stat_time_ = rtc::TimeMillis();
   task_queue_.PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
                               kTimerIntervalInMilliseconds);
 }
 
 void AudioDeviceBuffer::LogStats() {
@@ skipping 99 matching lines @@
     int16_t max_abs = WebRtcSpl_MaxAbsValueW16(
         static_cast<int16_t*>(const_cast<void*>(audio_buffer)),
         num_samples * play_channels_);
     if (max_abs > max_play_level_) {
       max_play_level_ = max_abs;
     }
   }
 }
 
 }  // namespace webrtc