AudioDeviceBuffer now uses 16-bit buffers

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.
  */
 
 #include <algorithm>
 
 #include "webrtc/modules/audio_device/audio_device_buffer.h"
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_device/audio_device_config.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
-#include "webrtc/base/platform_thread.h"
-
 namespace webrtc {
 
 static const char kTimerQueueName[] = "AudioDeviceBufferTimer";
 
 // Time between two sucessive calls to LogStats().
 static const size_t kTimerIntervalInSeconds = 10;
 static const size_t kTimerIntervalInMilliseconds =
     kTimerIntervalInSeconds * rtc::kNumMillisecsPerSec;
 // Min time required to qualify an audio session as a "call". If playout or
 // recording has been active for less than this time we will not store any
@@ skipping 257 matching lines @@
   LOG(LS_WARNING) << "Not implemented";
   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) {
+                                             size_t samples_per_channel) {
   RTC_DCHECK_RUN_ON(&recording_thread_checker_);
   // Copy the complete input buffer to the local buffer.
-  const size_t size_in_bytes = num_samples * rec_channels_ * sizeof(int16_t);
   const size_t old_size = rec_buffer_.size();
-  rec_buffer_.SetData(static_cast<const uint8_t*>(audio_buffer), size_in_bytes);
+  rec_buffer_.SetData(static_cast<const int16_t*>(audio_buffer),
+                      rec_channels_ * samples_per_channel);
   // 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();
   }
   // Derive a new level value twice per second and check if it is non-zero.
   int16_t max_abs = 0;
   RTC_DCHECK_LT(rec_stat_count_, 50);
   if (++rec_stat_count_ >= 50) {
-    const size_t size = num_samples * rec_channels_;
     // Returns the largest absolute value in a signed 16-bit vector.
-    max_abs = WebRtcSpl_MaxAbsValueW16(
-        reinterpret_cast<const int16_t*>(rec_buffer_.data()), size);
+    max_abs = WebRtcSpl_MaxAbsValueW16(rec_buffer_.data(), rec_buffer_.size());
     rec_stat_count_ = 0;
     // Set |only_silence_recorded_| to false as soon as at least one detection
     // of a non-zero audio packet is found. It can only be restored to true
     // again by restarting the call.
     if (max_abs > 0) {
       only_silence_recorded_ = false;
     }
   }
   // Update some stats but do it on the task queue to ensure that the members
   // are modified and read on the same thread. Note that |max_abs| will be
   // zero in most calls and then have no effect of the stats. It is only updated
   // approximately two times per second and can then change the stats.
-  task_queue_.PostTask(
-      [this, max_abs, num_samples] { UpdateRecStats(max_abs, num_samples); });
+  task_queue_.PostTask([this, max_abs, samples_per_channel] {
+    UpdateRecStats(max_abs, samples_per_channel);
+  });
   return 0;
 }
 
 int32_t AudioDeviceBuffer::DeliverRecordedData() {
   RTC_DCHECK_RUN_ON(&recording_thread_checker_);
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
-  const size_t rec_bytes_per_sample = rec_channels_ * sizeof(int16_t);
+  const size_t frame_size_in_bytes = rec_channels_ * sizeof(int16_t);

[kwiberg-webrtc, 2016/11/08 14:54:40]

Good. Or "bytes_per_frame", which means the same thing but is slightly shorter.

[henrika_webrtc, 2016/11/08 15:31:02]

Done.

   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);
+      rec_buffer_.data(), rec_buffer_.size(), frame_size_in_bytes,
+      rec_channels_, rec_sample_rate_, total_delay_ms, clock_drift_,
+      current_mic_level_, typing_status_, new_mic_level);
   if (res != -1) {
     new_mic_level_ = new_mic_level;
   } else {
     LOG(LS_ERROR) << "RecordedDataIsAvailable() failed";
   }
   return 0;
 }
 
-int32_t AudioDeviceBuffer::RequestPlayoutData(size_t num_samples) {
+int32_t AudioDeviceBuffer::RequestPlayoutData(size_t samples_per_channel) {
   RTC_DCHECK_RUN_ON(&playout_thread_checker_);
-  // The consumer can change the request size on the fly and we therefore
+  // The consumer can change the requested size on the fly and we therefore
   // resize the buffer accordingly. Also takes place at the first call to this
   // method.
-  const size_t play_bytes_per_sample = play_channels_ * sizeof(int16_t);
-  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);
+  const size_t total_samples = play_channels_ * samples_per_channel;
+  if (play_buffer_.size() != total_samples) {
+    play_buffer_.SetSize(total_samples);
     LOG(LS_INFO) << "Size of playout buffer: " << play_buffer_.size();
   }
 
   size_t num_samples_out(0);
   // 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;
   }
 
   // Retrieve new 16-bit PCM audio data using the audio transport instance.
   int64_t elapsed_time_ms = -1;
   int64_t ntp_time_ms = -1;
+  const size_t frame_size_in_bytes = play_channels_ * sizeof(int16_t);
   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);
+      samples_per_channel, frame_size_in_bytes, 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";
   }
 
   // Derive a new level value twice per second.
   int16_t max_abs = 0;
   RTC_DCHECK_LT(play_stat_count_, 50);
   if (++play_stat_count_ >= 50) {
-    const size_t size = num_samples * play_channels_;
     // Returns the largest absolute value in a signed 16-bit vector.
-    max_abs = WebRtcSpl_MaxAbsValueW16(
-        reinterpret_cast<const int16_t*>(play_buffer_.data()), size);
+    max_abs =
+        WebRtcSpl_MaxAbsValueW16(play_buffer_.data(), play_buffer_.size());
     play_stat_count_ = 0;
   }
   // Update some stats but do it on the task queue to ensure that the members
   // are modified and read on the same thread. Note that |max_abs| will be
   // zero in most calls and then have no effect of the stats. It is only updated
   // approximately two times per second and can then change the stats.
   task_queue_.PostTask([this, max_abs, num_samples_out] {
     UpdatePlayStats(max_abs, num_samples_out);
   });
   return static_cast<int32_t>(num_samples_out);
 }
 
 int32_t AudioDeviceBuffer::GetPlayoutData(void* audio_buffer) {
   RTC_DCHECK_RUN_ON(&playout_thread_checker_);
   RTC_DCHECK_GT(play_buffer_.size(), 0u);
   const size_t play_bytes_per_sample = play_channels_ * sizeof(int16_t);
-  memcpy(audio_buffer, play_buffer_.data(), play_buffer_.size());
-  return static_cast<int32_t>(play_buffer_.size() / play_bytes_per_sample);
+  memcpy(audio_buffer, play_buffer_.data(),
+         play_buffer_.size() * play_bytes_per_sample);
+  return static_cast<int32_t>(play_buffer_.size());
 }
 
 void AudioDeviceBuffer::StartPeriodicLogging() {
   task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this,
                                  AudioDeviceBuffer::LOG_START));
 }
 
 void AudioDeviceBuffer::StopPeriodicLogging() {
   task_queue_.PostTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this,
                                  AudioDeviceBuffer::LOG_STOP));
@@ skipping 69 matching lines @@
 
 void AudioDeviceBuffer::ResetPlayStats() {
   RTC_DCHECK_RUN_ON(&task_queue_);
   play_callbacks_ = 0;
   last_play_callbacks_ = 0;
   play_samples_ = 0;
   last_play_samples_ = 0;
   max_play_level_ = 0;
 }
 
-void AudioDeviceBuffer::UpdateRecStats(int16_t max_abs, size_t num_samples) {
+void AudioDeviceBuffer::UpdateRecStats(int16_t max_abs,
+                                       size_t samples_per_channel) {
   RTC_DCHECK_RUN_ON(&task_queue_);
   ++rec_callbacks_;
-  rec_samples_ += num_samples;
+  rec_samples_ += samples_per_channel;
   if (max_abs > max_rec_level_) {
     max_rec_level_ = max_abs;
   }
 }
 
-void AudioDeviceBuffer::UpdatePlayStats(int16_t max_abs, size_t num_samples) {
+void AudioDeviceBuffer::UpdatePlayStats(int16_t max_abs,
+                                        size_t samples_per_channel) {
   RTC_DCHECK_RUN_ON(&task_queue_);
   ++play_callbacks_;
-  play_samples_ += num_samples;
+  play_samples_ += samples_per_channel;
   if (max_abs > max_play_level_) {
     max_play_level_ = max_abs;
   }
 }
 
 }  // namespace webrtc