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