Switch OnMoreData() to use AudioBus.

media/audio/linux/alsa_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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 73 matching lines @@
 //
 // This function makes a best guess at the specific > 2 channel device name
 // based on the number of channels requested.  NULL is returned if no device
 // can be found to match the channel numbers.  In this case, using
 // kDefaultDevice is probably the best bet.
 //
 // A five channel source is assumed to be surround50 instead of surround41
 // (which is also 5 channels).
 //
 // TODO(ajwong): The source data should have enough info to tell us if we want
-// surround41 versus surround51, etc., instead of needing us to guess base don
+// surround41 versus surround51, etc., instead of needing us to guess based on
 // channel number.  Fix API to pass that data down.
 static const char* GuessSpecificDeviceName(uint32 channels) {
   switch (channels) {
     case 8:
       return "surround71";
 
     case 7:
       return "surround70";
 
     case 6:
@@ skipping 63 matching lines @@
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       message_loop_(MessageLoop::current()),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       state_(kCreated),
       volume_(1.0f),
-      source_callback_(NULL) {
+      source_callback_(NULL),
+      audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK_EQ(audio_bus_->frames() * bytes_per_frame_, packet_size_);
 
   // Sanity check input values.
   if (params.sample_rate() > kAlsaMaxSampleRate ||
       params.sample_rate() <= 0) {
     LOG(WARNING) << "Unsupported audio frequency.";
     TransitionTo(kInError);
   }
 
   if (AudioParameters::AUDIO_PCM_LINEAR != params.format() &&
       AudioParameters::AUDIO_PCM_LOW_LATENCY != params.format()) {
@@ skipping 179 matching lines @@
     // Before making a request to source for data we need to determine the
     // delay (in bytes) for the requested data to be played.
 
     uint32 buffer_delay = buffer_->forward_bytes() * bytes_per_frame_ /
         bytes_per_output_frame_;
 
     uint32 hardware_delay = GetCurrentDelay() * bytes_per_frame_;
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
-    int packet_size = RunDataCallback(packet->GetWritableData(),
-                                      packet->GetBufferSize(),
-                                      AudioBuffersState(buffer_delay,
-                                                        hardware_delay));
-    CHECK_LE(packet_size, packet->GetBufferSize());
+    int frames_filled = RunDataCallback(
+        audio_bus_.get(), AudioBuffersState(buffer_delay, hardware_delay));
+    size_t packet_size = frames_filled * bytes_per_frame_;
+    DCHECK_LE(packet_size, packet_size_);
+    audio_bus_->ToInterleaved(
+        frames_filled, bytes_per_sample_, packet->GetWritableData());
 
     // Reset the |last_fill_time| to avoid back to back RunDataCallback().
     last_fill_time_ = base::Time::Now();
 
-    // This should not happen, but in case it does, drop any trailing bytes
-    // that aren't large enough to make a frame.  Without this, packet writing
-    // may stall because the last few bytes in the packet may never get used by
-    // WritePacket.
-    DCHECK_EQ(0u, packet_size % bytes_per_frame_);
-    packet_size = (packet_size / bytes_per_frame_) * bytes_per_frame_;
-
+    // TODO(dalecurtis): Channel downmixing, upmixing, should be done in mixer;
+    // volume adjust should use SSE optimized vector_fmul() prior to interleave.
     if (should_downmix_) {
       if (media::FoldChannels(packet->GetWritableData(),
                               packet_size,
                               channels_,
                               bytes_per_sample_,
                               volume_)) {
         // Adjust packet size for downmix.
         packet_size = packet_size / bytes_per_frame_ * bytes_per_output_frame_;
       } else {
         LOG(ERROR) << "Folding failed";
@@ skipping 372 matching lines @@
 }
 
 AlsaPcmOutputStream::InternalState AlsaPcmOutputStream::state() {
   return state_;
 }
 
 bool AlsaPcmOutputStream::IsOnAudioThread() const {
   return message_loop_ && message_loop_ == MessageLoop::current();
 }
 
-uint32 AlsaPcmOutputStream::RunDataCallback(uint8* dest,
-                                            uint32 max_size,
-                                            AudioBuffersState buffers_state) {
+int AlsaPcmOutputStream::RunDataCallback(AudioBus* audio_bus,
+                                         AudioBuffersState buffers_state) {
   TRACE_EVENT0("audio", "AlsaPcmOutputStream::RunDataCallback");
 
   if (source_callback_)
-    return source_callback_->OnMoreData(dest, max_size, buffers_state);
+    return source_callback_->OnMoreData(audio_bus, buffers_state);
 
   return 0;
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this, code);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(IsOnAudioThread());
   source_callback_ = callback;
 }
 
 }  // namespace media