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.
5 #include "media/audio/audio_input_controller.h"
8 #include "base/threading/thread_restrictions.h"
9 #include "media/base/limits.h"
10 #include "media/base/scoped_histogram_timer.h"
11 #include "media/base/user_input_monitor.h"
14 const int kMaxInputChannels = 2;
16 // TODO(henrika): remove usage of timers and add support for proper
17 // notification of when the input device is removed. This was originally added
18 // to resolve http://crbug.com/79936 for Windows platforms. This then caused
19 // breakage (very hard to repro bugs!) on other platforms: See
20 // http://crbug.com/226327 and http://crbug.com/230972.
21 // See also that the timer has been disabled on Mac now due to
23 const int kTimerResetIntervalSeconds = 1;
24 // We have received reports that the timer can be too trigger happy on some
25 // Mac devices and the initial timer interval has therefore been increased
26 // from 1 second to 5 seconds.
27 const int kTimerInitialIntervalSeconds = 5;
33 AudioInputController::Factory* AudioInputController::factory_ = NULL;
35 AudioInputController::AudioInputController(EventHandler* handler,
36 SyncWriter* sync_writer,
37 UserInputMonitor* user_input_monitor)
38 : creator_task_runner_(base::MessageLoopProxy::current()),
41 data_is_active_(false),
43 sync_writer_(sync_writer),
45 user_input_monitor_(user_input_monitor),
46 prev_key_down_count_(0) {
47 DCHECK(creator_task_runner_.get());
50 AudioInputController::~AudioInputController() {
51 DCHECK_EQ(state_, CLOSED);
55 scoped_refptr<AudioInputController> AudioInputController::Create(
56 AudioManager* audio_manager,
57 EventHandler* event_handler,
58 const AudioParameters& params,
59 const std::string& device_id,
60 UserInputMonitor* user_input_monitor) {
61 DCHECK(audio_manager);
63 if (!params.IsValid() || (params.channels() > kMaxInputChannels))
67 return factory_->Create(
68 audio_manager, event_handler, params, user_input_monitor);
70 scoped_refptr<AudioInputController> controller(
71 new AudioInputController(event_handler, NULL, user_input_monitor));
73 controller->task_runner_ = audio_manager->GetTaskRunner();
75 // Create and open a new audio input stream from the existing
76 // audio-device thread.
77 if (!controller->task_runner_->PostTask(FROM_HERE,
78 base::Bind(&AudioInputController::DoCreate, controller,
79 base::Unretained(audio_manager), params, device_id))) {
87 scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
88 AudioManager* audio_manager,
89 EventHandler* event_handler,
90 const AudioParameters& params,
91 const std::string& device_id,
92 SyncWriter* sync_writer,
93 UserInputMonitor* user_input_monitor) {
94 DCHECK(audio_manager);
97 if (!params.IsValid() || (params.channels() > kMaxInputChannels))
100 // Create the AudioInputController object and ensure that it runs on
101 // the audio-manager thread.
102 scoped_refptr<AudioInputController> controller(
103 new AudioInputController(event_handler, sync_writer, user_input_monitor));
104 controller->task_runner_ = audio_manager->GetTaskRunner();
106 // Create and open a new audio input stream from the existing
107 // audio-device thread. Use the provided audio-input device.
108 if (!controller->task_runner_->PostTask(FROM_HERE,
109 base::Bind(&AudioInputController::DoCreate, controller,
110 base::Unretained(audio_manager), params, device_id))) {
118 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
119 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
120 EventHandler* event_handler,
121 AudioInputStream* stream,
122 SyncWriter* sync_writer,
123 UserInputMonitor* user_input_monitor) {
127 // Create the AudioInputController object and ensure that it runs on
128 // the audio-manager thread.
129 scoped_refptr<AudioInputController> controller(
130 new AudioInputController(event_handler, sync_writer, user_input_monitor));
131 controller->task_runner_ = task_runner;
133 // TODO(miu): See TODO at top of file. Until that's resolved, we need to
134 // disable the error auto-detection here (since the audio mirroring
135 // implementation will reliably report error and close events). Note, of
136 // course, that we're assuming CreateForStream() has been called for the audio
137 // mirroring use case only.
138 if (!controller->task_runner_->PostTask(
140 base::Bind(&AudioInputController::DoCreateForStream, controller,
148 void AudioInputController::Record() {
149 task_runner_->PostTask(FROM_HERE, base::Bind(
150 &AudioInputController::DoRecord, this));
153 void AudioInputController::Close(const base::Closure& closed_task) {
154 DCHECK(!closed_task.is_null());
155 DCHECK(creator_task_runner_->BelongsToCurrentThread());
157 task_runner_->PostTaskAndReply(
158 FROM_HERE, base::Bind(&AudioInputController::DoClose, this), closed_task);
161 void AudioInputController::SetVolume(double volume) {
162 task_runner_->PostTask(FROM_HERE, base::Bind(
163 &AudioInputController::DoSetVolume, this, volume));
166 void AudioInputController::SetAutomaticGainControl(bool enabled) {
167 task_runner_->PostTask(FROM_HERE, base::Bind(
168 &AudioInputController::DoSetAutomaticGainControl, this, enabled));
171 void AudioInputController::DoCreate(AudioManager* audio_manager,
172 const AudioParameters& params,
173 const std::string& device_id) {
174 DCHECK(task_runner_->BelongsToCurrentThread());
175 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CreateTime");
176 // TODO(miu): See TODO at top of file. Until that's resolved, assume all
177 // platform audio input requires the |no_data_timer_| be used to auto-detect
178 // errors. In reality, probably only Windows needs to be treated as
180 DoCreateForStream(audio_manager->MakeAudioInputStream(params, device_id),
184 void AudioInputController::DoCreateForStream(
185 AudioInputStream* stream_to_control, bool enable_nodata_timer) {
186 DCHECK(task_runner_->BelongsToCurrentThread());
189 stream_ = stream_to_control;
192 handler_->OnError(this, STREAM_CREATE_ERROR);
196 if (stream_ && !stream_->Open()) {
199 handler_->OnError(this, STREAM_OPEN_ERROR);
203 DCHECK(!no_data_timer_.get());
205 // This is a fix for crbug.com/357501. The timer can trigger when closing
206 // the lid on Macs, which causes more problems than the timer fixes.
207 // Also, in crbug.com/357569, the goal is to remove usage of this timer
208 // since it was added to solve a crash on Windows that no longer can be
210 // TODO(henrika): remove usage of timer when it has been verified on Canary
211 // that we are safe doing so. Goal is to get rid of |no_data_timer_| and
212 // everything that is tied to it.
213 enable_nodata_timer = false;
215 if (enable_nodata_timer) {
216 // Create the data timer which will call DoCheckForNoData(). The timer
217 // is started in DoRecord() and restarted in each DoCheckForNoData()
219 no_data_timer_.reset(new base::Timer(
220 FROM_HERE, base::TimeDelta::FromSeconds(kTimerInitialIntervalSeconds),
221 base::Bind(&AudioInputController::DoCheckForNoData,
222 base::Unretained(this)), false));
224 DVLOG(1) << "Disabled: timer check for no data.";
228 handler_->OnCreated(this);
230 if (user_input_monitor_) {
231 user_input_monitor_->EnableKeyPressMonitoring();
232 prev_key_down_count_ = user_input_monitor_->GetKeyPressCount();
236 void AudioInputController::DoRecord() {
237 DCHECK(task_runner_->BelongsToCurrentThread());
238 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");
240 if (state_ != CREATED)
244 base::AutoLock auto_lock(lock_);
248 if (no_data_timer_) {
249 // Start the data timer. Once |kTimerResetIntervalSeconds| have passed,
250 // a callback to DoCheckForNoData() is made.
251 no_data_timer_->Reset();
254 stream_->Start(this);
255 handler_->OnRecording(this);
258 void AudioInputController::DoClose() {
259 DCHECK(task_runner_->BelongsToCurrentThread());
260 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
262 if (state_ == CLOSED)
265 // Delete the timer on the same thread that created it.
266 no_data_timer_.reset();
268 DoStopCloseAndClearStream(NULL);
269 SetDataIsActive(false);
271 if (LowLatencyMode())
272 sync_writer_->Close();
274 if (user_input_monitor_)
275 user_input_monitor_->DisableKeyPressMonitoring();
280 void AudioInputController::DoReportError() {
281 DCHECK(task_runner_->BelongsToCurrentThread());
282 handler_->OnError(this, STREAM_ERROR);
285 void AudioInputController::DoSetVolume(double volume) {
286 DCHECK(task_runner_->BelongsToCurrentThread());
287 DCHECK_GE(volume, 0);
288 DCHECK_LE(volume, 1.0);
290 if (state_ != CREATED && state_ != RECORDING)
293 // Only ask for the maximum volume at first call and use cached value
294 // for remaining function calls.
296 max_volume_ = stream_->GetMaxVolume();
299 if (max_volume_ == 0.0) {
300 DLOG(WARNING) << "Failed to access input volume control";
304 // Set the stream volume and scale to a range matched to the platform.
305 stream_->SetVolume(max_volume_ * volume);
308 void AudioInputController::DoSetAutomaticGainControl(bool enabled) {
309 DCHECK(task_runner_->BelongsToCurrentThread());
310 DCHECK_NE(state_, RECORDING);
312 // Ensure that the AGC state only can be modified before streaming starts.
313 if (state_ != CREATED)
316 stream_->SetAutomaticGainControl(enabled);
319 void AudioInputController::DoCheckForNoData() {
320 DCHECK(task_runner_->BelongsToCurrentThread());
322 if (!GetDataIsActive()) {
323 // The data-is-active marker will be false only if it has been more than
324 // one second since a data packet was recorded. This can happen if a
325 // capture device has been removed or disabled.
326 handler_->OnError(this, NO_DATA_ERROR);
330 // Mark data as non-active. The flag will be re-enabled in OnData() each
331 // time a data packet is received. Hence, under normal conditions, the
332 // flag will only be disabled during a very short period.
333 SetDataIsActive(false);
335 // Restart the timer to ensure that we check the flag again in
336 // |kTimerResetIntervalSeconds|.
337 no_data_timer_->Start(
338 FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
339 base::Bind(&AudioInputController::DoCheckForNoData,
340 base::Unretained(this)));
343 void AudioInputController::OnData(AudioInputStream* stream,
346 uint32 hardware_delay_bytes,
349 base::AutoLock auto_lock(lock_);
350 if (state_ != RECORDING)
354 bool key_pressed = false;
355 if (user_input_monitor_) {
356 size_t current_count = user_input_monitor_->GetKeyPressCount();
357 key_pressed = current_count != prev_key_down_count_;
358 prev_key_down_count_ = current_count;
359 DVLOG_IF(6, key_pressed) << "Detected keypress.";
362 // Mark data as active to ensure that the periodic calls to
363 // DoCheckForNoData() does not report an error to the event handler.
364 SetDataIsActive(true);
366 // Use SyncSocket if we are in a low-latency mode.
367 if (LowLatencyMode()) {
368 sync_writer_->Write(data, size, volume, key_pressed);
369 sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
373 handler_->OnData(this, data, size);
376 void AudioInputController::OnError(AudioInputStream* stream) {
377 // Handle error on the audio-manager thread.
378 task_runner_->PostTask(FROM_HERE, base::Bind(
379 &AudioInputController::DoReportError, this));
382 void AudioInputController::DoStopCloseAndClearStream(
383 base::WaitableEvent* done) {
384 DCHECK(task_runner_->BelongsToCurrentThread());
386 // Allow calling unconditionally and bail if we don't have a stream to close.
387 if (stream_ != NULL) {
393 // Should be last in the method, do not touch "this" from here on.
398 void AudioInputController::SetDataIsActive(bool enabled) {
399 base::subtle::Release_Store(&data_is_active_, enabled);
402 bool AudioInputController::GetDataIsActive() {
403 return (base::subtle::Acquire_Load(&data_is_active_) != false);