blob: 99bb420e89553a84e6292a2fa74d404b5eed91eb [file] [log] [blame]
// 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_controller.h"
#include "base/bind.h"
#include "base/threading/thread_restrictions.h"
#include "media/base/limits.h"
namespace {
const int kMaxInputChannels = 2;
const int kTimerResetIntervalSeconds = 1;
#if defined(OS_IOS)
// The first callback on iOS is received after the current background
// audio has faded away.
const int kTimerInitialIntervalSeconds = 4;
#else
const int kTimerInitialIntervalSeconds = 1;
#endif // defined(OS_IOS)
}
namespace media {
// static
AudioInputController::Factory* AudioInputController::factory_ = NULL;
AudioInputController::AudioInputController(EventHandler* handler,
SyncWriter* sync_writer)
: creator_loop_(base::MessageLoopProxy::current()),
handler_(handler),
stream_(NULL),
data_is_active_(false),
state_(kEmpty),
sync_writer_(sync_writer),
max_volume_(0.0) {
DCHECK(creator_loop_);
}
AudioInputController::~AudioInputController() {
DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
}
// static
scoped_refptr<AudioInputController> AudioInputController::Create(
AudioManager* audio_manager,
EventHandler* event_handler,
const AudioParameters& params) {
DCHECK(audio_manager);
if (!params.IsValid() || (params.channels() > kMaxInputChannels))
return NULL;
if (factory_)
return factory_->Create(audio_manager, event_handler, params);
scoped_refptr<AudioInputController> controller(new AudioInputController(
event_handler, NULL));
controller->message_loop_ = audio_manager->GetMessageLoop();
// Create and open a new audio input stream from the existing
// audio-device thread. Use the default audio-input device.
std::string device_id = AudioManagerBase::kDefaultDeviceId;
if (!controller->message_loop_->PostTask(FROM_HERE,
base::Bind(&AudioInputController::DoCreate, controller,
base::Unretained(audio_manager), params, device_id))) {
controller = NULL;
}
return controller;
}
// static
scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
AudioManager* audio_manager,
EventHandler* event_handler,
const AudioParameters& params,
const std::string& device_id,
SyncWriter* sync_writer) {
DCHECK(audio_manager);
DCHECK(sync_writer);
if (!params.IsValid() || (params.channels() > kMaxInputChannels))
return NULL;
// Create the AudioInputController object and ensure that it runs on
// the audio-manager thread.
scoped_refptr<AudioInputController> controller(new AudioInputController(
event_handler, sync_writer));
controller->message_loop_ = audio_manager->GetMessageLoop();
// Create and open a new audio input stream from the existing
// audio-device thread. Use the provided audio-input device.
if (!controller->message_loop_->PostTask(FROM_HERE,
base::Bind(&AudioInputController::DoCreate, controller,
base::Unretained(audio_manager), params, device_id))) {
controller = NULL;
}
return controller;
}
void AudioInputController::Record() {
message_loop_->PostTask(FROM_HERE, base::Bind(
&AudioInputController::DoRecord, this));
}
void AudioInputController::Close(const base::Closure& closed_task) {
DCHECK(!closed_task.is_null());
DCHECK(creator_loop_->BelongsToCurrentThread());
message_loop_->PostTaskAndReply(
FROM_HERE, base::Bind(&AudioInputController::DoClose, this), closed_task);
}
void AudioInputController::SetVolume(double volume) {
message_loop_->PostTask(FROM_HERE, base::Bind(
&AudioInputController::DoSetVolume, this, volume));
}
void AudioInputController::SetAutomaticGainControl(bool enabled) {
message_loop_->PostTask(FROM_HERE, base::Bind(
&AudioInputController::DoSetAutomaticGainControl, this, enabled));
}
void AudioInputController::DoCreate(AudioManager* audio_manager,
const AudioParameters& params,
const std::string& device_id) {
DCHECK(message_loop_->BelongsToCurrentThread());
stream_ = audio_manager->MakeAudioInputStream(params, device_id);
if (!stream_) {
// TODO(satish): Define error types.
handler_->OnError(this, 0);
return;
}
if (stream_ && !stream_->Open()) {
stream_->Close();
stream_ = NULL;
// TODO(satish): Define error types.
handler_->OnError(this, 0);
return;
}
DCHECK(!no_data_timer_.get());
// Create the data timer which will call DoCheckForNoData(). The timer
// is started in DoRecord() and restarted in each DoCheckForNoData() callback.
no_data_timer_.reset(new base::Timer(
FROM_HERE, base::TimeDelta::FromSeconds(kTimerInitialIntervalSeconds),
base::Bind(&AudioInputController::DoCheckForNoData,
base::Unretained(this)), false));
state_ = kCreated;
handler_->OnCreated(this);
}
void AudioInputController::DoRecord() {
DCHECK(message_loop_->BelongsToCurrentThread());
if (state_ != kCreated)
return;
{
base::AutoLock auto_lock(lock_);
state_ = kRecording;
}
// Start the data timer. Once |kTimerResetIntervalSeconds| have passed,
// a callback to DoCheckForNoData() is made.
no_data_timer_->Reset();
stream_->Start(this);
handler_->OnRecording(this);
}
void AudioInputController::DoClose() {
DCHECK(message_loop_->BelongsToCurrentThread());
// Delete the timer on the same thread that created it.
no_data_timer_.reset();
if (state_ != kClosed) {
DoStopCloseAndClearStream(NULL);
SetDataIsActive(false);
if (LowLatencyMode()) {
sync_writer_->Close();
}
state_ = kClosed;
}
}
void AudioInputController::DoReportError(int code) {
DCHECK(message_loop_->BelongsToCurrentThread());
handler_->OnError(this, code);
}
void AudioInputController::DoSetVolume(double volume) {
DCHECK(message_loop_->BelongsToCurrentThread());
DCHECK_GE(volume, 0);
DCHECK_LE(volume, 1.0);
if (state_ != kCreated && state_ != kRecording)
return;
// Only ask for the maximum volume at first call and use cached value
// for remaining function calls.
if (!max_volume_) {
max_volume_ = stream_->GetMaxVolume();
}
if (max_volume_ == 0.0) {
DLOG(WARNING) << "Failed to access input volume control";
return;
}
// Set the stream volume and scale to a range matched to the platform.
stream_->SetVolume(max_volume_ * volume);
}
void AudioInputController::DoSetAutomaticGainControl(bool enabled) {
DCHECK(message_loop_->BelongsToCurrentThread());
DCHECK_NE(state_, kRecording);
// Ensure that the AGC state only can be modified before streaming starts.
if (state_ != kCreated || state_ == kRecording)
return;
stream_->SetAutomaticGainControl(enabled);
}
void AudioInputController::DoCheckForNoData() {
DCHECK(message_loop_->BelongsToCurrentThread());
if (!GetDataIsActive()) {
// The data-is-active marker will be false only if it has been more than
// one second since a data packet was recorded. This can happen if a
// capture device has been removed or disabled.
handler_->OnError(this, 0);
return;
}
// Mark data as non-active. The flag will be re-enabled in OnData() each
// time a data packet is received. Hence, under normal conditions, the
// flag will only be disabled during a very short period.
SetDataIsActive(false);
// Restart the timer to ensure that we check the flag again in
// |kTimerResetIntervalSeconds|.
no_data_timer_->Start(
FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
base::Bind(&AudioInputController::DoCheckForNoData,
base::Unretained(this)));
}
void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
uint32 size, uint32 hardware_delay_bytes,
double volume) {
{
base::AutoLock auto_lock(lock_);
if (state_ != kRecording)
return;
}
// Mark data as active to ensure that the periodic calls to
// DoCheckForNoData() does not report an error to the event handler.
SetDataIsActive(true);
// Use SyncSocket if we are in a low-latency mode.
if (LowLatencyMode()) {
sync_writer_->Write(data, size, volume);
sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
return;
}
handler_->OnData(this, data, size);
}
void AudioInputController::OnClose(AudioInputStream* stream) {
DVLOG(1) << "AudioInputController::OnClose()";
// TODO(satish): Sometimes the device driver closes the input stream without
// us asking for it (may be if the device was unplugged?). Check how to handle
// such cases here.
}
void AudioInputController::OnError(AudioInputStream* stream, int code) {
// Handle error on the audio-manager thread.
message_loop_->PostTask(FROM_HERE, base::Bind(
&AudioInputController::DoReportError, this, code));
}
void AudioInputController::DoStopCloseAndClearStream(
base::WaitableEvent *done) {
DCHECK(message_loop_->BelongsToCurrentThread());
// Allow calling unconditionally and bail if we don't have a stream to close.
if (stream_ != NULL) {
stream_->Stop();
stream_->Close();
stream_ = NULL;
}
// Should be last in the method, do not touch "this" from here on.
if (done != NULL)
done->Signal();
}
void AudioInputController::SetDataIsActive(bool enabled) {
base::subtle::Release_Store(&data_is_active_, enabled);
}
bool AudioInputController::GetDataIsActive() {
return (base::subtle::Acquire_Load(&data_is_active_) != false);
}
} // namespace media