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

media/audio/pulse/pulse_input.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/pulse/pulse_input.h"
 
 #include <pulse/pulseaudio.h>
 
 #include "base/logging.h"
 #include "media/audio/pulse/audio_manager_pulse.h"
@@ skipping 14 matching lines @@
       callback_(NULL),
       device_name_(device_name),
       params_(params),
       channels_(0),
       volume_(0.0),
       stream_started_(false),
       pa_mainloop_(mainloop),
       pa_context_(context),
       handle_(NULL),
       context_state_changed_(false) {
+  DVLOG(1) << __FUNCTION__;
   DCHECK(mainloop);
   DCHECK(context);
+  CHECK(params_.IsValid());
+  audio_bus_ = AudioBus::Create(params_);
 }
 
 PulseAudioInputStream::~PulseAudioInputStream() {
+  DVLOG(1) << __FUNCTION__;
   // All internal structures should already have been freed in Close(),
   // which calls AudioManagerPulse::Release which deletes this object.
   DCHECK(!handle_);
 }
 
 bool PulseAudioInputStream::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   AutoPulseLock auto_lock(pa_mainloop_);
   if (!pulse::CreateInputStream(pa_mainloop_, pa_context_, &handle_, params_,
                                 device_name_, &StreamNotifyCallback, this)) {
     return false;
   }
 
   DCHECK(handle_);
 
+  DVLOG(1) << "frames_per_buffer: " << params_.frames_per_buffer();
   buffer_.reset(new media::SeekableBuffer(0, 2 * params_.GetBytesPerBuffer()));
   audio_data_buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
   return true;
 }
 
 void PulseAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(callback);
   DCHECK(handle_);
 
@@ skipping 200 matching lines @@
 
     buffer_->Append(reinterpret_cast<const uint8*>(data), length);
 
     // Checks if we still have data.
     pa_stream_drop(handle_);
   } while (pa_stream_readable_size(handle_) > 0);
 
   int packet_size = params_.GetBytesPerBuffer();
   while (buffer_->forward_bytes() >= packet_size) {
     buffer_->Read(audio_data_buffer_.get(), packet_size);
-    callback_->OnData(this, audio_data_buffer_.get(), packet_size,
-                      hardware_delay, normalized_volume);
+    audio_bus_->FromInterleaved(audio_data_buffer_.get(),
+                                audio_bus_->frames(),
+                                params_.bits_per_sample() / 8);
+    callback_->OnData(
+        this, audio_bus_.get(), hardware_delay, normalized_volume);
 
     if (buffer_->forward_bytes() < packet_size)
       break;
 
     // TODO(xians): Remove once PPAPI is using circular buffers.
     DVLOG(1) << "OnData is being called consecutively, sleep 5ms to "
              << "wait until render consumes the data";
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(5));
   }
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
 }  // namespace media