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_input_device.h"
6
7 #include "base/basictypes.h"
8 #include "base/bind.h"
9 #include "base/memory/scoped_vector.h"
10 #include "base/threading/thread_restrictions.h"
11 #include "base/time/time.h"
12 #include "media/audio/audio_manager_base.h"
13 #include "media/base/audio_bus.h"
14
15 namespace media {
16
17 // The number of shared memory buffer segments indicated to browser process
18 // in order to avoid data overwriting. This number can be any positive number,
19 // dependent how fast the renderer process can pick up captured data from
20 // shared memory.
21 static const int kRequestedSharedMemoryCount = 10;
22
23 // Takes care of invoking the capture callback on the audio thread.
24 // An instance of this class is created for each capture stream in
25 // OnLowLatencyCreated().
26 class AudioInputDevice::AudioThreadCallback
27 : public AudioDeviceThread::Callback {
28 public:
29 AudioThreadCallback(const AudioParameters& audio_parameters,
30 base::SharedMemoryHandle memory,
31 int memory_length,
32 int total_segments,
33 CaptureCallback* capture_callback);
34 virtual ~AudioThreadCallback();
35
36 virtual void MapSharedMemory() OVERRIDE;
37
38 // Called whenever we receive notifications about pending data.
39 virtual void Process(int pending_data) OVERRIDE;
40
41 private:
42 int current_segment_id_;
43 ScopedVector<media::AudioBus> audio_buses_;
44 CaptureCallback* capture_callback_;
45
46 DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
47 };
48
AudioInputDevice(scoped_ptr<AudioInputIPC> ipc,const scoped_refptr<base::SingleThreadTaskRunner> & io_task_runner)49 AudioInputDevice::AudioInputDevice(
50 scoped_ptr<AudioInputIPC> ipc,
51 const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
52 : ScopedTaskRunnerObserver(io_task_runner),
53 callback_(NULL),
54 ipc_(ipc.Pass()),
55 state_(IDLE),
56 session_id_(0),
57 agc_is_enabled_(false),
58 stopping_hack_(false) {
59 CHECK(ipc_);
60
61 // The correctness of the code depends on the relative values assigned in the
62 // State enum.
63 COMPILE_ASSERT(IPC_CLOSED < IDLE, invalid_enum_value_assignment_0);
64 COMPILE_ASSERT(IDLE < CREATING_STREAM, invalid_enum_value_assignment_1);
65 COMPILE_ASSERT(CREATING_STREAM < RECORDING, invalid_enum_value_assignment_2);
66 }
67
Initialize(const AudioParameters & params,CaptureCallback * callback,int session_id)68 void AudioInputDevice::Initialize(const AudioParameters& params,
69 CaptureCallback* callback,
70 int session_id) {
71 DCHECK(params.IsValid());
72 DCHECK(!callback_);
73 DCHECK_EQ(0, session_id_);
74 audio_parameters_ = params;
75 callback_ = callback;
76 session_id_ = session_id;
77 }
78
Start()79 void AudioInputDevice::Start() {
80 DCHECK(callback_) << "Initialize hasn't been called";
81 DVLOG(1) << "Start()";
82 task_runner()->PostTask(FROM_HERE,
83 base::Bind(&AudioInputDevice::StartUpOnIOThread, this));
84 }
85
Stop()86 void AudioInputDevice::Stop() {
87 DVLOG(1) << "Stop()";
88
89 {
90 base::AutoLock auto_lock(audio_thread_lock_);
91 audio_thread_.Stop(base::MessageLoop::current());
92 stopping_hack_ = true;
93 }
94
95 task_runner()->PostTask(FROM_HERE,
96 base::Bind(&AudioInputDevice::ShutDownOnIOThread, this));
97 }
98
SetVolume(double volume)99 void AudioInputDevice::SetVolume(double volume) {
100 if (volume < 0 || volume > 1.0) {
101 DLOG(ERROR) << "Invalid volume value specified";
102 return;
103 }
104
105 task_runner()->PostTask(FROM_HERE,
106 base::Bind(&AudioInputDevice::SetVolumeOnIOThread, this, volume));
107 }
108
SetAutomaticGainControl(bool enabled)109 void AudioInputDevice::SetAutomaticGainControl(bool enabled) {
110 DVLOG(1) << "SetAutomaticGainControl(enabled=" << enabled << ")";
111 task_runner()->PostTask(FROM_HERE,
112 base::Bind(&AudioInputDevice::SetAutomaticGainControlOnIOThread,
113 this, enabled));
114 }
115
OnStreamCreated(base::SharedMemoryHandle handle,base::SyncSocket::Handle socket_handle,int length,int total_segments)116 void AudioInputDevice::OnStreamCreated(
117 base::SharedMemoryHandle handle,
118 base::SyncSocket::Handle socket_handle,
119 int length,
120 int total_segments) {
121 DCHECK(task_runner()->BelongsToCurrentThread());
122 #if defined(OS_WIN)
123 DCHECK(handle);
124 DCHECK(socket_handle);
125 #else
126 DCHECK_GE(handle.fd, 0);
127 DCHECK_GE(socket_handle, 0);
128 #endif
129 DCHECK_GT(length, 0);
130
131 if (state_ != CREATING_STREAM)
132 return;
133
134 base::AutoLock auto_lock(audio_thread_lock_);
135 // TODO(miu): See TODO in OnStreamCreated method for AudioOutputDevice.
136 // Interface changes need to be made; likely, after AudioInputDevice is merged
137 // into AudioOutputDevice (http://crbug.com/179597).
138 if (stopping_hack_)
139 return;
140
141 DCHECK(audio_thread_.IsStopped());
142 audio_callback_.reset(new AudioInputDevice::AudioThreadCallback(
143 audio_parameters_, handle, length, total_segments, callback_));
144 audio_thread_.Start(
145 audio_callback_.get(), socket_handle, "AudioInputDevice", false);
146
147 state_ = RECORDING;
148 ipc_->RecordStream();
149 }
150
OnVolume(double volume)151 void AudioInputDevice::OnVolume(double volume) {
152 NOTIMPLEMENTED();
153 }
154
OnStateChanged(AudioInputIPCDelegate::State state)155 void AudioInputDevice::OnStateChanged(
156 AudioInputIPCDelegate::State state) {
157 DCHECK(task_runner()->BelongsToCurrentThread());
158
159 // Do nothing if the stream has been closed.
160 if (state_ < CREATING_STREAM)
161 return;
162
163 // TODO(miu): Clean-up inconsistent and incomplete handling here.
164 // http://crbug.com/180640
165 switch (state) {
166 case AudioInputIPCDelegate::kStopped:
167 ShutDownOnIOThread();
168 break;
169 case AudioInputIPCDelegate::kRecording:
170 NOTIMPLEMENTED();
171 break;
172 case AudioInputIPCDelegate::kError:
173 DLOG(WARNING) << "AudioInputDevice::OnStateChanged(kError)";
174 // Don't dereference the callback object if the audio thread
175 // is stopped or stopping. That could mean that the callback
176 // object has been deleted.
177 // TODO(tommi): Add an explicit contract for clearing the callback
178 // object. Possibly require calling Initialize again or provide
179 // a callback object via Start() and clear it in Stop().
180 if (!audio_thread_.IsStopped())
181 callback_->OnCaptureError();
182 break;
183 default:
184 NOTREACHED();
185 break;
186 }
187 }
188
OnIPCClosed()189 void AudioInputDevice::OnIPCClosed() {
190 DCHECK(task_runner()->BelongsToCurrentThread());
191 state_ = IPC_CLOSED;
192 ipc_.reset();
193 }
194
~AudioInputDevice()195 AudioInputDevice::~AudioInputDevice() {
196 // TODO(henrika): The current design requires that the user calls
197 // Stop before deleting this class.
198 DCHECK(audio_thread_.IsStopped());
199 }
200
StartUpOnIOThread()201 void AudioInputDevice::StartUpOnIOThread() {
202 DCHECK(task_runner()->BelongsToCurrentThread());
203
204 // Make sure we don't call Start() more than once.
205 if (state_ != IDLE)
206 return;
207
208 if (session_id_ <= 0) {
209 DLOG(WARNING) << "Invalid session id for the input stream " << session_id_;
210 return;
211 }
212
213 state_ = CREATING_STREAM;
214 ipc_->CreateStream(this, session_id_, audio_parameters_,
215 agc_is_enabled_, kRequestedSharedMemoryCount);
216 }
217
ShutDownOnIOThread()218 void AudioInputDevice::ShutDownOnIOThread() {
219 DCHECK(task_runner()->BelongsToCurrentThread());
220
221 // Close the stream, if we haven't already.
222 if (state_ >= CREATING_STREAM) {
223 ipc_->CloseStream();
224 state_ = IDLE;
225 agc_is_enabled_ = false;
226 }
227
228 // We can run into an issue where ShutDownOnIOThread is called right after
229 // OnStreamCreated is called in cases where Start/Stop are called before we
230 // get the OnStreamCreated callback. To handle that corner case, we call
231 // Stop(). In most cases, the thread will already be stopped.
232 //
233 // Another situation is when the IO thread goes away before Stop() is called
234 // in which case, we cannot use the message loop to close the thread handle
235 // and can't not rely on the main thread existing either.
236 base::AutoLock auto_lock_(audio_thread_lock_);
237 base::ThreadRestrictions::ScopedAllowIO allow_io;
238 audio_thread_.Stop(NULL);
239 audio_callback_.reset();
240 stopping_hack_ = false;
241 }
242
SetVolumeOnIOThread(double volume)243 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
244 DCHECK(task_runner()->BelongsToCurrentThread());
245 if (state_ >= CREATING_STREAM)
246 ipc_->SetVolume(volume);
247 }
248
SetAutomaticGainControlOnIOThread(bool enabled)249 void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
250 DCHECK(task_runner()->BelongsToCurrentThread());
251
252 if (state_ >= CREATING_STREAM) {
253 DLOG(WARNING) << "The AGC state can not be modified after starting.";
254 return;
255 }
256
257 // We simply store the new AGC setting here. This value will be used when
258 // a new stream is initialized and by GetAutomaticGainControl().
259 agc_is_enabled_ = enabled;
260 }
261
WillDestroyCurrentMessageLoop()262 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
263 LOG(ERROR) << "IO loop going away before the input device has been stopped";
264 ShutDownOnIOThread();
265 }
266
267 // AudioInputDevice::AudioThreadCallback
AudioThreadCallback(const AudioParameters & audio_parameters,base::SharedMemoryHandle memory,int memory_length,int total_segments,CaptureCallback * capture_callback)268 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
269 const AudioParameters& audio_parameters,
270 base::SharedMemoryHandle memory,
271 int memory_length,
272 int total_segments,
273 CaptureCallback* capture_callback)
274 : AudioDeviceThread::Callback(audio_parameters, memory, memory_length,
275 total_segments),
276 current_segment_id_(0),
277 capture_callback_(capture_callback) {
278 }
279
~AudioThreadCallback()280 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
281 }
282
MapSharedMemory()283 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
284 shared_memory_.Map(memory_length_);
285
286 // Create vector of audio buses by wrapping existing blocks of memory.
287 uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
288 for (int i = 0; i < total_segments_; ++i) {
289 media::AudioInputBuffer* buffer =
290 reinterpret_cast<media::AudioInputBuffer*>(ptr);
291 scoped_ptr<media::AudioBus> audio_bus =
292 media::AudioBus::WrapMemory(audio_parameters_, buffer->audio);
293 audio_buses_.push_back(audio_bus.release());
294 ptr += segment_length_;
295 }
296 }
297
Process(int pending_data)298 void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
299 // The shared memory represents parameters, size of the data buffer and the
300 // actual data buffer containing audio data. Map the memory into this
301 // structure and parse out parameters and the data area.
302 uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
303 ptr += current_segment_id_ * segment_length_;
304 AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
305 // Usually this will be equal but in the case of low sample rate (e.g. 8kHz,
306 // the buffer may be bigger (on mac at least)).
307 DCHECK_GE(buffer->params.size,
308 segment_length_ - sizeof(AudioInputBufferParameters));
309 double volume = buffer->params.volume;
310 bool key_pressed = buffer->params.key_pressed;
311
312 // Use pre-allocated audio bus wrapping existing block of shared memory.
313 media::AudioBus* audio_bus = audio_buses_[current_segment_id_];
314
315 // Deliver captured data to the client in floating point format
316 // and update the audio-delay measurement.
317 int audio_delay_milliseconds = pending_data / bytes_per_ms_;
318 capture_callback_->Capture(
319 audio_bus, audio_delay_milliseconds, volume, key_pressed);
320
321 if (++current_segment_id_ >= total_segments_)
322 current_segment_id_ = 0;
323 }
324
325 } // namespace media
326