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