Switch OnMoreData() to use AudioBus.

media/audio/linux/cras_output.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.
 //
 // The object has one error state: |state_| == kInError.  When |state_| ==
 // kInError, all public API functions will fail with an error (Start() will call
 // the OnError() function on the callback immediately), or no-op themselves with
 // the exception of Close().  Even if an error state has been entered, if Open()
 // has previously returned successfully, Close() must be called.
 
@@ skipping 54 matching lines @@
     : client_(NULL),
       stream_id_(0),
       samples_per_packet_(params.frames_per_buffer()),
       bytes_per_frame_(0),
       frame_rate_(params.sample_rate()),
       num_channels_(params.channels()),
       pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample())),
       state_(kCreated),
       volume_(1.0),
       manager_(manager),
-      source_callback_(NULL) {
+      source_callback_(NULL),
+      audio_bus_(AudioBus::Create(params)) {
   // We must have a manager.
   DCHECK(manager_);
 
   // Sanity check input values.
   if (params.sample_rate() <= 0) {
     LOG(WARNING) << "Unsupported audio frequency.";
     TransitionTo(kInError);
     return;
   }
 
@@ skipping 185 matching lines @@
                                 const timespec* sample_ts) {
   timespec latency_ts  = {0, 0};
 
   // Determine latency and pass that on to the source.
   cras_client_calc_playback_latency(sample_ts, &latency_ts);
   uint32 latency_usec = (latency_ts.tv_sec * 1000000) +
       latency_ts.tv_nsec / 1000;
 
   uint32 frames_latency = latency_usec * frame_rate_ / 1000000;
   uint32 bytes_latency = frames_latency * bytes_per_frame_;
-  uint32 rendered = source_callback_->OnMoreData(
-      buffer, frames * bytes_per_frame_, AudioBuffersState(0, bytes_latency));
-  return rendered / bytes_per_frame_;
+  DCHECK_EQ(frames, static_cast<size_t>(audio_bus_->frames()));
+  int frames_filled = source_callback_->OnMoreData(
+      audio_bus_.get(), AudioBuffersState(0, bytes_latency));
+  // Note: If this ever changes to output raw float the data must be clipped and
+  // sanitized since it may come from an untrusted source such as NaCl.
+  audio_bus_->ToInterleaved(
+      frames_filled, bytes_per_frame_ / (frames * num_channels_), buffer);
+  return frames_filled;
 }
 
 void CrasOutputStream::NotifyStreamError(int err) {
   // This will remove the stream from the client.
   if (state_ == kIsClosed || state_ == kInError)
     return;  // Don't care about error if we aren't using it.
   TransitionTo(kInError);
   if (source_callback_)
     source_callback_->OnError(this, err);
 }
@@ skipping 32 matching lines @@
     state_ = to;
   }
   return state_;
 }
 
 CrasOutputStream::InternalState CrasOutputStream::state() {
   return state_;
 }
 
 }  // namespace media