media/audio/audio_output_controller.cc

   1 // Copyright (c) 2012 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/audio_output_controller.h"
   6
   7 #include "base/bind.h"
   8 #include "base/metrics/histogram_macros.h"
   9 #include "base/numerics/safe_conversions.h"
  10 #include "base/task_runner_util.h"
  11 #include "base/threading/platform_thread.h"
  12 #include "base/time/time.h"
  13 #include "base/trace_event/trace_event.h"
  14
  15 using base::TimeDelta;
  16
  17 namespace media {
  18
  19 AudioOutputController::AudioOutputController(
  20     AudioManager* audio_manager,
  21     EventHandler* handler,
  22     const AudioParameters& params,
  23     const std::string& output_device_id,
  24     SyncReader* sync_reader)
  25     : audio_manager_(audio_manager),
  26       params_(params),
  27       handler_(handler),
  28       output_device_id_(output_device_id),
  29       stream_(NULL),
  30       diverting_to_stream_(NULL),
  31       volume_(1.0),
  32       state_(kEmpty),
  33       sync_reader_(sync_reader),
  34       message_loop_(audio_manager->GetTaskRunner()),
  35       power_monitor_(
  36           params.sample_rate(),
  37           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
  38       on_more_io_data_called_(0) {
  39   DCHECK(audio_manager);
  40   DCHECK(handler_);
  41   DCHECK(sync_reader_);
  42   DCHECK(message_loop_.get());
  43 }
  44
  45 AudioOutputController::~AudioOutputController() {
  46   DCHECK_EQ(kClosed, state_);
  47 }
  48
  49 // static
  50 scoped_refptr<AudioOutputController> AudioOutputController::Create(
  51     AudioManager* audio_manager,
  52     EventHandler* event_handler,
  53     const AudioParameters& params,
  54     const std::string& output_device_id,
  55     SyncReader* sync_reader) {
  56   DCHECK(audio_manager);
  57   DCHECK(sync_reader);
  58
  59   if (!params.IsValid() || !audio_manager)
  60     return NULL;
  61
  62   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
  63       audio_manager, event_handler, params, output_device_id, sync_reader));
  64   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
  65       &AudioOutputController::DoCreate, controller, false));
  66   return controller;
  67 }
  68
  69 void AudioOutputController::Play() {
  70   message_loop_->PostTask(FROM_HERE, base::Bind(
  71       &AudioOutputController::DoPlay, this));
  72 }
  73
  74 void AudioOutputController::Pause() {
  75   message_loop_->PostTask(FROM_HERE, base::Bind(
  76       &AudioOutputController::DoPause, this));
  77 }
  78
  79 void AudioOutputController::Close(const base::Closure& closed_task) {
  80   DCHECK(!closed_task.is_null());
  81   message_loop_->PostTaskAndReply(FROM_HERE, base::Bind(
  82       &AudioOutputController::DoClose, this), closed_task);
  83 }
  84
  85 void AudioOutputController::SetVolume(double volume) {
  86   message_loop_->PostTask(FROM_HERE, base::Bind(
  87       &AudioOutputController::DoSetVolume, this, volume));
  88 }
  89
  90 void AudioOutputController::GetOutputDeviceId(
  91     base::Callback<void(const std::string&)> callback) const {
  92   base::PostTaskAndReplyWithResult(
  93       message_loop_.get(),
  94       FROM_HERE,
  95       base::Bind(&AudioOutputController::DoGetOutputDeviceId, this),
  96       callback);
  97 }
  98
  99 void AudioOutputController::SwitchOutputDevice(
 100     const std::string& output_device_id, const base::Closure& callback) {
 101   message_loop_->PostTaskAndReply(
 102       FROM_HERE,
 103       base::Bind(&AudioOutputController::DoSwitchOutputDevice, this,
 104                  output_device_id),
 105       callback);
 106 }
 107
 108 void AudioOutputController::DoCreate(bool is_for_device_change) {
 109   DCHECK(message_loop_->BelongsToCurrentThread());
 110   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CreateTime");
 111   TRACE_EVENT0("audio", "AudioOutputController::DoCreate");
 112
 113   // Close() can be called before DoCreate() is executed.
 114   if (state_ == kClosed)
 115     return;
 116
 117   DoStopCloseAndClearStream();  // Calls RemoveOutputDeviceChangeListener().
 118   DCHECK_EQ(kEmpty, state_);
 119
 120   stream_ = diverting_to_stream_ ?
 121       diverting_to_stream_ :
 122       audio_manager_->MakeAudioOutputStreamProxy(params_, output_device_id_);
 123   if (!stream_) {
 124     state_ = kError;
 125     handler_->OnError();
 126     return;
 127   }
 128
 129   if (!stream_->Open()) {
 130     DoStopCloseAndClearStream();
 131     state_ = kError;
 132     handler_->OnError();
 133     return;
 134   }
 135
 136   // Everything started okay, so re-register for state change callbacks if
 137   // stream_ was created via AudioManager.
 138   if (stream_ != diverting_to_stream_)
 139     audio_manager_->AddOutputDeviceChangeListener(this);
 140
 141   // We have successfully opened the stream. Set the initial volume.
 142   stream_->SetVolume(volume_);
 143
 144   // Finally set the state to kCreated.
 145   state_ = kCreated;
 146
 147   // And then report we have been created if we haven't done so already.
 148   if (!is_for_device_change)
 149     handler_->OnCreated();
 150 }
 151
 152 void AudioOutputController::DoPlay() {
 153   DCHECK(message_loop_->BelongsToCurrentThread());
 154   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.PlayTime");
 155   TRACE_EVENT0("audio", "AudioOutputController::DoPlay");
 156
 157   // We can start from created or paused state.
 158   if (state_ != kCreated && state_ != kPaused)
 159     return;
 160
 161   // Ask for first packet.
 162   sync_reader_->UpdatePendingBytes(0);
 163
 164   state_ = kPlaying;
 165
 166   stream_->Start(this);
 167
 168   // For UMA tracking purposes, start the wedge detection timer.  This allows us
 169   // to record statistics about the number of wedged playbacks in the field.
 170   //
 171   // WedgeCheck() will look to see if |on_more_io_data_called_| is true after
 172   // the timeout expires.  Care must be taken to ensure the wedge check delay is
 173   // large enough that the value isn't queried while OnMoreDataIO() is setting
 174   // it.
 175   //
 176   // Timer self-manages its lifetime and WedgeCheck() will only record the UMA
 177   // statistic if state is still kPlaying.  Additional Start() calls will
 178   // invalidate the previous timer.
 179   wedge_timer_.reset(new base::OneShotTimer<AudioOutputController>());
 180   wedge_timer_->Start(
 181       FROM_HERE, TimeDelta::FromSeconds(5), this,
 182       &AudioOutputController::WedgeCheck);
 183
 184   handler_->OnPlaying();
 185 }
 186
 187 void AudioOutputController::StopStream() {
 188   DCHECK(message_loop_->BelongsToCurrentThread());
 189
 190   if (state_ == kPlaying) {
 191     wedge_timer_.reset();
 192     stream_->Stop();
 193
 194     // A stopped stream is silent, and power_montior_.Scan() is no longer being
 195     // called; so we must reset the power monitor.
 196     power_monitor_.Reset();
 197
 198     state_ = kPaused;
 199   }
 200 }
 201
 202 void AudioOutputController::DoPause() {
 203   DCHECK(message_loop_->BelongsToCurrentThread());
 204   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.PauseTime");
 205   TRACE_EVENT0("audio", "AudioOutputController::DoPause");
 206
 207   StopStream();
 208
 209   if (state_ != kPaused)
 210     return;
 211
 212   // Let the renderer know we've stopped.  Necessary to let PPAPI clients know
 213   // audio has been shutdown.  TODO(dalecurtis): This stinks.  PPAPI should have
 214   // a better way to know when it should exit PPB_Audio_Shared::Run().
 215   sync_reader_->UpdatePendingBytes(kuint32max);
 216
 217   handler_->OnPaused();
 218 }
 219
 220 void AudioOutputController::DoClose() {
 221   DCHECK(message_loop_->BelongsToCurrentThread());
 222   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CloseTime");
 223   TRACE_EVENT0("audio", "AudioOutputController::DoClose");
 224
 225   if (state_ != kClosed) {
 226     DoStopCloseAndClearStream();
 227     sync_reader_->Close();
 228     state_ = kClosed;
 229   }
 230 }
 231
 232 void AudioOutputController::DoSetVolume(double volume) {
 233   DCHECK(message_loop_->BelongsToCurrentThread());
 234
 235   // Saves the volume to a member first. We may not be able to set the volume
 236   // right away but when the stream is created we'll set the volume.
 237   volume_ = volume;
 238
 239   switch (state_) {
 240     case kCreated:
 241     case kPlaying:
 242     case kPaused:
 243       stream_->SetVolume(volume_);
 244       break;
 245     default:
 246       return;
 247   }
 248 }
 249
 250 std::string AudioOutputController::DoGetOutputDeviceId() const {
 251   DCHECK(message_loop_->BelongsToCurrentThread());
 252   return output_device_id_;
 253 }
 254
 255 void AudioOutputController::DoSwitchOutputDevice(
 256     const std::string& output_device_id) {
 257   DCHECK(message_loop_->BelongsToCurrentThread());
 258
 259   if (state_ == kClosed)
 260     return;
 261
 262   if (output_device_id == output_device_id_)
 263     return;
 264
 265   output_device_id_ = output_device_id;
 266
 267   // If output is currently diverted, we must not call OnDeviceChange
 268   // since it would break the diverted setup. Once diversion is
 269   // finished using StopDiverting() the output will switch to the new
 270   // device ID.
 271   if (stream_ != diverting_to_stream_)
 272     OnDeviceChange();
 273 }
 274
 275 void AudioOutputController::DoReportError() {
 276   DCHECK(message_loop_->BelongsToCurrentThread());
 277   if (state_ != kClosed)
 278     handler_->OnError();
 279 }
 280
 281 int AudioOutputController::OnMoreData(AudioBus* dest,
 282                                       uint32 total_bytes_delay) {
 283   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 284
 285   // Indicate that we haven't wedged (at least not indefinitely, WedgeCheck()
 286   // may have already fired if OnMoreData() took an abnormal amount of time).
 287   // Since this thread is the only writer of |on_more_io_data_called_| once the
 288   // thread starts, its safe to compare and then increment.
 289   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
 290     base::AtomicRefCountInc(&on_more_io_data_called_);
 291
 292   sync_reader_->Read(dest);
 293
 294   const int frames = dest->frames();
 295   sync_reader_->UpdatePendingBytes(base::saturated_cast<uint32>(
 296       total_bytes_delay + frames * params_.GetBytesPerFrame()));
 297
 298   if (will_monitor_audio_levels())
 299     power_monitor_.Scan(*dest, frames);
 300
 301   return frames;
 302 }
 303
 304 void AudioOutputController::OnError(AudioOutputStream* stream) {
 305   // Handle error on the audio controller thread.
 306   message_loop_->PostTask(FROM_HERE, base::Bind(
 307       &AudioOutputController::DoReportError, this));
 308 }
 309
 310 void AudioOutputController::DoStopCloseAndClearStream() {
 311   DCHECK(message_loop_->BelongsToCurrentThread());
 312
 313   // Allow calling unconditionally and bail if we don't have a stream_ to close.
 314   if (stream_) {
 315     // De-register from state change callbacks if stream_ was created via
 316     // AudioManager.
 317     if (stream_ != diverting_to_stream_)
 318       audio_manager_->RemoveOutputDeviceChangeListener(this);
 319
 320     StopStream();
 321     stream_->Close();
 322     if (stream_ == diverting_to_stream_)
 323       diverting_to_stream_ = NULL;
 324     stream_ = NULL;
 325   }
 326
 327   state_ = kEmpty;
 328 }
 329
 330 void AudioOutputController::OnDeviceChange() {
 331   DCHECK(message_loop_->BelongsToCurrentThread());
 332   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.DeviceChangeTime");
 333   TRACE_EVENT0("audio", "AudioOutputController::OnDeviceChange");
 334
 335   // TODO(dalecurtis): Notify the renderer side that a device change has
 336   // occurred.  Currently querying the hardware information here will lead to
 337   // crashes on OSX.  See http://crbug.com/158170.
 338
 339   // Recreate the stream (DoCreate() will first shut down an existing stream).
 340   // Exit if we ran into an error.
 341   const State original_state = state_;
 342   DoCreate(true);
 343   if (!stream_ || state_ == kError)
 344     return;
 345
 346   // Get us back to the original state or an equivalent state.
 347   switch (original_state) {
 348     case kPlaying:
 349       DoPlay();
 350       return;
 351     case kCreated:
 352     case kPaused:
 353       // From the outside these two states are equivalent.
 354       return;
 355     default:
 356       NOTREACHED() << "Invalid original state.";
 357   }
 358 }
 359
 360 const AudioParameters& AudioOutputController::GetAudioParameters() {
 361   return params_;
 362 }
 363
 364 void AudioOutputController::StartDiverting(AudioOutputStream* to_stream) {
 365   message_loop_->PostTask(
 366       FROM_HERE,
 367       base::Bind(&AudioOutputController::DoStartDiverting, this, to_stream));
 368 }
 369
 370 void AudioOutputController::StopDiverting() {
 371   message_loop_->PostTask(
 372       FROM_HERE, base::Bind(&AudioOutputController::DoStopDiverting, this));
 373 }
 374
 375 void AudioOutputController::DoStartDiverting(AudioOutputStream* to_stream) {
 376   DCHECK(message_loop_->BelongsToCurrentThread());
 377
 378   if (state_ == kClosed)
 379     return;
 380
 381   DCHECK(!diverting_to_stream_);
 382   diverting_to_stream_ = to_stream;
 383   // Note: OnDeviceChange() will engage the "re-create" process, which will
 384   // detect and use the alternate AudioOutputStream rather than create a new one
 385   // via AudioManager.
 386   OnDeviceChange();
 387 }
 388
 389 void AudioOutputController::DoStopDiverting() {
 390   DCHECK(message_loop_->BelongsToCurrentThread());
 391
 392   if (state_ == kClosed)
 393     return;
 394
 395   // Note: OnDeviceChange() will cause the existing stream (the consumer of the
 396   // diverted audio data) to be closed, and diverting_to_stream_ will be set
 397   // back to NULL.
 398   OnDeviceChange();
 399   DCHECK(!diverting_to_stream_);
 400 }
 401
 402 std::pair<float, bool> AudioOutputController::ReadCurrentPowerAndClip() {
 403   DCHECK(will_monitor_audio_levels());
 404   return power_monitor_.ReadCurrentPowerAndClip();
 405 }
 406
 407 void AudioOutputController::WedgeCheck() {
 408   DCHECK(message_loop_->BelongsToCurrentThread());
 409
 410   // If we should be playing and we haven't, that's a wedge.
 411   if (state_ == kPlaying) {
 412     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
 413                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
 414   }
 415 }
 416
 417 }  // namespace media