// Copyright (c) 2011 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 "content/renderer/media/audio_renderer_impl.h" #include #include "content/common/audio_messages.h" #include "content/renderer/render_thread.h" #include "content/renderer/render_view.h" #include "media/base/filter_host.h" namespace { // We will try to fill 200 ms worth of audio samples in each packet. A round // trip latency for IPC messages are typically 10 ms, this should give us // plenty of time to avoid clicks. const int kMillisecondsPerPacket = 200; // We have at most 3 packets in browser, i.e. 600 ms. This is a reasonable // amount to avoid clicks. const int kPacketsInBuffer = 3; } // namespace AudioRendererImpl::AudioRendererImpl(AudioMessageFilter* filter) : AudioRendererBase(), bytes_per_second_(0), filter_(filter), stream_id_(0), shared_memory_(NULL), shared_memory_size_(0), io_loop_(filter->message_loop()), stopped_(false), pending_request_(false), prerolling_(false), preroll_bytes_(0) { DCHECK(io_loop_); } AudioRendererImpl::~AudioRendererImpl() { } base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) { if (bytes_per_second_) { return base::TimeDelta::FromMicroseconds( base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_); } return base::TimeDelta(); } bool AudioRendererImpl::OnInitialize(const media::AudioDecoderConfig& config) { AudioParameters params(config); params.format = AudioParameters::AUDIO_PCM_LINEAR; bytes_per_second_ = params.GetBytesPerSecond(); io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::CreateStreamTask, params)); return true; } void AudioRendererImpl::OnStop() { base::AutoLock auto_lock(lock_); if (stopped_) return; stopped_ = true; // We should never touch |io_loop_| after being stopped, so post our final // task to clean up. io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::DestroyTask)); } void AudioRendererImpl::ConsumeAudioSamples( scoped_refptr buffer_in) { base::AutoLock auto_lock(lock_); if (stopped_) return; // TODO(hclam): handle end of stream here. // Use the base class to queue the buffer. AudioRendererBase::ConsumeAudioSamples(buffer_in); // Post a task to render thread to notify a packet reception. io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::NotifyPacketReadyTask)); } void AudioRendererImpl::SetPlaybackRate(float rate) { DCHECK(rate >= 0.0f); base::AutoLock auto_lock(lock_); // Handle the case where we stopped due to |io_loop_| dying. if (stopped_) { AudioRendererBase::SetPlaybackRate(rate); return; } // We have two cases here: // Play: GetPlaybackRate() == 0.0 && rate != 0.0 // Pause: GetPlaybackRate() != 0.0 && rate == 0.0 if (GetPlaybackRate() == 0.0f && rate != 0.0f) { io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::PlayTask)); } else if (GetPlaybackRate() != 0.0f && rate == 0.0f) { // Pause is easy, we can always pause. io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::PauseTask)); } AudioRendererBase::SetPlaybackRate(rate); // If we are playing, give a kick to try fulfilling the packet request as // the previous packet request may be stalled by a pause. if (rate > 0.0f) { io_loop_->PostTask( FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::NotifyPacketReadyTask)); } } void AudioRendererImpl::Pause(media::FilterCallback* callback) { AudioRendererBase::Pause(callback); base::AutoLock auto_lock(lock_); if (stopped_) return; io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::PauseTask)); } void AudioRendererImpl::Seek(base::TimeDelta time, const media::FilterStatusCB& cb) { AudioRendererBase::Seek(time, cb); base::AutoLock auto_lock(lock_); if (stopped_) return; io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::SeekTask)); } void AudioRendererImpl::Play(media::FilterCallback* callback) { AudioRendererBase::Play(callback); base::AutoLock auto_lock(lock_); if (stopped_) return; if (GetPlaybackRate() != 0.0f) { io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::PlayTask)); } else { io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &AudioRendererImpl::PauseTask)); } } void AudioRendererImpl::SetVolume(float volume) { base::AutoLock auto_lock(lock_); if (stopped_) return; io_loop_->PostTask(FROM_HERE, NewRunnableMethod( this, &AudioRendererImpl::SetVolumeTask, volume)); } void AudioRendererImpl::OnCreated(base::SharedMemoryHandle handle, uint32 length) { DCHECK(MessageLoop::current() == io_loop_); base::AutoLock auto_lock(lock_); if (stopped_) return; shared_memory_.reset(new base::SharedMemory(handle, false)); shared_memory_->Map(length); shared_memory_size_ = length; } void AudioRendererImpl::OnLowLatencyCreated(base::SharedMemoryHandle, base::SyncSocket::Handle, uint32) { // AudioRenderer should not have a low-latency audio channel. NOTREACHED(); } void AudioRendererImpl::OnRequestPacket(AudioBuffersState buffers_state) { DCHECK(MessageLoop::current() == io_loop_); { base::AutoLock auto_lock(lock_); DCHECK(!pending_request_); pending_request_ = true; request_buffers_state_ = buffers_state; } // Try to fill in the fulfill the packet request. NotifyPacketReadyTask(); } void AudioRendererImpl::OnStateChanged(AudioStreamState state) { DCHECK(MessageLoop::current() == io_loop_); base::AutoLock auto_lock(lock_); if (stopped_) return; switch (state) { case kAudioStreamError: // We receive this error if we counter an hardware error on the browser // side. We can proceed with ignoring the audio stream. // TODO(hclam): We need more handling of these kind of error. For example // re-try creating the audio output stream on the browser side or fail // nicely and report to demuxer that the whole audio stream is discarded. host()->DisableAudioRenderer(); break; // TODO(hclam): handle these events. case kAudioStreamPlaying: case kAudioStreamPaused: break; default: NOTREACHED(); break; } } void AudioRendererImpl::OnVolume(double volume) { // TODO(hclam): decide whether we need to report the current volume to // pipeline. } void AudioRendererImpl::CreateStreamTask(const AudioParameters& audio_params) { DCHECK(MessageLoop::current() == io_loop_); base::AutoLock auto_lock(lock_); if (stopped_) return; // Make sure we don't call create more than once. DCHECK_EQ(0, stream_id_); stream_id_ = filter_->AddDelegate(this); io_loop_->AddDestructionObserver(this); AudioParameters params_to_send(audio_params); // Let the browser choose packet size. params_to_send.samples_per_packet = 0; filter_->Send(new AudioHostMsg_CreateStream( 0, stream_id_, params_to_send, false)); } void AudioRendererImpl::PlayTask() { DCHECK(MessageLoop::current() == io_loop_); filter_->Send(new AudioHostMsg_PlayStream(0, stream_id_)); } void AudioRendererImpl::PauseTask() { DCHECK(MessageLoop::current() == io_loop_); filter_->Send(new AudioHostMsg_PauseStream(0, stream_id_)); } void AudioRendererImpl::SeekTask() { DCHECK(MessageLoop::current() == io_loop_); // We have to pause the audio stream before we can flush. filter_->Send(new AudioHostMsg_PauseStream(0, stream_id_)); filter_->Send(new AudioHostMsg_FlushStream(0, stream_id_)); } void AudioRendererImpl::DestroyTask() { DCHECK(MessageLoop::current() == io_loop_); // Make sure we don't call destroy more than once. DCHECK_NE(0, stream_id_); filter_->RemoveDelegate(stream_id_); filter_->Send(new AudioHostMsg_CloseStream(0, stream_id_)); io_loop_->RemoveDestructionObserver(this); stream_id_ = 0; } void AudioRendererImpl::SetVolumeTask(double volume) { DCHECK(MessageLoop::current() == io_loop_); base::AutoLock auto_lock(lock_); if (stopped_) return; filter_->Send(new AudioHostMsg_SetVolume(0, stream_id_, volume)); } void AudioRendererImpl::NotifyPacketReadyTask() { DCHECK(MessageLoop::current() == io_loop_); base::AutoLock auto_lock(lock_); if (stopped_) return; if (pending_request_ && GetPlaybackRate() > 0.0f) { DCHECK(shared_memory_.get()); // Adjust the playback delay. base::Time current_time = base::Time::Now(); base::TimeDelta request_delay = ConvertToDuration(request_buffers_state_.total_bytes()); // Add message delivery delay. if (current_time > request_buffers_state_.timestamp) { base::TimeDelta receive_latency = current_time - request_buffers_state_.timestamp; // If the receive latency is too much it may offset all the delay. if (receive_latency >= request_delay) { request_delay = base::TimeDelta(); } else { request_delay -= receive_latency; } } // Finally we need to adjust the delay according to playback rate. if (GetPlaybackRate() != 1.0f) { request_delay = base::TimeDelta::FromMicroseconds( static_cast(ceil(request_delay.InMicroseconds() * GetPlaybackRate()))); } uint32 filled = FillBuffer(static_cast(shared_memory_->memory()), shared_memory_size_, request_delay, request_buffers_state_.pending_bytes == 0); pending_request_ = false; // Then tell browser process we are done filling into the buffer. filter_->Send(new AudioHostMsg_NotifyPacketReady(0, stream_id_, filled)); } } void AudioRendererImpl::WillDestroyCurrentMessageLoop() { DCHECK(MessageLoop::current() == io_loop_); // We treat the IO loop going away the same as stopping. base::AutoLock auto_lock(lock_); if (stopped_) return; stopped_ = true; DestroyTask(); }