Audio software mixer.

media/audio/audio_output_proxy.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_proxy.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_output_dispatcher.h"
 
 AudioOutputProxy::AudioOutputProxy(AudioOutputDispatcher* dispatcher)
     : dispatcher_(dispatcher),
       state_(kCreated),
-      physical_stream_(NULL),
-      volume_(1.0) {
+      volume_(1.0),
+      audio_source_callback_(NULL) {
 }
 
 AudioOutputProxy::~AudioOutputProxy() {
   DCHECK(CalledOnValidThread());
   DCHECK(state_ == kCreated || state_ == kClosed);
-  DCHECK(!physical_stream_);
+  DCHECK(!audio_source_callback_);
 }
 
 bool AudioOutputProxy::Open() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, kCreated);
 
-  if (!dispatcher_->StreamOpened()) {
+  if (!dispatcher_->OpenStream()) {
     state_ = kError;
     return false;
   }
 
   state_ = kOpened;
   return true;
 }
 
 void AudioOutputProxy::Start(AudioSourceCallback* callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(physical_stream_ == NULL);
   DCHECK_EQ(state_, kOpened);
+  DCHECK(!audio_source_callback_);
 
-  physical_stream_= dispatcher_->StreamStarted();
-  if (!physical_stream_) {
+  audio_source_callback_ = callback;
+  if (!dispatcher_->StartStream(callback, this)) {
     state_ = kError;
     callback->OnError(this, 0);
+    audio_source_callback_ = NULL;
     return;
   }
-
-  physical_stream_->SetVolume(volume_);
-  physical_stream_->Start(callback);
   state_ = kPlaying;
 }
 
 void AudioOutputProxy::Stop() {
   DCHECK(CalledOnValidThread());
   if (state_ != kPlaying)
     return;
 
-  DCHECK(physical_stream_);
-  physical_stream_->Stop();
-  dispatcher_->StreamStopped(physical_stream_);
-  physical_stream_ = NULL;
+  dispatcher_->StopStream(this);
+  audio_source_callback_ = NULL;
   state_ = kOpened;
 }
 
 void AudioOutputProxy::SetVolume(double volume) {
   DCHECK(CalledOnValidThread());
-  volume_ = volume;
-  if (physical_stream_) {
-    physical_stream_->SetVolume(volume);
+  {
+    base::AutoLock lock(lock_);

[vrk (LEFT CHROMIUM), 2012/04/06 23:37:05]

See suggestion in audio_output_mixer.h, and remove this lock.

[enal1, 2012/04/16 22:01:35]

Done.

+    volume_ = volume;
   }
+  dispatcher_->StreamVolumeSet(this, volume);
 }
 
 void AudioOutputProxy::GetVolume(double* volume) {
-  DCHECK(CalledOnValidThread());
+  base::AutoLock lock(lock_);
   *volume = volume_;
 }
 
 void AudioOutputProxy::Close() {
   DCHECK(CalledOnValidThread());
   DCHECK(state_ == kCreated || state_ == kError || state_ == kOpened);
-  DCHECK(!physical_stream_);
+  DCHECK(!audio_source_callback_);
 
   if (state_ != kCreated)
-    dispatcher_->StreamClosed();
+    dispatcher_->CloseStream(this);
 
   state_ = kClosed;
 
   // Delete the object now like is done in the Close() implementation of
   // physical stream objects.  If we delete the object via DeleteSoon, we
   // unnecessarily complicate the Shutdown procedure of the
   // dispatcher+audio manager.
   delete this;
 }
+
+uint32 AudioOutputProxy::OnMoreData(AudioOutputStream* stream,

[vrk (LEFT CHROMIUM), 2012/04/06 23:37:05]

See suggestion in audio_output_mixer.h, and remove these methods. (Sorry, I know
I originally suggested these methods! But I didn't consider the threading
scenario in this class.)

[enal1, 2012/04/16 22:01:35]

Done.

+                                    uint8* dest,
+                                    uint32 max_size,
+                                    AudioBuffersState buffers_state) {
+  DCHECK(stream == this);
+  return audio_source_callback_->OnMoreData(stream,
+                                            dest,
+                                            max_size,
+                                            buffers_state);
+}
+
+void AudioOutputProxy::OnError(AudioOutputStream* stream, int code) {
+  DCHECK(stream == this);
+  audio_source_callback_->OnError(stream, code);
+}
+
+void AudioOutputProxy::WaitTillDataReady() {
+  audio_source_callback_->WaitTillDataReady();
+}