blob: e994fc330fc88b3c592b51ea27bb31ec3893726d [file] [log] [blame]
// Copyright 2013 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 "cobalt/media/blink/webaudiosourceprovider_impl.h"
#include <vector>
#include "base/basictypes.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "cobalt/media/base/bind_to_current_loop.h"
#include "third_party/WebKit/public/platform/WebAudioSourceProviderClient.h"
using blink::WebVector;
namespace cobalt {
namespace media {
namespace {
// Simple helper class for Try() locks. Lock is Try()'d on construction and
// must be checked via the locked() attribute. If acquisition was successful
// the lock will be released upon destruction.
// TODO(dalecurtis): This should probably move to base/ if others start using
// this pattern.
class AutoTryLock {
public:
explicit AutoTryLock(base::Lock& lock)
: lock_(lock), acquired_(lock_.Try()) {}
bool locked() const { return acquired_; }
~AutoTryLock() {
if (acquired_) {
lock_.AssertAcquired();
lock_.Release();
}
}
private:
base::Lock& lock_;
const bool acquired_;
DISALLOW_COPY_AND_ASSIGN(AutoTryLock);
};
} // namespace
// TeeFilter is a RenderCallback implementation that allows for a client to get
// a copy of the data being rendered by the |renderer_| on Render(). This class
// also holds on to the necessary audio parameters.
class WebAudioSourceProviderImpl::TeeFilter
: public AudioRendererSink::RenderCallback {
public:
TeeFilter() : renderer_(NULL), channels_(0), sample_rate_(0) {}
~TeeFilter() override {}
void Initialize(AudioRendererSink::RenderCallback* renderer, int channels,
int sample_rate) {
DCHECK(renderer);
renderer_ = renderer;
channels_ = channels;
sample_rate_ = sample_rate;
}
// AudioRendererSink::RenderCallback implementation.
// These are forwarders to |renderer_| and are here to allow for a client to
// get a copy of the rendered audio by SetCopyAudioCallback().
int Render(AudioBus* audio_bus, uint32_t frames_delayed,
uint32_t frames_skipped) OVERRIDE;
void OnRenderError() OVERRIDE;
bool IsInitialized() const { return !!renderer_; }
int channels() const { return channels_; }
int sample_rate() const { return sample_rate_; }
void set_copy_audio_bus_callback(const CopyAudioCB& callback) {
copy_audio_bus_callback_ = callback;
}
private:
AudioRendererSink::RenderCallback* renderer_;
int channels_;
int sample_rate_;
CopyAudioCB copy_audio_bus_callback_;
DISALLOW_COPY_AND_ASSIGN(TeeFilter);
};
WebAudioSourceProviderImpl::WebAudioSourceProviderImpl(
const scoped_refptr<SwitchableAudioRendererSink>& sink)
: volume_(1.0),
state_(kStopped),
client_(NULL),
sink_(sink),
tee_filter_(new TeeFilter()),
weak_factory_(this) {}
WebAudioSourceProviderImpl::~WebAudioSourceProviderImpl() {}
void WebAudioSourceProviderImpl::setClient(
blink::WebAudioSourceProviderClient* client) {
base::AutoLock auto_lock(sink_lock_);
if (client && client != client_) {
// Detach the audio renderer from normal playback.
sink_->Stop();
// The client will now take control by calling provideInput() periodically.
client_ = client;
set_format_cb_ = BindToCurrentLoop(base::Bind(
&WebAudioSourceProviderImpl::OnSetFormat, weak_factory_.GetWeakPtr()));
// If |tee_filter_| is Initialize()d - then run |set_format_cb_| to send
// |client_| the current format info. Otherwise |set_format_cb_| will get
// called when Initialize() is called. Note: Always using |set_format_cb_|
// ensures we have the same locking order when calling into |client_|.
if (tee_filter_->IsInitialized())
base::ResetAndReturn(&set_format_cb_).Run();
} else if (!client && client_) {
// Restore normal playback.
client_ = NULL;
sink_->SetVolume(volume_);
if (state_ >= kStarted) sink_->Start();
if (state_ >= kPlaying) sink_->Play();
}
}
void WebAudioSourceProviderImpl::provideInput(
const WebVector<float*>& audio_data, size_t number_of_frames) {
if (!bus_wrapper_ ||
static_cast<size_t>(bus_wrapper_->channels()) != audio_data.size()) {
bus_wrapper_ = AudioBus::CreateWrapper(static_cast<int>(audio_data.size()));
}
const int incoming_number_of_frames = static_cast<int>(number_of_frames);
bus_wrapper_->set_frames(incoming_number_of_frames);
for (size_t i = 0; i < audio_data.size(); ++i)
bus_wrapper_->SetChannelData(static_cast<int>(i), audio_data[i]);
// Use a try lock to avoid contention in the real-time audio thread.
AutoTryLock auto_try_lock(sink_lock_);
if (!auto_try_lock.locked() || state_ != kPlaying) {
// Provide silence if we failed to acquire the lock or the source is not
// running.
bus_wrapper_->Zero();
return;
}
DCHECK(client_);
DCHECK_EQ(tee_filter_->channels(), bus_wrapper_->channels());
const int frames = tee_filter_->Render(bus_wrapper_.get(), 0, 0);
if (frames < incoming_number_of_frames)
bus_wrapper_->ZeroFramesPartial(frames, incoming_number_of_frames - frames);
bus_wrapper_->Scale(volume_);
}
void WebAudioSourceProviderImpl::Initialize(const AudioParameters& params,
RenderCallback* renderer) {
base::AutoLock auto_lock(sink_lock_);
DCHECK_EQ(state_, kStopped);
tee_filter_->Initialize(renderer, params.channels(), params.sample_rate());
sink_->Initialize(params, tee_filter_.get());
if (!set_format_cb_.is_null()) base::ResetAndReturn(&set_format_cb_).Run();
}
void WebAudioSourceProviderImpl::Start() {
base::AutoLock auto_lock(sink_lock_);
DCHECK(tee_filter_);
DCHECK_EQ(state_, kStopped);
state_ = kStarted;
if (!client_) sink_->Start();
}
void WebAudioSourceProviderImpl::Stop() {
base::AutoLock auto_lock(sink_lock_);
state_ = kStopped;
if (!client_) sink_->Stop();
}
void WebAudioSourceProviderImpl::Play() {
base::AutoLock auto_lock(sink_lock_);
DCHECK_EQ(state_, kStarted);
state_ = kPlaying;
if (!client_) sink_->Play();
}
void WebAudioSourceProviderImpl::Pause() {
base::AutoLock auto_lock(sink_lock_);
DCHECK(state_ == kPlaying || state_ == kStarted);
state_ = kStarted;
if (!client_) sink_->Pause();
}
bool WebAudioSourceProviderImpl::SetVolume(double volume) {
base::AutoLock auto_lock(sink_lock_);
volume_ = volume;
if (!client_) sink_->SetVolume(volume);
return true;
}
media::OutputDeviceInfo WebAudioSourceProviderImpl::GetOutputDeviceInfo() {
base::AutoLock auto_lock(sink_lock_);
return sink_->GetOutputDeviceInfo();
}
bool WebAudioSourceProviderImpl::CurrentThreadIsRenderingThread() {
NOTIMPLEMENTED();
return false;
}
void WebAudioSourceProviderImpl::SwitchOutputDevice(
const std::string& device_id, const url::Origin& security_origin,
const OutputDeviceStatusCB& callback) {
base::AutoLock auto_lock(sink_lock_);
if (client_)
callback.Run(media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
else
sink_->SwitchOutputDevice(device_id, security_origin, callback);
}
void WebAudioSourceProviderImpl::SetCopyAudioCallback(
const CopyAudioCB& callback) {
DCHECK(!callback.is_null());
// Use |sink_lock_| to protect |tee_filter_| too since they go in lockstep.
base::AutoLock auto_lock(sink_lock_);
DCHECK(tee_filter_);
tee_filter_->set_copy_audio_bus_callback(callback);
}
void WebAudioSourceProviderImpl::ClearCopyAudioCallback() {
DCHECK(tee_filter_);
tee_filter_->set_copy_audio_bus_callback(CopyAudioCB());
}
int WebAudioSourceProviderImpl::RenderForTesting(AudioBus* audio_bus) {
return tee_filter_->Render(audio_bus, 0, 0);
}
void WebAudioSourceProviderImpl::OnSetFormat() {
base::AutoLock auto_lock(sink_lock_);
if (!client_) return;
// Inform Blink about the audio stream format.
client_->setFormat(tee_filter_->channels(), tee_filter_->sample_rate());
}
int WebAudioSourceProviderImpl::TeeFilter::Render(AudioBus* audio_bus,
uint32_t frames_delayed,
uint32_t frames_skipped) {
DCHECK(IsInitialized());
const int num_rendered_frames =
renderer_->Render(audio_bus, frames_delayed, frames_skipped);
if (!copy_audio_bus_callback_.is_null()) {
std::unique_ptr<AudioBus> bus_copy =
AudioBus::Create(audio_bus->channels(), audio_bus->frames());
audio_bus->CopyTo(bus_copy.get());
copy_audio_bus_callback_.Run(std::move(bus_copy), frames_delayed,
sample_rate_);
}
return num_rendered_frames;
}
void WebAudioSourceProviderImpl::TeeFilter::OnRenderError() {
DCHECK(IsInitialized());
renderer_->OnRenderError();
}
} // namespace media
} // namespace cobalt