Avoids crash at device switch on iOS

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 43 matching lines @@
       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) {
   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 154 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) {
-  AllocateRecordingBufferIfNeeded();
-  RTC_CHECK(rec_buffer_);
+  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 {
@@ skipping 12 matching lines @@
   }
 
   // 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, num_samples));
   return 0;
 }
 
 int32_t AudioDeviceBuffer::DeliverRecordedData() {
-  RTC_CHECK(rec_buffer_);
   RTC_DCHECK(audio_transport_cb_);
   rtc::CritScope lock(&_critSectCb);
 
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
 
   int32_t res(0);
   uint32_t newMicLevel(0);
@@ skipping 16 matching lines @@
   // 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]++;
 
-  AllocatePlayoutBufferIfNeeded();
-  RTC_CHECK(play_buffer_);
+  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_);
 
   rtc::CritScope lock(&_critSectCb);
 
   // 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";
@@ skipping 18 matching lines @@
       rtc::Bind(&AudioDeviceBuffer::UpdatePlayStats, this, 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::AllocatePlayoutBufferIfNeeded() {
+void AudioDeviceBuffer::UpdatePlayoutParameters() {
   RTC_CHECK(play_bytes_per_sample_);
-  if (play_buffer_)
-    return;
-  LOG(INFO) << __FUNCTION__;
   rtc::CritScope lock(&_critSect);
-  // Derive the required buffer size given sample rate and number of channels.
+  // 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_;
-  LOG(INFO) << "playout samples per 10ms: " << play_samples_per_10ms_;
-  LOG(INFO) << "playout bytes per 10ms: " << play_bytes_per_10ms_;
-  // Allocate memory for the playout audio buffer. It will always contain audio
-  // samples corresponding to 10ms of audio to be played out.
-  play_buffer_.reset(new int8_t[play_bytes_per_10ms_]);
+  RTC_DCHECK_LE(play_bytes_per_10ms_, kMaxBufferSizeBytes);

[Henrik Grunell WebRTC, 2016/09/09 10:19:29]

Nit: I think it should even be a CHECK (not DCHECK), since if it's not fulfilled
we'll read oob. Same below. We never checked this before though, so feel free to
change now or when the follow-up for dynamic change of buffer size is written.

 }
 
-void AudioDeviceBuffer::AllocateRecordingBufferIfNeeded() {
+void AudioDeviceBuffer::UpdateRecordingParameters() {
   RTC_CHECK(rec_bytes_per_sample_);
-  if (rec_buffer_)
-    return;
-  LOG(INFO) << __FUNCTION__;
   rtc::CritScope lock(&_critSect);
-  // Derive the required buffer size given sample rate and number of channels.
+  // 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_;
-  LOG(INFO) << "recorded samples per 10ms: " << rec_samples_per_10ms_;
-  LOG(INFO) << "recorded bytes per 10ms: " << rec_bytes_per_10ms_;
-  // Allocate memory for the recording audio buffer. It will always contain
-  // audio samples corresponding to 10ms of audio.
-  rec_buffer_.reset(new int8_t[rec_bytes_per_10ms_]);
+  RTC_DCHECK_LE(rec_bytes_per_10ms_, kMaxBufferSizeBytes);
 }
 
 void AudioDeviceBuffer::StartTimer() {
   last_log_stat_time_ = rtc::TimeMillis();
   task_queue_.PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this),
                               kTimerIntervalInMilliseconds);
 }
 
 void AudioDeviceBuffer::LogStats() {
   RTC_DCHECK(task_queue_.IsCurrent());
@@ skipping 46 matching lines @@
   rec_samples_ += num_samples;
 }
 
 void AudioDeviceBuffer::UpdatePlayStats(size_t num_samples) {
   RTC_DCHECK(task_queue_.IsCurrent());
   ++play_callbacks_;
   play_samples_ += num_samples;
 }
 
 }  // namespace webrtc