Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector (Relanding)

media/audio/win/audio_low_latency_input_win.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 "media/audio/win/audio_low_latency_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
+#include "media/base/audio_bus.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 
 namespace media {
 namespace {
 
 // Returns true if |device| represents the default communication capture device.
 bool IsDefaultCommunicationDevice(IMMDeviceEnumerator* enumerator,
                                   IMMDevice* device) {
   ScopedComPtr<IMMDevice> communications;
   if (FAILED(enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
                                                  communications.Receive()))) {
     return false;
   }
 
   base::win::ScopedCoMem<WCHAR> communications_id, device_id;
   device->GetId(&device_id);
   communications->GetId(&communications_id);
   return lstrcmpW(communications_id, device_id) == 0;
 }
 
 }  // namespace
 
-WASAPIAudioInputStream::WASAPIAudioInputStream(
-    AudioManagerWin* manager,
-    const AudioParameters& params,
-    const std::string& device_id)
+WASAPIAudioInputStream::WASAPIAudioInputStream(AudioManagerWin* manager,
+                                               const AudioParameters& params,
+                                               const std::string& device_id)
     : manager_(manager),
       capture_thread_(NULL),
       opened_(false),
       started_(false),
       frame_size_(0),
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       effects_(params.effects()),
       device_id_(device_id),
       perf_count_to_100ns_units_(0.0),
       ms_to_frame_count_(0.0),
-      sink_(NULL) {
+      sink_(NULL),
+      audio_bus_(media::AudioBus::Create(params)) {
   DCHECK(manager_);
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the Avrt.dll";
 
   // Set up the desired capture format specified by the client.
   format_.nSamplesPerSec = params.sample_rate();
   format_.wFormatTag = WAVE_FORMAT_PCM;
   format_.wBitsPerSample = params.bits_per_sample();
@@ skipping 366 matching lines @@
 
           // Get a cached AGC volume level which is updated once every second
           // on the audio manager thread. Note that, |volume| is also updated
           // each time SetVolume() is called through IPC by the render-side AGC.
           GetAgcVolume(&volume);
 
           // Deliver captured data to the registered consumer using a packet
           // size which was specified at construction.
           uint32 delay_frames = static_cast<uint32>(audio_delay_frames + 0.5);
           while (buffer_frame_index >= packet_size_frames_) {
-            uint8* audio_data =
-                reinterpret_cast<uint8*>(capture_buffer.get());
+            // Copy data to audio bus to match the OnData interface.
+            uint8* audio_data = reinterpret_cast<uint8*>(capture_buffer.get());
+            audio_bus_->FromInterleaved(
+                audio_data, audio_bus_->frames(), format_.wBitsPerSample / 8);
 
             // Deliver data packet, delay estimation and volume level to
             // the user.
-            sink_->OnData(this,
-                          audio_data,
-                          packet_size_bytes_,
-                          delay_frames * frame_size_,
-                          volume);
+            sink_->OnData(
+                this, audio_bus_.get(), delay_frames * frame_size_, volume);
 
             // Store parts of the recorded data which can't be delivered
             // using the current packet size. The stored section will be used
             // either in the next while-loop iteration or in the next
             // capture event.
             memmove(&capture_buffer[0],
                     &capture_buffer[packet_size_bytes_],
                     (buffer_frame_index - packet_size_frames_) * frame_size_);
 
             buffer_frame_index -= packet_size_frames_;
@@ skipping 272 matching lines @@
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }
 
 }  // namespace media