audio_input_controller.cc revision e5d81f57cb97b3b6b7fccc9c5610d21eb81db09d
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 // 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 209 // reproduced. 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; 214 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() 218 // callback. 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)); 223 } else { 224 DVLOG(1) << "Disabled: timer check for no data."; 225 } 226 227 state_ = CREATED; 228 handler_->OnCreated(this); 229 230 if (user_input_monitor_) { 231 user_input_monitor_->EnableKeyPressMonitoring(); 232 prev_key_down_count_ = user_input_monitor_->GetKeyPressCount(); 233 } 234} 235 236void AudioInputController::DoRecord() { 237 DCHECK(task_runner_->BelongsToCurrentThread()); 238 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime"); 239 240 if (state_ != CREATED) 241 return; 242 243 { 244 base::AutoLock auto_lock(lock_); 245 state_ = RECORDING; 246 } 247 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(); 252 } 253 254 stream_->Start(this); 255 handler_->OnRecording(this); 256} 257 258void AudioInputController::DoClose() { 259 DCHECK(task_runner_->BelongsToCurrentThread()); 260 SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime"); 261 262 if (state_ == CLOSED) 263 return; 264 265 // Delete the timer on the same thread that created it. 266 no_data_timer_.reset(); 267 268 DoStopCloseAndClearStream(NULL); 269 SetDataIsActive(false); 270 271 if (LowLatencyMode()) 272 sync_writer_->Close(); 273 274 if (user_input_monitor_) 275 user_input_monitor_->DisableKeyPressMonitoring(); 276 277 state_ = CLOSED; 278} 279 280void AudioInputController::DoReportError() { 281 DCHECK(task_runner_->BelongsToCurrentThread()); 282 handler_->OnError(this, STREAM_ERROR); 283} 284 285void AudioInputController::DoSetVolume(double volume) { 286 DCHECK(task_runner_->BelongsToCurrentThread()); 287 DCHECK_GE(volume, 0); 288 DCHECK_LE(volume, 1.0); 289 290 if (state_ != CREATED && state_ != RECORDING) 291 return; 292 293 // Only ask for the maximum volume at first call and use cached value 294 // for remaining function calls. 295 if (!max_volume_) { 296 max_volume_ = stream_->GetMaxVolume(); 297 } 298 299 if (max_volume_ == 0.0) { 300 DLOG(WARNING) << "Failed to access input volume control"; 301 return; 302 } 303 304 // Set the stream volume and scale to a range matched to the platform. 305 stream_->SetVolume(max_volume_ * volume); 306} 307 308void AudioInputController::DoSetAutomaticGainControl(bool enabled) { 309 DCHECK(task_runner_->BelongsToCurrentThread()); 310 DCHECK_NE(state_, RECORDING); 311 312 // Ensure that the AGC state only can be modified before streaming starts. 313 if (state_ != CREATED) 314 return; 315 316 stream_->SetAutomaticGainControl(enabled); 317} 318 319void AudioInputController::DoCheckForNoData() { 320 DCHECK(task_runner_->BelongsToCurrentThread()); 321 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); 327 return; 328 } 329 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); 334 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))); 341} 342 343void AudioInputController::OnData(AudioInputStream* stream, 344 const uint8* data, 345 uint32 size, 346 uint32 hardware_delay_bytes, 347 double volume) { 348 { 349 base::AutoLock auto_lock(lock_); 350 if (state_ != RECORDING) 351 return; 352 } 353 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."; 360 } 361 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); 365 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); 370 return; 371 } 372 373 handler_->OnData(this, data, size); 374} 375 376void AudioInputController::OnError(AudioInputStream* stream) { 377 // Handle error on the audio-manager thread. 378 task_runner_->PostTask(FROM_HERE, base::Bind( 379 &AudioInputController::DoReportError, this)); 380} 381 382void AudioInputController::DoStopCloseAndClearStream( 383 base::WaitableEvent* done) { 384 DCHECK(task_runner_->BelongsToCurrentThread()); 385 386 // Allow calling unconditionally and bail if we don't have a stream to close. 387 if (stream_ != NULL) { 388 stream_->Stop(); 389 stream_->Close(); 390 stream_ = NULL; 391 } 392 393 // Should be last in the method, do not touch "this" from here on. 394 if (done != NULL) 395 done->Signal(); 396} 397 398void AudioInputController::SetDataIsActive(bool enabled) { 399 base::subtle::Release_Store(&data_is_active_, enabled); 400} 401 402bool AudioInputController::GetDataIsActive() { 403 return (base::subtle::Acquire_Load(&data_is_active_) != false); 404} 405 406} // namespace media 407