Simplified AudioOutputStream interface.

media/audio/audio_output_controller.cc

 // Copyright (c) 2010 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/message_loop.h"
 
-// The following parameters limit the request buffer and packet size from the
-// renderer to avoid renderer from requesting too much memory.
-static const uint32 kMegabytes = 1024 * 1024;
-static const uint32 kMaxHardwareBufferSize = 2 * kMegabytes;
 // Signal a pause in low-latency mode.
 static const int kPauseMark = -1;
 
 namespace {
 // Return true if the parameters for creating an audio stream is valid.
 // Return false otherwise.
-static bool CheckParameters(AudioParameters params,
-                            uint32 hardware_buffer_size) {
+static bool CheckParameters(AudioParameters params) {
   if (!params.IsValid())
     return false;
-  if (hardware_buffer_size <= 0 ||
-      hardware_buffer_size > kMaxHardwareBufferSize)
-    return false;
   return true;
 }
 
 }  // namespace
 
 namespace media {
 
 AudioOutputController::AudioOutputController(EventHandler* handler,
                                              uint32 capacity,
                                              SyncReader* sync_reader)
     : handler_(handler),
       stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       buffer_(0, capacity),
       pending_request_(false),
       sync_reader_(sync_reader),
       message_loop_(NULL) {
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK(kClosed == state_);
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     EventHandler* event_handler,
     AudioParameters params,
-    uint32 hardware_buffer_size,
     uint32 buffer_capacity) {
 
-  if (!CheckParameters(params, hardware_buffer_size))
+  if (!CheckParameters(params))
     return NULL;
 
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
       event_handler, buffer_capacity, NULL));
 
   controller->message_loop_ =
       AudioManager::GetAudioManager()->GetMessageLoop();
   controller->message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(controller.get(), &AudioOutputController::DoCreate,
-                        params, hardware_buffer_size));
+                        params));
   return controller;
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::CreateLowLatency(
     EventHandler* event_handler,
     AudioParameters params,
-    uint32 hardware_buffer_size,
     SyncReader* sync_reader) {
 
   DCHECK(sync_reader);
 
-  if (!CheckParameters(params, hardware_buffer_size))
+  if (!CheckParameters(params))
     return NULL;
 
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
       event_handler, 0, sync_reader));
 
   controller->message_loop_ =
       AudioManager::GetAudioManager()->GetMessageLoop();
   controller->message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(controller.get(), &AudioOutputController::DoCreate,
-                        params, hardware_buffer_size));
+                        params));
   return controller;
 }
 
 void AudioOutputController::Play() {
   DCHECK(message_loop_);
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioOutputController::DoPlay));
 }
 
@@ skipping 32 matching lines @@
   pending_request_ = false;
   // If |size| is set to 0, it indicates that the audio source doesn't have
   // more data right now, and so it doesn't make sense to send additional
   // request.
   if (size) {
     buffer_.Append(data, size);
     SubmitOnMoreData_Locked();
   }
 }
 
-void AudioOutputController::DoCreate(AudioParameters params,
-                                     uint32 hardware_buffer_size) {
+void AudioOutputController::DoCreate(AudioParameters params) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
   DCHECK(state_ == kEmpty);
 
   stream_ = AudioManager::GetAudioManager()->MakeAudioOutputStream(params);
   if (!stream_) {
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
-  if (!stream_->Open(hardware_buffer_size)) {
+  if (!stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
 
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
+
   // We have successfully opened the stream. Set the initial volume.
   stream_->SetVolume(volume_);
 
   // Finally set the state to kCreated.
   state_ = kCreated;
 
   // And then report we have been created.
   handler_->OnCreated(this);
 
   // If in normal latency mode then start buffering.
@@ skipping 58 matching lines @@
   if (state_ != kClosed) {
     // |stream_| can be null if creating the device failed in DoCreate().
     if (stream_) {
       stream_->Stop();
       stream_->Close();
       // After stream is closed it is destroyed, so don't keep a reference to
       // it.
       stream_ = NULL;
     }
 
+    if (LowLatencyMode()) {
+      sync_reader_->Close();
+    }
+
     state_ = kClosed;
   }
 
   closed_task->Run();
   delete closed_task;
 }
 
 void AudioOutputController::DoSetVolume(double volume) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
@@ skipping 33 matching lines @@
     SubmitOnMoreData_Locked();
     return size;
   }
 
   // Low latency mode.
   uint32 size =  sync_reader_->Read(dest, max_size);
   sync_reader_->UpdatePendingBytes(buffers_state.total_bytes() + size);
   return size;
 }
 
-void AudioOutputController::OnClose(AudioOutputStream* stream) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
-
-  // Push source doesn't need to know the stream so just pass in NULL.
-  if (LowLatencyMode()) {
-    sync_reader_->Close();
-  }
-}
-
 void AudioOutputController::OnError(AudioOutputStream* stream, int code) {
   // Handle error on the audio controller thread.
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioOutputController::DoReportError, code));
 }
 
 void AudioOutputController::SubmitOnMoreData_Locked() {
   lock_.AssertAcquired();
 
   if (buffer_.forward_bytes() > buffer_.forward_capacity())
     return;
 
   if (pending_request_)
     return;
   pending_request_ = true;
 
   AudioBuffersState buffers_state = buffers_state_;
   buffers_state.pending_bytes += buffer_.forward_bytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
   AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, buffers_state);
 }
 
 }  // namespace media