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

media/audio/android/opensles_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/android/opensles_input.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "media/audio/android/audio_manager_android.h"
+#include "media/base/audio_bus.h"
 
 #define LOG_ON_FAILURE_AND_RETURN(op, ...)      \
   do {                                          \
     SLresult err = (op);                        \
     if (err != SL_RESULT_SUCCESS) {             \
       DLOG(ERROR) << #op << " failed: " << err; \
       return __VA_ARGS__;                       \
     }                                           \
   } while (0)
 
 namespace media {
 
 OpenSLESInputStream::OpenSLESInputStream(AudioManagerAndroid* audio_manager,
                                          const AudioParameters& params)
     : audio_manager_(audio_manager),
       callback_(NULL),
       recorder_(NULL),
       simple_buffer_queue_(NULL),
       active_buffer_index_(0),
       buffer_size_bytes_(0),
-      started_(false) {
+      started_(false),
+      audio_bus_(media::AudioBus::Create(params)) {
   DVLOG(2) << __PRETTY_FUNCTION__;
   format_.formatType = SL_DATAFORMAT_PCM;
   format_.numChannels = static_cast<SLuint32>(params.channels());
   // Provides sampling rate in milliHertz to OpenSLES.
   format_.samplesPerSec = static_cast<SLuint32>(params.sample_rate() * 1000);
   format_.bitsPerSample = params.bits_per_sample();
   format_.containerSize = params.bits_per_sample();
   format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
   if (format_.numChannels == 1)
     format_.channelMask = SL_SPEAKER_FRONT_CENTER;
@@ skipping 247 matching lines @@
   stream->ReadBufferQueue();
 }
 
 void OpenSLESInputStream::ReadBufferQueue() {
   base::AutoLock lock(lock_);
   if (!started_)
     return;
 
   TRACE_EVENT0("audio", "OpenSLESOutputStream::ReadBufferQueue");
 
+  // Convert from interleaved format to deinterleaved audio bus format.
+  audio_bus_->FromInterleaved(audio_data_[active_buffer_index_],
+                              audio_bus_->frames(),
+                              format_.bitsPerSample / 8);
+
   // TODO(henrika): Investigate if it is possible to get an accurate
   // delay estimation.
-  callback_->OnData(this,
-                    audio_data_[active_buffer_index_],
-                    buffer_size_bytes_,
-                    buffer_size_bytes_,
-                    0.0);
+  callback_->OnData(this, audio_bus_.get(), buffer_size_bytes_, 0.0);
 
   // Done with this buffer. Send it to device for recording.
   SLresult err =
       (*simple_buffer_queue_)->Enqueue(simple_buffer_queue_,
                                        audio_data_[active_buffer_index_],
                                        buffer_size_bytes_);
   if (SL_RESULT_SUCCESS != err)
     HandleError(err);
 
   active_buffer_index_ = (active_buffer_index_ + 1) % kMaxNumOfBuffersInQueue;
@@ skipping 17 matching lines @@
   }
 }
 
 void OpenSLESInputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Input error " << error;
   if (callback_)
     callback_->OnError(this);
 }
 
 }  // namespace media