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

media/audio/audio_input_controller.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/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
@@ skipping 184 matching lines @@
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CreateTime");
 
 #if defined(AUDIO_POWER_MONITORING)
   // Create the audio (power) level meter given the provided audio parameters.
   // An AudioBus is also needed to wrap the raw data buffer from the native
   // layer to match AudioPowerMonitor::Scan().
   // TODO(henrika): Remove use of extra AudioBus. See http://crbug.com/375155.
   audio_level_.reset(new media::AudioPowerMonitor(
       params.sample_rate(),
       TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMilliseconds)));
-  audio_bus_ = AudioBus::Create(params);
   audio_params_ = params;
 #endif
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, assume all
   // platform audio input requires the |no_data_timer_| be used to auto-detect
   // errors.  In reality, probably only Windows needs to be treated as
   // unreliable here.
   DoCreateForStream(audio_manager->MakeAudioInputStream(params, device_id),
                     true);
 }
@@ skipping 160 matching lines @@
 
   // Restart the timer to ensure that we check the flag again in
   // |kTimerResetIntervalSeconds|.
   no_data_timer_->Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
       base::Bind(&AudioInputController::DoCheckForNoData,
       base::Unretained(this)));
 }
 
 void AudioInputController::OnData(AudioInputStream* stream,
-                                  const uint8* data,
-                                  uint32 size,
+                                  const AudioBus* source,
                                   uint32 hardware_delay_bytes,
                                   double volume) {
   // Mark data as active to ensure that the periodic calls to
   // DoCheckForNoData() does not report an error to the event handler.
   SetDataIsActive(true);
 
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != RECORDING)
       return;
   }
 
   bool key_pressed = false;
   if (user_input_monitor_) {
     size_t current_count = user_input_monitor_->GetKeyPressCount();
     key_pressed = current_count != prev_key_down_count_;
     prev_key_down_count_ = current_count;
     DVLOG_IF(6, key_pressed) << "Detected keypress.";
   }
 
   // Use SharedMemory and SyncSocket if the client has created a SyncWriter.
   // Used by all low-latency clients except WebSpeech.
   if (SharedMemoryAndSyncSocketMode()) {
-    sync_writer_->Write(data, size, volume, key_pressed);
+    sync_writer_->Write(source, volume, key_pressed);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
 
 #if defined(AUDIO_POWER_MONITORING)
     // Only do power-level measurements if an AudioPowerMonitor object has
     // been created. Done in DoCreate() but not DoCreateForStream(), hence
     // logging will mainly be done for WebRTC and WebSpeech clients.
     if (!audio_level_)
       return;
 
     // Perform periodic audio (power) level measurements.
     if ((base::TimeTicks::Now() - last_audio_level_log_time_).InSeconds() >
         kPowerMonitorLogIntervalSeconds) {
       // Wrap data into an AudioBus to match AudioPowerMonitor::Scan.
       // TODO(henrika): remove this section when capture side uses AudioBus.
       // See http://crbug.com/375155 for details.
-      audio_bus_->FromInterleaved(
-          data, audio_bus_->frames(), audio_params_.bits_per_sample() / 8);
-      audio_level_->Scan(*audio_bus_, audio_bus_->frames());
+      audio_level_->Scan(*source, source->frames());
 
       // Get current average power level and add it to the log.
       // Possible range is given by [-inf, 0] dBFS.
       std::pair<float, bool> result = audio_level_->ReadCurrentPowerAndClip();
 
       // Use event handler on the audio thread to relay a message to the ARIH
       // in content which does the actual logging on the IO thread.
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &AudioInputController::DoLogAudioLevel, this, result.first));
 
       last_audio_level_log_time_ = base::TimeTicks::Now();
 
       // Reset the average power level (since we don't log continuously).
       audio_level_->Reset();
     }
 #endif
 
     return;
   }
 
+  // TODO(henrika): fix WebSpeech as well....
+
+  /*
+
   // TODO(henrika): Investigate if we can avoid the extra copy here.
   // (see http://crbug.com/249316 for details). AFAIK, this scope is only
   // active for WebSpeech clients.
   scoped_ptr<uint8[]> audio_data(new uint8[size]);
   memcpy(audio_data.get(), data, size);
 
   // Ownership of the audio buffer will be with the callback until it is run,
   // when ownership is passed to the callback function.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoOnData, this, base::Passed(&audio_data), size));
+  */
 }
 
 void AudioInputController::DoOnData(scoped_ptr<uint8[]> data, uint32 size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (handler_)
     handler_->OnData(this, data.get(), size);
 }
 
 void AudioInputController::DoLogAudioLevel(float level_dbfs) {
 #if defined(AUDIO_POWER_MONITORING)
@@ skipping 33 matching lines @@
 
 void AudioInputController::SetDataIsActive(bool enabled) {
   base::subtle::Release_Store(&data_is_active_, enabled);
 }
 
 bool AudioInputController::GetDataIsActive() {
   return (base::subtle::Acquire_Load(&data_is_active_) != false);
 }
 
 }  // namespace media