media/audio/sounds/audio_stream_handler.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/audio/sounds/audio_stream_handler.h"
   6
   7 #include <string>
   8
   9 #include "base/cancelable_callback.h"
  10 #include "base/logging.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/synchronization/lock.h"
  13 #include "base/time/time.h"
  14 #include "media/audio/audio_manager.h"
  15 #include "media/audio/audio_manager_base.h"
  16 #include "media/base/channel_layout.h"
  17
  18 namespace media {
  19
  20 namespace {
  21
  22 // Volume percent.
  23 const double kOutputVolumePercent = 0.8;
  24
  25 // The number of frames each OnMoreData() call will request.
  26 const int kDefaultFrameCount = 1024;
  27
  28 // Keep alive timeout for audio stream.
  29 const int kKeepAliveMs = 1500;
  30
  31 AudioStreamHandler::TestObserver* g_observer_for_testing = NULL;
  32 AudioOutputStream::AudioSourceCallback* g_audio_source_for_testing = NULL;
  33
  34 }  // namespace
  35
  36 class AudioStreamHandler::AudioStreamContainer
  37     : public AudioOutputStream::AudioSourceCallback {
  38  public:
  39   AudioStreamContainer(const WavAudioHandler& wav_audio)
  40       : started_(false),
  41         stream_(NULL),
  42         cursor_(0),
  43         delayed_stop_posted_(false),
  44         wav_audio_(wav_audio) {}
  45
  46   ~AudioStreamContainer() override {
  47     DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
  48   }
  49
  50   void Play() {
  51     DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
  52
  53     if (!stream_) {
  54       const AudioParameters& p = wav_audio_.params();
  55       const AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
  56                                    p.channel_layout(),
  57                                    p.sample_rate(),
  58                                    p.bits_per_sample(),
  59                                    kDefaultFrameCount);
  60       stream_ = AudioManager::Get()->MakeAudioOutputStreamProxy(params,
  61                                                                 std::string());
  62       if (!stream_ || !stream_->Open()) {
  63         LOG(ERROR) << "Failed to open an output stream.";
  64         return;
  65       }
  66       stream_->SetVolume(kOutputVolumePercent);
  67     }
  68
  69     {
  70       base::AutoLock al(state_lock_);
  71
  72       delayed_stop_posted_ = false;
  73       stop_closure_.Reset(base::Bind(&AudioStreamContainer::StopStream,
  74                                      base::Unretained(this)));
  75
  76       if (started_) {
  77         if (wav_audio_.AtEnd(cursor_))
  78           cursor_ = 0;
  79         return;
  80       }
  81
  82       cursor_ = 0;
  83     }
  84
  85     started_ = true;
  86     if (g_audio_source_for_testing)
  87       stream_->Start(g_audio_source_for_testing);
  88     else
  89       stream_->Start(this);
  90
  91     if (g_observer_for_testing)
  92       g_observer_for_testing->OnPlay();
  93   }
  94
  95   void Stop() {
  96     DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
  97     StopStream();
  98     if (stream_)
  99       stream_->Close();
 100     stream_ = NULL;
 101     stop_closure_.Cancel();
 102   }
 103
 104  private:
 105   // AudioOutputStream::AudioSourceCallback overrides:
 106   // Following methods could be called from *ANY* thread.
 107   int OnMoreData(AudioBus* dest, uint32 /* total_bytes_delay */) override {
 108     base::AutoLock al(state_lock_);
 109     size_t bytes_written = 0;
 110
 111     if (wav_audio_.AtEnd(cursor_) ||
 112         !wav_audio_.CopyTo(dest, cursor_, &bytes_written)) {
 113       if (delayed_stop_posted_)
 114         return 0;
 115       delayed_stop_posted_ = true;
 116       AudioManager::Get()->GetTaskRunner()->PostDelayedTask(
 117           FROM_HERE,
 118           stop_closure_.callback(),
 119           base::TimeDelta::FromMilliseconds(kKeepAliveMs));
 120       return 0;
 121     }
 122     cursor_ += bytes_written;
 123     return dest->frames();
 124   }
 125
 126   void OnError(AudioOutputStream* /* stream */) override {
 127     LOG(ERROR) << "Error during system sound reproduction.";
 128   }
 129
 130   void StopStream() {
 131     DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
 132
 133     if (stream_ && started_) {
 134       // Do not hold the |state_lock_| while stopping the output stream.
 135       stream_->Stop();
 136       if (g_observer_for_testing)
 137         g_observer_for_testing->OnStop(cursor_);
 138     }
 139
 140     started_ = false;
 141   }
 142
 143   // Must only be accessed on the AudioManager::GetTaskRunner() thread.
 144   bool started_;
 145   AudioOutputStream* stream_;
 146
 147   // All variables below must be accessed under |state_lock_| when |started_|.
 148   base::Lock state_lock_;
 149   size_t cursor_;
 150   bool delayed_stop_posted_;
 151   const WavAudioHandler wav_audio_;
 152   base::CancelableClosure stop_closure_;
 153
 154   DISALLOW_COPY_AND_ASSIGN(AudioStreamContainer);
 155 };
 156
 157 AudioStreamHandler::AudioStreamHandler(const base::StringPiece& wav_data)
 158     : wav_audio_(wav_data),
 159       initialized_(false) {
 160   AudioManager* manager = AudioManager::Get();
 161   if (!manager) {
 162     LOG(ERROR) << "Can't get access to audio manager.";
 163     return;
 164   }
 165   if (!wav_audio_.params().IsValid()) {
 166     LOG(ERROR) << "Audio params are invalid.";
 167     return;
 168   }
 169   stream_.reset(new AudioStreamContainer(wav_audio_));
 170   initialized_ = true;
 171 }
 172
 173 AudioStreamHandler::~AudioStreamHandler() {
 174   DCHECK(CalledOnValidThread());
 175   AudioManager::Get()->GetTaskRunner()->PostTask(
 176       FROM_HERE,
 177       base::Bind(&AudioStreamContainer::Stop, base::Unretained(stream_.get())));
 178   AudioManager::Get()->GetTaskRunner()->DeleteSoon(FROM_HERE,
 179                                                    stream_.release());
 180 }
 181
 182 bool AudioStreamHandler::IsInitialized() const {
 183   DCHECK(CalledOnValidThread());
 184   return initialized_;
 185 }
 186
 187 bool AudioStreamHandler::Play() {
 188   DCHECK(CalledOnValidThread());
 189
 190   if (!IsInitialized())
 191     return false;
 192
 193   AudioManager::Get()->GetTaskRunner()->PostTask(
 194       FROM_HERE,
 195       base::Bind(base::IgnoreResult(&AudioStreamContainer::Play),
 196                  base::Unretained(stream_.get())));
 197   return true;
 198 }
 199
 200 void AudioStreamHandler::Stop() {
 201   DCHECK(CalledOnValidThread());
 202   AudioManager::Get()->GetTaskRunner()->PostTask(
 203       FROM_HERE,
 204       base::Bind(&AudioStreamContainer::Stop, base::Unretained(stream_.get())));
 205 }
 206
 207 // static
 208 void AudioStreamHandler::SetObserverForTesting(TestObserver* observer) {
 209   g_observer_for_testing = observer;
 210 }
 211
 212 // static
 213 void AudioStreamHandler::SetAudioSourceForTesting(
 214     AudioOutputStream::AudioSourceCallback* source) {
 215   g_audio_source_for_testing = source;
 216 }
 217
 218 }  // namespace media