media/filters/audio_renderer_impl.cc - Issue 17315021: Refactored DataBuffer to use unix_hacker style methods.

Unified Diff: media/filters/audio_renderer_impl.cc

Issue 17315021: Refactored DataBuffer to use unix_hacker style methods. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Fixed accidental renaming of test cases. Created 7 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« media/base/seekable_buffer.cc ('K') | « media/filters/audio_renderer_algorithm.cc ('k') | media/filters/audio_renderer_impl_unittest.cc » ('j') | webkit/plugins/ppapi/content_decryptor_delegate.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: media/filters/audio_renderer_impl.cc

diff --git a/media/filters/audio_renderer_impl.cc b/media/filters/audio_renderer_impl.cc

index 8a4cd23eacba9c18dff08b873942af8fac8bf0a2..465c50754d5617cac20ddb2ecf92d35738016f74 100644

--- a/media/filters/audio_renderer_impl.cc

+++ b/media/filters/audio_renderer_impl.cc

@@ -40,15 +40,14 @@ void HistogramRendererEvent(AudioRendererEvent event) {

AudioRendererImpl::AudioRendererImpl(

const scoped_refptr<base::MessageLoopProxy>& message_loop,

- media::AudioRendererSink* sink,

- ScopedVector<AudioDecoder> decoders,

+ media::AudioRendererSink* sink, ScopedVector<AudioDecoder> decoders,

const SetDecryptorReadyCB& set_decryptor_ready_cb,

bool increase_preroll_on_underflow)

: message_loop_(message_loop),

weak_factory_(this),

sink_(sink),

- decoder_selector_(new AudioDecoderSelector(

- message_loop, decoders.Pass(), set_decryptor_ready_cb)),

+ decoder_selector_(new AudioDecoderSelector(message_loop, decoders.Pass(),

+ set_decryptor_ready_cb)),

now_cb_(base::Bind(&base::TimeTicks::Now)),

state_(kUninitialized),

sink_playing_(false),

@@ -60,8 +59,7 @@ AudioRendererImpl::AudioRendererImpl(

underflow_disabled_(false),

increase_preroll_on_underflow_(increase_preroll_on_underflow),

preroll_aborted_(false),

- actual_frames_per_buffer_(0) {

+ actual_frames_per_buffer_(0) {}

AudioRendererImpl::~AudioRendererImpl() {

// Stop() should have been called and |algorithm_| should have been destroyed.

@@ -104,14 +102,13 @@ void AudioRendererImpl::Pause(const base::Closure& callback) {

{

base::AutoLock auto_lock(lock_);

- DCHECK(state_ == kPlaying || state_ == kUnderflow ||

- state_ == kRebuffering) << "state_ == " << state_;

+ DCHECK(state_ == kPlaying || state_ == kUnderflow || state_ == kRebuffering)

+ << "state_ == " << state_;

pause_cb_ = callback;

state_ = kPaused;

// Pause only when we've completed our pending read.

- if (!pending_read_)

- base::ResetAndReturn(&pause_cb_).Run();

+ if (!pending_read_) base::ResetAndReturn(&pause_cb_).Run();

}

DoPause();

@@ -129,8 +126,8 @@ void AudioRendererImpl::Flush(const base::Closure& callback) {

DCHECK(message_loop_->BelongsToCurrentThread());

if (decrypting_demuxer_stream_) {

- decrypting_demuxer_stream_->Reset(base::Bind(

- &AudioRendererImpl::ResetDecoder, weak_this_, callback));

+ decrypting_demuxer_stream_->Reset(

+ base::Bind(&AudioRendererImpl::ResetDecoder, weak_this_, callback));

return;

}

@@ -195,14 +192,11 @@ void AudioRendererImpl::Preroll(base::TimeDelta time,

AttemptRead_Locked();

}

-void AudioRendererImpl::Initialize(DemuxerStream* stream,

- const PipelineStatusCB& init_cb,

- const StatisticsCB& statistics_cb,

- const base::Closure& underflow_cb,

- const TimeCB& time_cb,

- const base::Closure& ended_cb,

- const base::Closure& disabled_cb,

- const PipelineStatusCB& error_cb) {

+void AudioRendererImpl::Initialize(

+ DemuxerStream* stream, const PipelineStatusCB& init_cb,

+ const StatisticsCB& statistics_cb, const base::Closure& underflow_cb,

+ const TimeCB& time_cb, const base::Closure& ended_cb,

+ const base::Closure& disabled_cb, const PipelineStatusCB& error_cb) {

DCHECK(message_loop_->BelongsToCurrentThread());

DCHECK(stream);

DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);

@@ -226,8 +220,7 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream,

error_cb_ = error_cb;

decoder_selector_->SelectAudioDecoder(

- stream,

- statistics_cb,

+ stream, statistics_cb,

base::Bind(&AudioRendererImpl::OnDecoderSelected, weak_this_));

}

@@ -310,8 +303,7 @@ void AudioRendererImpl::SetVolume(float volume) {

}

void AudioRendererImpl::DecodedAudioReady(

- AudioDecoder::Status status,

- const scoped_refptr<DataBuffer>& buffer) {

+ AudioDecoder::Status status, const scoped_refptr<DataBuffer>& buffer) {

DCHECK(message_loop_->BelongsToCurrentThread());

base::AutoLock auto_lock(lock_);

@@ -348,21 +340,19 @@ void AudioRendererImpl::DecodedAudioReady(

while (splicer_->HasNextBuffer())

need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());

- if (!need_another_buffer && !CanRead_Locked())

- return;

+ if (!need_another_buffer && !CanRead_Locked()) return;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

AttemptRead_Locked();

}

bool AudioRendererImpl::HandleSplicerBuffer(

const scoped_refptr<DataBuffer>& buffer) {

- if (buffer->IsEndOfStream()) {

+ if (buffer->end_of_stream()) {

received_end_of_stream_ = true;

// Transition to kPlaying if we are currently handling an underflow since

// no more data will be arriving.

- if (state_ == kUnderflow || state_ == kRebuffering)

- state_ = kPlaying;

+ if (state_ == kUnderflow || state_ == kRebuffering) state_ = kPlaying;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

}

switch (state_) {

@@ -370,19 +360,16 @@ bool AudioRendererImpl::HandleSplicerBuffer(

NOTREACHED();

return false;

case kPaused:

- if (!buffer->IsEndOfStream())

- algorithm_->EnqueueBuffer(buffer);

+ if (!buffer->end_of_stream()) algorithm_->EnqueueBuffer(buffer);

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

DCHECK(!pending_read_);

base::ResetAndReturn(&pause_cb_).Run();

return false;

case kPrerolling:

- if (IsBeforePrerollTime(buffer))

- return true;

+ if (IsBeforePrerollTime(buffer)) return true;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

- if (!buffer->IsEndOfStream()) {

+ if (!buffer->end_of_stream()) {

algorithm_->EnqueueBuffer(buffer);

- if (!algorithm_->IsQueueFull())

- return false;

+ if (!algorithm_->IsQueueFull()) return false;

}

state_ = kPaused;

base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);

@@ -390,8 +377,7 @@ bool AudioRendererImpl::HandleSplicerBuffer(

case kPlaying:

case kUnderflow:

case kRebuffering:

- if (!buffer->IsEndOfStream())

- algorithm_->EnqueueBuffer(buffer);

+ if (!buffer->end_of_stream()) algorithm_->EnqueueBuffer(buffer);

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

return false;

case kStopped:

return false;

@@ -408,8 +394,7 @@ void AudioRendererImpl::AttemptRead_Locked() {

DCHECK(message_loop_->BelongsToCurrentThread());

lock_.AssertAcquired();

- if (!CanRead_Locked())

- return;

+ if (!CanRead_Locked()) return;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

pending_read_ = true;

decoder_->Read(base::Bind(&AudioRendererImpl::DecodedAudioReady, weak_this_));

@@ -432,7 +417,7 @@ bool AudioRendererImpl::CanRead_Locked() {

}

return !pending_read_ && !received_end_of_stream_ &&

- !algorithm_->IsQueueFull();

+ !algorithm_->IsQueueFull();

}

void AudioRendererImpl::SetPlaybackRate(float playback_rate) {

@@ -455,8 +440,10 @@ void AudioRendererImpl::SetPlaybackRate(float playback_rate) {

bool AudioRendererImpl::IsBeforePrerollTime(

const scoped_refptr<DataBuffer>& buffer) {

- return (state_ == kPrerolling) && buffer.get() && !buffer->IsEndOfStream() &&

- (buffer->GetTimestamp() + buffer->GetDuration()) < preroll_timestamp_;

+ return (state_ == kPrerolling) && buffer.get() &&

+ !buffer->end_of_stream() &&

+ (buffer->timestamp() + buffer->duration()) <

+ preroll_timestamp_;

}

int AudioRendererImpl::Render(AudioBus* audio_bus,

@@ -467,25 +454,23 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,

actual_frames_per_buffer_ = audio_bus->frames();

}

- int frames_filled = FillBuffer(

- audio_buffer_.get(), audio_bus->frames(), audio_delay_milliseconds);

+ int frames_filled = FillBuffer(audio_buffer_.get(), audio_bus->frames(),

+ audio_delay_milliseconds);

DCHECK_LE(frames_filled, actual_frames_per_buffer_);

// Deinterleave audio data into the output bus.

- audio_bus->FromInterleaved(

- audio_buffer_.get(), frames_filled,

- audio_parameters_.bits_per_sample() / 8);

+ audio_bus->FromInterleaved(audio_buffer_.get(), frames_filled,

+ audio_parameters_.bits_per_sample() / 8);

return frames_filled;

}

-uint32 AudioRendererImpl::FillBuffer(uint8* dest,

- uint32 requested_frames,

+uint32 AudioRendererImpl::FillBuffer(uint8* dest, uint32 requested_frames,

int audio_delay_milliseconds) {

base::TimeDelta current_time = kNoTimestamp();

base::TimeDelta max_time = kNoTimestamp();

- base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(

- audio_delay_milliseconds);

+ base::TimeDelta playback_delay =

+ base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);

size_t frames_written = 0;

base::Closure underflow_cb;

@@ -493,19 +478,15 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,

base::AutoLock auto_lock(lock_);

// Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.

- if (!algorithm_)

- return 0;

+ if (!algorithm_) return 0;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

float playback_rate = algorithm_->playback_rate();

- if (playback_rate == 0)

- return 0;

+ if (playback_rate == 0) return 0;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

- if (state_ == kRebuffering && algorithm_->IsQueueFull())

- state_ = kPlaying;

+ if (state_ == kRebuffering && algorithm_->IsQueueFull()) state_ = kPlaying;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

// Mute audio by returning 0 when not playing.

- if (state_ != kPlaying)

- return 0;

+ if (state_ != kPlaying) return 0;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

// We use the following conditions to determine end of playback:

// 1) Algorithm can not fill the audio callback buffer

@@ -542,8 +523,8 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,

}

if (CanRead_Locked()) {

- message_loop_->PostTask(FROM_HERE, base::Bind(

- &AudioRendererImpl::AttemptRead, weak_this_));

+ message_loop_->PostTask(

+ FROM_HERE, base::Bind(&AudioRendererImpl::AttemptRead, weak_this_));

}

// The |audio_time_buffered_| is the ending timestamp of the last frame

@@ -553,8 +534,8 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,

if (audio_time_buffered_ != kNoTimestamp()) {

// Adjust the delay according to playback rate.

base::TimeDelta adjusted_playback_delay =

- base::TimeDelta::FromMicroseconds(ceil(

- playback_delay.InMicroseconds() * playback_rate));

+ base::TimeDelta::FromMicroseconds(

+ ceil(playback_delay.InMicroseconds() * playback_rate));

base::TimeDelta previous_time = current_time_;

current_time_ = audio_time_buffered_ - adjusted_playback_delay;

@@ -583,16 +564,14 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,

max_time = algorithm_->GetTime();

audio_time_buffered_ = max_time;

- UpdateEarliestEndTime_Locked(

- frames_written, playback_delay, now_cb_.Run());

+ UpdateEarliestEndTime_Locked(frames_written, playback_delay, now_cb_.Run());

}

if (current_time != kNoTimestamp() && max_time != kNoTimestamp()) {

time_cb_.Run(current_time, max_time);

}

- if (!underflow_cb.is_null())

- underflow_cb.Run();

+ if (!underflow_cb.is_null()) underflow_cb.Run();

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

return frames_written;

}

@@ -600,8 +579,7 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,

void AudioRendererImpl::UpdateEarliestEndTime_Locked(

int frames_filled, const base::TimeDelta& playback_delay,

const base::TimeTicks& time_now) {

- if (frames_filled <= 0)

- return;

+ if (frames_filled <= 0) return;

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

base::TimeDelta predicted_play_time = base::TimeDelta::FromMicroseconds(

static_cast<float>(frames_filled) * base::Time::kMicrosecondsPerSecond /

@@ -628,8 +606,7 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {

NOTREACHED();

return;

case kPaused:

- if (status != PIPELINE_OK)

- error_cb_.Run(status);

+ if (status != PIPELINE_OK) error_cb_.Run(status);

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

base::ResetAndReturn(&pause_cb_).Run();

return;

case kPrerolling:

@@ -642,8 +619,7 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {

case kUnderflow:

case kRebuffering:

case kStopped:

- if (status != PIPELINE_OK)

- error_cb_.Run(status);

+ if (status != PIPELINE_OK) error_cb_.Run(status);

scherkus (not reviewing) 2013/06/21 19:48:38 revert this change -- we don't do single-line ifs

return;

}