Merge AudioRendererImpl and AudioRendererBase; add NullAudioSink

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_hardware.h"
@@ skipping 52 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::Release() {
   int ret = base::subtle::Barrier_AtomicIncrement(&ref_count_, -1);
   if (ret == 0) {
     delete this;
   }
   return ret;
 }
 
-size_t WebRtcAudioDeviceImpl::Render(
+int WebRtcAudioDeviceImpl::Render(
     const std::vector<float*>& audio_data,
-    size_t number_of_frames,
-    size_t audio_delay_milliseconds) {
+    int number_of_frames,
+    int audio_delay_milliseconds) {
   DCHECK_LE(number_of_frames, output_buffer_size());
 
   {
     base::AutoLock auto_lock(lock_);
     // Store the reported audio delay locally.
     output_delay_ms_ = audio_delay_milliseconds;
   }
 
   const int channels = audio_data.size();
   DCHECK_LE(channels, output_channels());
 
   int samples_per_sec = output_sample_rate();
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
-  uint32_t samples_per_10_msec = (samples_per_sec / 100);
+  int samples_per_10_msec = (samples_per_sec / 100);
   const int bytes_per_10_msec =
       channels * samples_per_10_msec * bytes_per_sample_;
 
   uint32_t num_audio_samples = 0;
-  size_t accumulated_audio_samples = 0;
+  int accumulated_audio_samples = 0;
 
   char* audio_byte_buffer = reinterpret_cast<char*>(output_buffer_.get());
 
   // Get audio samples in blocks of 10 milliseconds from the registered
   // webrtc::AudioTransport source. Keep reading until our internal buffer
   // is full.
   while (accumulated_audio_samples < number_of_frames) {
     // Get 10ms and append output to temporary byte buffer.
     audio_transport_callback_->NeedMorePlayData(samples_per_10_msec,
                                                 bytes_per_sample_,
@@ skipping 20 matching lines @@
 }
 
 void WebRtcAudioDeviceImpl::OnRenderError() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // TODO(henrika): Implement error handling.
   LOG(ERROR) << "OnRenderError()";
 }
 
 void WebRtcAudioDeviceImpl::Capture(
     const std::vector<float*>& audio_data,
-    size_t number_of_frames,
-    size_t audio_delay_milliseconds) {
+    int number_of_frames,
+    int audio_delay_milliseconds) {
   DCHECK_LE(number_of_frames, input_buffer_size());
 
   int output_delay_ms = 0;
   {
     base::AutoLock auto_lock(lock_);
     // Store the reported audio delay locally.
     input_delay_ms_ = audio_delay_milliseconds;
     output_delay_ms = output_delay_ms_;
   }
 
   const int channels = audio_data.size();
   DCHECK_LE(channels, input_channels());
   uint32_t new_mic_level = 0;
 
   // Interleave, scale, and clip input to int16 and store result in
   // a local byte buffer.
   media::InterleaveFloatToInt16(audio_data,
                                 input_buffer_.get(),
                                 number_of_frames);
 
   int samples_per_sec = input_sample_rate();
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
   const int samples_per_10_msec = (samples_per_sec / 100);
   const int bytes_per_10_msec =
       channels * samples_per_10_msec * bytes_per_sample_;
-  size_t accumulated_audio_samples = 0;
+  int accumulated_audio_samples = 0;
 
   char* audio_byte_buffer = reinterpret_cast<char*>(input_buffer_.get());
 
   // Write audio samples in blocks of 10 milliseconds to the registered
   // webrtc::AudioTransport sink. Keep writing until our internal byte
   // buffer is empty.
   while (accumulated_audio_samples < number_of_frames) {
     // Deliver 10ms of recorded PCM audio.
     // TODO(henrika): add support for analog AGC?
     audio_transport_callback_->RecordedDataIsAvailable(
@@ skipping 146 matching lines @@
   }
 
   // Ask the browser for the default number of audio input channels.
   // This request is based on a synchronous IPC message.
   ChannelLayout input_channel_layout =
       audio_hardware::GetInputChannelLayout();
   DVLOG(1) << "Audio input hardware channels: " << input_channel_layout;
 
   ChannelLayout out_channel_layout = CHANNEL_LAYOUT_MONO;
   AudioParameters::Format in_format = AudioParameters::AUDIO_PCM_LINEAR;
-  size_t in_buffer_size = 0;
-  size_t out_buffer_size = 0;
+  int in_buffer_size = 0;
+  int out_buffer_size = 0;
 
   // TODO(henrika): factor out all platform specific parts in separate
   // functions. Code is a bit messy right now.
 
 // Windows
 #if defined(OS_WIN)
   // Always use stereo rendering on Windows.
   out_channel_layout = CHANNEL_LAYOUT_STEREO;
 
   DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
@@ skipping 642 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }