audio_output_device.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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// Audio rendering unit utilizing audio output stream provided by browser
6// process through IPC.
7//
8// Relationship of classes.
9//
10//  AudioOutputController                AudioOutputDevice
11//           ^                                ^
12//           |                                |
13//           v               IPC              v
14//    AudioRendererHost  <---------> AudioOutputIPC (AudioMessageFilter)
15//
16// Transportation of audio samples from the render to the browser process
17// is done by using shared memory in combination with a sync socket pair
18// to generate a low latency transport. The AudioOutputDevice user registers an
19// AudioOutputDevice::RenderCallback at construction and will be polled by the
20// AudioOutputDevice for audio to be played out by the underlying audio layers.
21//
22// State sequences.
23//
24//            Task [IO thread]                  IPC [IO thread]
25//
26// Start -> CreateStreamOnIOThread -----> CreateStream ------>
27//       <- OnStreamCreated <- AudioMsg_NotifyStreamCreated <-
28//       ---> PlayOnIOThread -----------> PlayStream -------->
29//
30// Optionally Play() / Pause() sequences may occur:
31// Play -> PlayOnIOThread --------------> PlayStream --------->
32// Pause -> PauseOnIOThread ------------> PauseStream -------->
33// (note that Play() / Pause() sequences before OnStreamCreated are
34//  deferred until OnStreamCreated, with the last valid state being used)
35//
36// AudioOutputDevice::Render => audio transport on audio thread =>
37//                               |
38// Stop --> ShutDownOnIOThread -------->  CloseStream -> Close
39//
40// This class utilizes several threads during its lifetime, namely:
41// 1. Creating thread.
42//    Must be the main render thread.
43// 2. Control thread (may be the main render thread or another thread).
44//    The methods: Start(), Stop(), Play(), Pause(), SetVolume()
45//    must be called on the same thread.
46// 3. IO thread (internal implementation detail - not exposed to public API)
47//    The thread within which this class receives all the IPC messages and
48//    IPC communications can only happen in this thread.
49// 4. Audio transport thread (See AudioDeviceThread).
50//    Responsible for calling the AudioThreadCallback implementation that in
51//    turn calls AudioRendererSink::RenderCallback which feeds audio samples to
52//    the audio layer in the browser process using sync sockets and shared
53//    memory.
54//
55// Implementation notes:
56// - The user must call Stop() before deleting the class instance.
57
58#ifndef MEDIA_AUDIO_AUDIO_OUTPUT_DEVICE_H_
59#define MEDIA_AUDIO_AUDIO_OUTPUT_DEVICE_H_
60
61#include "base/basictypes.h"
62#include "base/bind.h"
63#include "base/memory/scoped_ptr.h"
64#include "base/memory/shared_memory.h"
65#include "media/audio/audio_device_thread.h"
66#include "media/audio/audio_output_ipc.h"
67#include "media/audio/audio_parameters.h"
68#include "media/audio/scoped_task_runner_observer.h"
69#include "media/base/audio_renderer_sink.h"
70#include "media/base/media_export.h"
71
72namespace media {
73
74class MEDIA_EXPORT AudioOutputDevice
75    : NON_EXPORTED_BASE(public AudioRendererSink),
76      NON_EXPORTED_BASE(public AudioOutputIPCDelegate),
77      NON_EXPORTED_BASE(public ScopedTaskRunnerObserver) {
78 public:
79  // NOTE: Clients must call Initialize() before using.
80  AudioOutputDevice(
81      scoped_ptr<AudioOutputIPC> ipc,
82      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
83
84  // Initialize the stream using |session_id|, which is used for the browser
85  // to select the correct input device.
86  void InitializeWithSessionId(const AudioParameters& params,
87                               RenderCallback* callback,
88                               int session_id);
89
90  // AudioRendererSink implementation.
91  virtual void Initialize(const AudioParameters& params,
92                          RenderCallback* callback) OVERRIDE;
93  virtual void Start() OVERRIDE;
94  virtual void Stop() OVERRIDE;
95  virtual void Play() OVERRIDE;
96  virtual void Pause() OVERRIDE;
97  virtual bool SetVolume(double volume) OVERRIDE;
98
99  // Methods called on IO thread ----------------------------------------------
100  // AudioOutputIPCDelegate methods.
101  virtual void OnStateChanged(AudioOutputIPCDelegate::State state) OVERRIDE;
102  virtual void OnStreamCreated(base::SharedMemoryHandle handle,
103                               base::SyncSocket::Handle socket_handle,
104                               int length) OVERRIDE;
105  virtual void OnIPCClosed() OVERRIDE;
106
107 protected:
108  // Magic required by ref_counted.h to avoid any code deleting the object
109  // accidentally while there are references to it.
110  friend class base::RefCountedThreadSafe<AudioOutputDevice>;
111  virtual ~AudioOutputDevice();
112
113 private:
114  // Note: The ordering of members in this enum is critical to correct behavior!
115  enum State {
116    IPC_CLOSED,  // No more IPCs can take place.
117    IDLE,  // Not started.
118    CREATING_STREAM,  // Waiting for OnStreamCreated() to be called back.
119    PAUSED,  // Paused.  OnStreamCreated() has been called.  Can Play()/Stop().
120    PLAYING,  // Playing back.  Can Pause()/Stop().
121  };
122
123  // Methods called on IO thread ----------------------------------------------
124  // The following methods are tasks posted on the IO thread that need to
125  // be executed on that thread.  They use AudioOutputIPC to send IPC messages
126  // upon state changes.
127  void CreateStreamOnIOThread(const AudioParameters& params);
128  void PlayOnIOThread();
129  void PauseOnIOThread();
130  void ShutDownOnIOThread();
131  void SetVolumeOnIOThread(double volume);
132
133  // base::MessageLoop::DestructionObserver implementation for the IO loop.
134  // If the IO loop dies before we do, we shut down the audio thread from here.
135  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
136
137  AudioParameters audio_parameters_;
138
139  RenderCallback* callback_;
140
141  // A pointer to the IPC layer that takes care of sending requests over to
142  // the AudioRendererHost.  Only valid when state_ != IPC_CLOSED and must only
143  // be accessed on the IO thread.
144  scoped_ptr<AudioOutputIPC> ipc_;
145
146  // Current state (must only be accessed from the IO thread).  See comments for
147  // State enum above.
148  State state_;
149
150  // State of Play() / Pause() calls before OnStreamCreated() is called.
151  bool play_on_start_;
152
153  // The media session ID used to identify which input device to be started.
154  // Only used by Unified IO.
155  int session_id_;
156
157  // Our audio thread callback class.  See source file for details.
158  class AudioThreadCallback;
159
160  // In order to avoid a race between OnStreamCreated and Stop(), we use this
161  // guard to control stopping and starting the audio thread.
162  base::Lock audio_thread_lock_;
163  AudioDeviceThread audio_thread_;
164  scoped_ptr<AudioOutputDevice::AudioThreadCallback> audio_callback_;
165
166  // Temporary hack to ignore OnStreamCreated() due to the user calling Stop()
167  // so we don't start the audio thread pointing to a potentially freed
168  // |callback_|.
169  //
170  // TODO(scherkus): Replace this by changing AudioRendererSink to either accept
171  // the callback via Start(). See http://crbug.com/151051 for details.
172  bool stopping_hack_;
173
174  DISALLOW_COPY_AND_ASSIGN(AudioOutputDevice);
175};
176
177}  // namespace media
178
179#endif  // MEDIA_AUDIO_AUDIO_OUTPUT_DEVICE_H_
180