audio_input_controller.cc revision effb81e5f8246d0db0270817048dc992db66e9fb
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_controller.h" 6 7#include "base/bind.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" 12 13namespace { 14const int kMaxInputChannels = 2; 15 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 22// crbug.com/357501. 23const 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. 27const int kTimerInitialIntervalSeconds = 5; 28} 29 30namespace media { 31 32// static 33AudioInputController::Factory* AudioInputController::factory_ = NULL; 34 35AudioInputController::AudioInputController(EventHandler* handler, 36 SyncWriter* sync_writer, 37 UserInputMonitor* user_input_monitor) 38 : creator_task_runner_(base::MessageLoopProxy::current()), 39 handler_(handler), 40 stream_(NULL), 41 data_is_active_(false), 42 state_(CLOSED), 43 sync_writer_(sync_writer), 44 max_volume_(0.0), 45 user_input_monitor_(user_input_monitor), 46 prev_key_down_count_(0) { 47 DCHECK(creator_task_runner_.get()); 48} 49 50AudioInputController::~AudioInputController() { 51 DCHECK_EQ(state_, CLOSED); 52} 53 54// static 55scoped_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); 62 63 if (!params.IsValid() || (params.channels() > kMaxInputChannels)) 64 return NULL; 65 66 if (factory_) { 67 return factory_->Create( 68 audio_manager, event_handler, params, user_input_monitor); 69 } 70 scoped_refptr<AudioInputController> controller( 71 new AudioInputController(event_handler, NULL, user_input_monitor)); 72 73 controller->task_runner_ = audio_manager->GetTaskRunner(); 74 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))) { 80 controller = NULL; 81 } 82 83 return controller; 84} 85 86// static 87scoped_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); 95 DCHECK(sync_writer); 96 97 if (!params.IsValid() || (params.channels() > kMaxInputChannels)) 98 return NULL; 99 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(); 105 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))) { 111 controller = NULL; 112 } 113 114 return controller; 115} 116 117// static 118scoped_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) { 124 DCHECK(sync_writer); 125 DCHECK(stream); 126 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; 132 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( 139 FROM_HERE, 140 base::Bind(&AudioInputController::DoCreateForStream, controller, 141 stream, false))) { 142 controller = NULL; 143 } 144 145 return controller; 146} 147 148void AudioInputController::Record() { 149 task_runner_->PostTask(FROM_HERE, base::Bind( 150 &AudioInputController::DoRecord, this)); 151} 152 153void AudioInputController::Close(const base::Closure& closed_task) { 154 DCHECK(!closed_task.is_null()); 155 DCHECK(creator_task_runner_->BelongsToCurrentThread()); 156 157 task_runner_->PostTaskAndReply( 158 FROM_HERE, base::Bind(&AudioInputController::DoClose, this), closed_task); 159} 160 161void AudioInputController::SetVolume(double volume) { 162 task_runner_->PostTask(FROM_HERE, base::Bind( 163 &AudioInputController::DoSetVolume, this, volume)); 164} 165 166void AudioInputController::SetAutomaticGainControl(bool enabled) { 167 task_runner_->PostTask(FROM_HERE, base::Bind( 168 &AudioInputController::DoSetAutomaticGainControl, this, enabled)); 169} 170 171void 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 179 // unreliable here. 180 DoCreateForStream(audio_manager->MakeAudioInputStream(params, device_id), 181 true); 182} 183 184void AudioInputController::DoCreateForStream( 185 AudioInputStream* stream_to_control, bool enable_nodata_timer) { 186 DCHECK(task_runner_->BelongsToCurrentThread()); 187 188 DCHECK(!stream_); 189 stream_ = stream_to_control; 190 191 if (!stream_) { 192 handler_->OnError(this, STREAM_CREATE_ERROR); 193 return; 194 } 195 196 if (stream_ && !stream_->Open()) { 197 stream_->Close(); 198 stream_ = NULL; 199 handler_->OnError(this, STREAM_OPEN_ERROR); 200 return; 201 } 202 203 DCHECK(!no_data_timer_.get()); 204 205#if defined(OS_MACOSX) 206 // This is a fix for crbug.com/357501. The timer can trigger when closing 207 // the lid on Macs, which causes more problems than the timer fixes. 208 enable_nodata_timer = false; 209#endif 210 211 if (enable_nodata_timer) { 212 // Create the data timer which will call DoCheckForNoData(). The timer 213 // is started in DoRecord() and restarted in each DoCheckForNoData() 214 // callback. 215 no_data_timer_.reset(new base::Timer( 216 FROM_HERE, base::TimeDelta::FromSeconds(kTimerInitialIntervalSeconds), 217 base::Bind(&AudioInputController::DoCheckForNoData, 218 base::Unretained(this)), false)); 219 } else { 220 DVLOG(1) << "Disabled: timer check for no data."; 221 } 222 223 state_ = CREATED; 224 handler_->OnCreated(this); 225 226 if (user_input_monitor_) { 227 user_input_monitor_->EnableKeyPressMonitoring(); 228 prev_key_down_count_ = user_input_monitor_->GetKeyPressCount(); 229 } 230} 231 232void AudioInputController::DoRecord() { 233 DCHECK(task_runner_->BelongsToCurrentThread()); 234 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime"); 235 236 if (state_ != CREATED) 237 return; 238 239 { 240 base::AutoLock auto_lock(lock_); 241 state_ = RECORDING; 242 } 243 244 if (no_data_timer_) { 245 // Start the data timer. Once |kTimerResetIntervalSeconds| have passed, 246 // a callback to DoCheckForNoData() is made. 247 no_data_timer_->Reset(); 248 } 249 250 stream_->Start(this); 251 handler_->OnRecording(this); 252} 253 254void AudioInputController::DoClose() { 255 DCHECK(task_runner_->BelongsToCurrentThread()); 256 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime"); 257 258 if (state_ == CLOSED) 259 return; 260 261 // Delete the timer on the same thread that created it. 262 no_data_timer_.reset(); 263 264 DoStopCloseAndClearStream(NULL); 265 SetDataIsActive(false); 266 267 if (LowLatencyMode()) 268 sync_writer_->Close(); 269 270 if (user_input_monitor_) 271 user_input_monitor_->DisableKeyPressMonitoring(); 272 273 state_ = CLOSED; 274} 275 276void AudioInputController::DoReportError() { 277 DCHECK(task_runner_->BelongsToCurrentThread()); 278 handler_->OnError(this, STREAM_ERROR); 279} 280 281void AudioInputController::DoSetVolume(double volume) { 282 DCHECK(task_runner_->BelongsToCurrentThread()); 283 DCHECK_GE(volume, 0); 284 DCHECK_LE(volume, 1.0); 285 286 if (state_ != CREATED && state_ != RECORDING) 287 return; 288 289 // Only ask for the maximum volume at first call and use cached value 290 // for remaining function calls. 291 if (!max_volume_) { 292 max_volume_ = stream_->GetMaxVolume(); 293 } 294 295 if (max_volume_ == 0.0) { 296 DLOG(WARNING) << "Failed to access input volume control"; 297 return; 298 } 299 300 // Set the stream volume and scale to a range matched to the platform. 301 stream_->SetVolume(max_volume_ * volume); 302} 303 304void AudioInputController::DoSetAutomaticGainControl(bool enabled) { 305 DCHECK(task_runner_->BelongsToCurrentThread()); 306 DCHECK_NE(state_, RECORDING); 307 308 // Ensure that the AGC state only can be modified before streaming starts. 309 if (state_ != CREATED) 310 return; 311 312 stream_->SetAutomaticGainControl(enabled); 313} 314 315void AudioInputController::DoCheckForNoData() { 316 DCHECK(task_runner_->BelongsToCurrentThread()); 317 318 if (!GetDataIsActive()) { 319 // The data-is-active marker will be false only if it has been more than 320 // one second since a data packet was recorded. This can happen if a 321 // capture device has been removed or disabled. 322 handler_->OnError(this, NO_DATA_ERROR); 323 return; 324 } 325 326 // Mark data as non-active. The flag will be re-enabled in OnData() each 327 // time a data packet is received. Hence, under normal conditions, the 328 // flag will only be disabled during a very short period. 329 SetDataIsActive(false); 330 331 // Restart the timer to ensure that we check the flag again in 332 // |kTimerResetIntervalSeconds|. 333 no_data_timer_->Start( 334 FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds), 335 base::Bind(&AudioInputController::DoCheckForNoData, 336 base::Unretained(this))); 337} 338 339void AudioInputController::OnData(AudioInputStream* stream, 340 const uint8* data, 341 uint32 size, 342 uint32 hardware_delay_bytes, 343 double volume) { 344 { 345 base::AutoLock auto_lock(lock_); 346 if (state_ != RECORDING) 347 return; 348 } 349 350 bool key_pressed = false; 351 if (user_input_monitor_) { 352 size_t current_count = user_input_monitor_->GetKeyPressCount(); 353 key_pressed = current_count != prev_key_down_count_; 354 prev_key_down_count_ = current_count; 355 DVLOG_IF(6, key_pressed) << "Detected keypress."; 356 } 357 358 // Mark data as active to ensure that the periodic calls to 359 // DoCheckForNoData() does not report an error to the event handler. 360 SetDataIsActive(true); 361 362 // Use SyncSocket if we are in a low-latency mode. 363 if (LowLatencyMode()) { 364 sync_writer_->Write(data, size, volume, key_pressed); 365 sync_writer_->UpdateRecordedBytes(hardware_delay_bytes); 366 return; 367 } 368 369 handler_->OnData(this, data, size); 370} 371 372void AudioInputController::OnError(AudioInputStream* stream) { 373 // Handle error on the audio-manager thread. 374 task_runner_->PostTask(FROM_HERE, base::Bind( 375 &AudioInputController::DoReportError, this)); 376} 377 378void AudioInputController::DoStopCloseAndClearStream( 379 base::WaitableEvent* done) { 380 DCHECK(task_runner_->BelongsToCurrentThread()); 381 382 // Allow calling unconditionally and bail if we don't have a stream to close. 383 if (stream_ != NULL) { 384 stream_->Stop(); 385 stream_->Close(); 386 stream_ = NULL; 387 } 388 389 // Should be last in the method, do not touch "this" from here on. 390 if (done != NULL) 391 done->Signal(); 392} 393 394void AudioInputController::SetDataIsActive(bool enabled) { 395 base::subtle::Release_Store(&data_is_active_, enabled); 396} 397 398bool AudioInputController::GetDataIsActive() { 399 return (base::subtle::Acquire_Load(&data_is_active_) != false); 400} 401 402} // namespace media 403