Upgrade AudioBus to support wrapping, interleaving.

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/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/render_thread_impl.h"
+#include "media/audio/audio_parameters.h"
 #include "media/audio/audio_util.h"
-#include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 
 using content::AudioDeviceFactory;
 using media::AudioParameters;
 
 static const int64 kMillisecondsBetweenProcessCalls = 5000;
 static const double kMaxVolumeLevel = 255.0;
 
 // Supported hardware sample rates for input and output sides.
 #if defined(OS_WIN) || defined(OS_MACOSX)
@@ skipping 185 matching lines @@
                                                 channels,
                                                 samples_per_sec,
                                                 audio_byte_buffer,
                                                 num_audio_samples);
     accumulated_audio_samples += num_audio_samples;
     audio_byte_buffer += bytes_per_10_msec;
   }
 
   // Deinterleave each channel and convert to 32-bit floating-point
   // with nominal range -1.0 -> +1.0 to match the callback format.
-  for (int channel_index = 0; channel_index < channels; ++channel_index) {
-    media::DeinterleaveAudioChannel(
-        output_buffer_.get(),
-        audio_bus->channel(channel_index),
-        channels,
-        channel_index,
-        bytes_per_sample_,
-        audio_bus->frames());
-  }
+  audio_bus->FromInterleaved(output_buffer_.get(), audio_bus->frames(),
+                             bytes_per_sample_);
   return audio_bus->frames();
 }
 
 void WebRtcAudioDeviceImpl::OnRenderError() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // TODO(henrika): Implement error handling.
   LOG(ERROR) << "OnRenderError()";
 }
 
 void WebRtcAudioDeviceImpl::Capture(media::AudioBus* audio_bus,
@@ skipping 18 matching lines @@
     input_delay_ms_ = audio_delay_milliseconds;
     output_delay_ms = output_delay_ms_;
   }
 
   const int channels = audio_bus->channels();
   DCHECK_LE(channels, input_channels());
   uint32_t new_mic_level = 0;
 
   // Interleave, scale, and clip input to int and store result in
   // a local byte buffer.
-  media::InterleaveFloatToInt(audio_bus,
-                              input_buffer_.get(),
-                              audio_bus->frames(),
-                              input_audio_parameters_.bits_per_sample() / 8);
+  audio_bus->ToInterleaved(audio_bus->frames(),
+                           input_audio_parameters_.bits_per_sample() / 8,
+                           input_buffer_.get());
 
   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_;
   int accumulated_audio_samples = 0;
@@ skipping 884 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }