Switch OnMoreData() to use AudioBus.

media/audio/audio_output_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_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "media/audio/shared_memory_util.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::WaitableEvent;
 
 namespace media {
 
 // Polling-related constants.
 const int AudioOutputController::kPollNumAttempts = 3;
 const int AudioOutputController::kPollPauseInMilliseconds = 3;
 
 AudioOutputController::AudioOutputController(EventHandler* handler,
-                                             SyncReader* sync_reader)
+                                             SyncReader* sync_reader,
+                                             const AudioParameters& params)
     : handler_(handler),
       stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
       message_loop_(NULL),
       number_polling_attempts_left_(0),
+      params_(params),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)) {
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
   DCHECK(message_loop_);
 
   if (!message_loop_.get() || message_loop_->BelongsToCurrentThread()) {
     DoStopCloseAndClearStream(NULL);
   } else {
@@ skipping 16 matching lines @@
     const AudioParameters& params,
     SyncReader* sync_reader) {
   DCHECK(audio_manager);
   DCHECK(sync_reader);
 
   if (!params.IsValid() || !audio_manager)
     return NULL;
 
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      event_handler, sync_reader));
+      event_handler, sync_reader, params));
 
   controller->message_loop_ = audio_manager->GetMessageLoop();
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoCreate, controller,
-      base::Unretained(audio_manager), params));
+      base::Unretained(audio_manager)));
   return controller;
 }
 
 void AudioOutputController::Play() {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoPlay, this));
 }
 
 void AudioOutputController::Pause() {
@@ skipping 14 matching lines @@
   message_loop_->PostTaskAndReply(FROM_HERE, base::Bind(
       &AudioOutputController::DoClose, this), closed_task);
 }
 
 void AudioOutputController::SetVolume(double volume) {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoSetVolume, this, volume));
 }
 
-void AudioOutputController::DoCreate(AudioManager* audio_manager,
-                                     const AudioParameters& params) {
+void AudioOutputController::DoCreate(AudioManager* audio_manager) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
   DCHECK_EQ(kEmpty, state_);
 
   DoStopCloseAndClearStream(NULL);
-  stream_ = audio_manager->MakeAudioOutputStreamProxy(params);
+  stream_ = audio_manager->MakeAudioOutputStreamProxy(params_);
   if (!stream_) {
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   if (!stream_->Open()) {
     DoStopCloseAndClearStream(NULL);
 
     // TODO(hclam): Define error types.
@@ skipping 143 matching lines @@
       return;
   }
 }
 
 void AudioOutputController::DoReportError(int code) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (state_ != kClosed)
     handler_->OnError(this, code);
 }
 
-uint32 AudioOutputController::OnMoreData(uint8* dest,
-                                         uint32 max_size,
-                                         AudioBuffersState buffers_state) {
+int AudioOutputController::OnMoreData(AudioBus* audio_bus,
+                                      AudioBuffersState buffers_state) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 
   {
     // Check state and do nothing if we are not playing.
     // We are on the hardware audio thread, so lock is needed.
     base::AutoLock auto_lock(lock_);
     if (state_ != kPlaying) {
       return 0;
     }
   }
-  uint32 size = sync_reader_->Read(dest, max_size);
-  sync_reader_->UpdatePendingBytes(buffers_state.total_bytes() + size);
-  return size;
+  int frames = sync_reader_->Read(audio_bus);
+  sync_reader_->UpdatePendingBytes(
+      buffers_state.total_bytes() + frames * params_.GetBytesPerFrame());
+  return frames;
 }
 
 void AudioOutputController::WaitTillDataReady() {
   if (!sync_reader_->DataReady()) {
     // In the different place we use different mechanism to poll, get max
     // polling delay from constants used there.
     const base::TimeDelta kMaxPollingDelay = TimeDelta::FromMilliseconds(
         kPollNumAttempts * kPollPauseInMilliseconds);
     Time start_time = Time::Now();
     do {
@@ skipping 19 matching lines @@
     stream_ = NULL;
     weak_this_.InvalidateWeakPtrs();
   }
 
   // Should be last in the method, do not touch "this" from here on.
   if (done != NULL)
     done->Signal();
 }
 
 }  // namespace media