Skip to content

GitLab

T
tangled
Commit e27f0305 authored by scherkus@chromium.org's avatar scherkus@chromium.org
Browse files
Options

Update AudioRenderer API to fire changes in BufferingState. 

As a result, Pipeline now handles prerolling and underflow/rebuffering
by listening for BUFFERING_HAVE_NOTHING/ENOUGH callbacks. Preroll() is
renamed StartPlayingFrom() and no longer accepts a completion callback.
In this new model, AudioRenderers immediately enter and remain in
the "playing" state and fire buffering state callbacks to let Pipeline
know when to start/stop the clock.

BUG=144683

Review URL: https://codereview.chromium.org/284763002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@272465 0039d316-1c4b-4281-b951-d872f2087c98
parent 5f66681f
Hide whitespace changes
Inline Side-by-side
Showing with 228 additions and 386 deletions
media/base/audio_renderer.h
View file @ e27f0305
...@@ -8,6 +8,7 @@ ...@@ -8,6 +8,7 @@
#include "base/callback.h" #include "base/callback.h"
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "base/time/time.h" #include "base/time/time.h"
#include "media/base/buffering_state.h"
#include "media/base/media_export.h" #include "media/base/media_export.h"
#include "media/base/pipeline_status.h" #include "media/base/pipeline_status.h"
...@@ -21,6 +22,9 @@ class MEDIA_EXPORT AudioRenderer { ...@@ -21,6 +22,9 @@ class MEDIA_EXPORT AudioRenderer {
// Second parameter is the maximum time value that the clock cannot exceed. // Second parameter is the maximum time value that the clock cannot exceed.
typedef base::Callback<void(base::TimeDelta, base::TimeDelta)> TimeCB; typedef base::Callback<void(base::TimeDelta, base::TimeDelta)> TimeCB;
// Used to indicate changes in the buffering state of this audio renderer.
typedef base::Callback<void(BufferingState)> BufferingStateCB;
AudioRenderer(); AudioRenderer();
virtual ~AudioRenderer(); virtual ~AudioRenderer();
...@@ -29,21 +33,19 @@ class MEDIA_EXPORT AudioRenderer { ...@@ -29,21 +33,19 @@ class MEDIA_EXPORT AudioRenderer {
// //
// |statistics_cb| is executed periodically with audio rendering stats. // |statistics_cb| is executed periodically with audio rendering stats.
// //
// |underflow_cb| is executed when the renderer runs out of data to pass to
// the audio card during playback. ResumeAfterUnderflow() must be called
// to resume playback. Pause(), Preroll(), or Stop() cancels the underflow
// condition.
//
// |time_cb| is executed whenever time has advanced by way of audio rendering. // |time_cb| is executed whenever time has advanced by way of audio rendering.
// //
// |buffering_state_cb| is executed when audio rendering has either ran out of
// data or has enough data to continue playback.
//
// |ended_cb| is executed when audio rendering has reached the end of stream. // |ended_cb| is executed when audio rendering has reached the end of stream.
// //
// |error_cb| is executed if an error was encountered. // |error_cb| is executed if an error was encountered.
virtual void Initialize(DemuxerStream* stream, virtual void Initialize(DemuxerStream* stream,
const PipelineStatusCB& init_cb, const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb, const StatisticsCB& statistics_cb,
const base::Closure& underflow_cb,
const TimeCB& time_cb, const TimeCB& time_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb, const base::Closure& ended_cb,
const PipelineStatusCB& error_cb) = 0; const PipelineStatusCB& error_cb) = 0;
...@@ -56,14 +58,16 @@ class MEDIA_EXPORT AudioRenderer { ...@@ -56,14 +58,16 @@ class MEDIA_EXPORT AudioRenderer {
virtual void StopRendering() = 0; virtual void StopRendering() = 0;
// Discard any audio data, executing |callback| when completed. // Discard any audio data, executing |callback| when completed.
//
// Clients should expect |buffering_state_cb| to be called with
// BUFFERING_HAVE_NOTHING while flushing is in progress.
virtual void Flush(const base::Closure& callback) = 0; virtual void Flush(const base::Closure& callback) = 0;
// Start prerolling audio data for samples starting at |time|, executing // Starts playback by reading from |stream| and decoding and rendering audio.
// |callback| when completed. // |timestamp| is the media timestamp playback should start rendering from.
// //
// Only valid to call after a successful Initialize() or Flush(). // Only valid to call after a successful Initialize() or Flush().
virtual void Preroll(base::TimeDelta time, virtual void StartPlayingFrom(base::TimeDelta timestamp) = 0;
const PipelineStatusCB& callback) = 0;
// Stop all operations in preparation for being deleted, executing |callback| // Stop all operations in preparation for being deleted, executing |callback|
// when complete. // when complete.
...@@ -75,9 +79,6 @@ class MEDIA_EXPORT AudioRenderer { ...@@ -75,9 +79,6 @@ class MEDIA_EXPORT AudioRenderer {
// Sets the output volume. // Sets the output volume.
virtual void SetVolume(float volume) = 0; virtual void SetVolume(float volume) = 0;
// Resumes playback after underflow occurs.
virtual void ResumeAfterUnderflow() = 0;
private: private:
DISALLOW_COPY_AND_ASSIGN(AudioRenderer); DISALLOW_COPY_AND_ASSIGN(AudioRenderer);
}; };
......
media/base/mock_filters.h
View file @ e27f0305
...@@ -141,8 +141,8 @@ class MockAudioRenderer : public AudioRenderer { ...@@ -141,8 +141,8 @@ class MockAudioRenderer : public AudioRenderer {
MOCK_METHOD7(Initialize, void(DemuxerStream* stream, MOCK_METHOD7(Initialize, void(DemuxerStream* stream,
const PipelineStatusCB& init_cb, const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb, const StatisticsCB& statistics_cb,
const base::Closure& underflow_cb,
const TimeCB& time_cb, const TimeCB& time_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb, const base::Closure& ended_cb,
const PipelineStatusCB& error_cb)); const PipelineStatusCB& error_cb));
MOCK_METHOD0(StartRendering, void()); MOCK_METHOD0(StartRendering, void());
...@@ -150,7 +150,7 @@ class MockAudioRenderer : public AudioRenderer { ...@@ -150,7 +150,7 @@ class MockAudioRenderer : public AudioRenderer {
MOCK_METHOD1(Flush, void(const base::Closure& callback)); MOCK_METHOD1(Flush, void(const base::Closure& callback));
MOCK_METHOD1(Stop, void(const base::Closure& callback)); MOCK_METHOD1(Stop, void(const base::Closure& callback));
MOCK_METHOD1(SetPlaybackRate, void(float playback_rate)); MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb)); MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta time));
MOCK_METHOD1(SetVolume, void(float volume)); MOCK_METHOD1(SetVolume, void(float volume));
MOCK_METHOD0(ResumeAfterUnderflow, void()); MOCK_METHOD0(ResumeAfterUnderflow, void());
......
media/base/pipeline.cc
View file @ e27f0305
...@@ -414,6 +414,10 @@ void Pipeline::StateTransitionTask(PipelineStatus status) { ...@@ -414,6 +414,10 @@ void Pipeline::StateTransitionTask(PipelineStatus status) {
PlaybackRateChangedTask(GetPlaybackRate()); PlaybackRateChangedTask(GetPlaybackRate());
VolumeChangedTask(GetVolume()); VolumeChangedTask(GetVolume());
// Handle renderers that immediately signal they have enough data.
if (!WaitingForEnoughData())
StartPlayback();
// We enter this state from either kInitPrerolling or kSeeking. As of now // We enter this state from either kInitPrerolling or kSeeking. As of now
// both those states call Preroll(), which means by time we enter this // both those states call Preroll(), which means by time we enter this
// state we've already buffered enough data. Forcefully update the // state we've already buffered enough data. Forcefully update the
...@@ -422,11 +426,10 @@ void Pipeline::StateTransitionTask(PipelineStatus status) { ...@@ -422,11 +426,10 @@ void Pipeline::StateTransitionTask(PipelineStatus status) {
// //
// TODO(scherkus): Remove after renderers are taught to fire buffering // TODO(scherkus): Remove after renderers are taught to fire buffering
// state callbacks http://crbug.com/144683 // state callbacks http://crbug.com/144683
DCHECK(WaitingForEnoughData()); if (video_renderer_) {
if (audio_renderer_) DCHECK(WaitingForEnoughData());
BufferingStateChanged(&audio_buffering_state_, BUFFERING_HAVE_ENOUGH);
if (video_renderer_)
BufferingStateChanged(&video_buffering_state_, BUFFERING_HAVE_ENOUGH); BufferingStateChanged(&video_buffering_state_, BUFFERING_HAVE_ENOUGH);
}
return; return;
case kStopping: case kStopping:
...@@ -453,9 +456,9 @@ void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) { ...@@ -453,9 +456,9 @@ void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) {
// Preroll renderers. // Preroll renderers.
if (audio_renderer_) { if (audio_renderer_) {
bound_fns.Push(base::Bind( bound_fns.Push(base::Bind(&AudioRenderer::StartPlayingFrom,
&AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()), base::Unretained(audio_renderer_.get()),
seek_timestamp)); seek_timestamp));
} }
if (video_renderer_) { if (video_renderer_) {
...@@ -477,6 +480,14 @@ void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) { ...@@ -477,6 +480,14 @@ void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) {
pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb); pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
} }
#if DCHECK_IS_ON
static void VerifyBufferingStates(BufferingState* audio_buffering_state,
BufferingState* video_buffering_state) {
DCHECK_EQ(*audio_buffering_state, BUFFERING_HAVE_NOTHING);
DCHECK_EQ(*video_buffering_state, BUFFERING_HAVE_NOTHING);
}
#endif
void Pipeline::DoSeek( void Pipeline::DoSeek(
base::TimeDelta seek_timestamp, base::TimeDelta seek_timestamp,
const PipelineStatusCB& done_cb) { const PipelineStatusCB& done_cb) {
...@@ -494,14 +505,8 @@ void Pipeline::DoSeek( ...@@ -494,14 +505,8 @@ void Pipeline::DoSeek(
if (audio_renderer_) { if (audio_renderer_) {
bound_fns.Push(base::Bind( bound_fns.Push(base::Bind(
&AudioRenderer::Flush, base::Unretained(audio_renderer_.get()))); &AudioRenderer::Flush, base::Unretained(audio_renderer_.get())));
// TODO(scherkus): Remove after AudioRenderer is taught to fire buffering
// state callbacks http://crbug.com/144683
bound_fns.Push(base::Bind(&Pipeline::BufferingStateChanged,
base::Unretained(this),
&audio_buffering_state_,
BUFFERING_HAVE_NOTHING));
} }
if (video_renderer_) { if (video_renderer_) {
bound_fns.Push(base::Bind( bound_fns.Push(base::Bind(
&VideoRenderer::Flush, base::Unretained(video_renderer_.get()))); &VideoRenderer::Flush, base::Unretained(video_renderer_.get())));
...@@ -513,6 +518,14 @@ void Pipeline::DoSeek( ...@@ -513,6 +518,14 @@ void Pipeline::DoSeek(
&video_buffering_state_, &video_buffering_state_,
BUFFERING_HAVE_NOTHING)); BUFFERING_HAVE_NOTHING));
} }
#if DCHECK_IS_ON
// Verify renderers reset their buffering states.
bound_fns.Push(base::Bind(&VerifyBufferingStates,
&audio_buffering_state_,
&video_buffering_state_));
#endif
if (text_renderer_) { if (text_renderer_) {
bound_fns.Push(base::Bind( bound_fns.Push(base::Bind(
&TextRenderer::Flush, base::Unretained(text_renderer_.get()))); &TextRenderer::Flush, base::Unretained(text_renderer_.get())));
...@@ -524,9 +537,9 @@ void Pipeline::DoSeek( ...@@ -524,9 +537,9 @@ void Pipeline::DoSeek(
// Preroll renderers. // Preroll renderers.
if (audio_renderer_) { if (audio_renderer_) {
bound_fns.Push(base::Bind( bound_fns.Push(base::Bind(&AudioRenderer::StartPlayingFrom,
&AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()), base::Unretained(audio_renderer_.get()),
seek_timestamp)); seek_timestamp));
} }
if (video_renderer_) { if (video_renderer_) {
...@@ -856,8 +869,9 @@ void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) { ...@@ -856,8 +869,9 @@ void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
demuxer_->GetStream(DemuxerStream::AUDIO), demuxer_->GetStream(DemuxerStream::AUDIO),
done_cb, done_cb,
base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)), base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
base::Bind(&Pipeline::OnAudioUnderflow, base::Unretained(this)),
base::Bind(&Pipeline::OnAudioTimeUpdate, base::Unretained(this)), base::Bind(&Pipeline::OnAudioTimeUpdate, base::Unretained(this)),
base::Bind(&Pipeline::BufferingStateChanged, base::Unretained(this),
&audio_buffering_state_),
base::Bind(&Pipeline::OnAudioRendererEnded, base::Unretained(this)), base::Bind(&Pipeline::OnAudioRendererEnded, base::Unretained(this)),
base::Bind(&Pipeline::SetError, base::Unretained(this))); base::Bind(&Pipeline::SetError, base::Unretained(this)));
} }
...@@ -878,20 +892,6 @@ void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) { ...@@ -878,20 +892,6 @@ void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
base::Bind(&Pipeline::GetMediaDuration, base::Unretained(this))); base::Bind(&Pipeline::GetMediaDuration, base::Unretained(this)));
} }
void Pipeline::OnAudioUnderflow() {
if (!task_runner_->BelongsToCurrentThread()) {
task_runner_->PostTask(FROM_HERE, base::Bind(
&Pipeline::OnAudioUnderflow, base::Unretained(this)));
return;
}
if (state_ != kPlaying)
return;
if (audio_renderer_)
audio_renderer_->ResumeAfterUnderflow();
}
void Pipeline::BufferingStateChanged(BufferingState* buffering_state, void Pipeline::BufferingStateChanged(BufferingState* buffering_state,
BufferingState new_buffering_state) { BufferingState new_buffering_state) {
DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", " DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", "
...@@ -903,7 +903,7 @@ void Pipeline::BufferingStateChanged(BufferingState* buffering_state, ...@@ -903,7 +903,7 @@ void Pipeline::BufferingStateChanged(BufferingState* buffering_state,
// Renderer underflowed. // Renderer underflowed.
if (!was_waiting_for_enough_data && WaitingForEnoughData()) { if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
StartWaitingForEnoughData(); PausePlayback();
return; return;
} }
...@@ -925,10 +925,11 @@ bool Pipeline::WaitingForEnoughData() const { ...@@ -925,10 +925,11 @@ bool Pipeline::WaitingForEnoughData() const {
return false; return false;
} }
void Pipeline::StartWaitingForEnoughData() { void Pipeline::PausePlayback() {
DVLOG(1) << __FUNCTION__; DVLOG(1) << __FUNCTION__;
DCHECK_EQ(state_, kPlaying); DCHECK_EQ(state_, kPlaying);
DCHECK(WaitingForEnoughData()); DCHECK(WaitingForEnoughData());
DCHECK(task_runner_->BelongsToCurrentThread());
base::AutoLock auto_lock(lock_); base::AutoLock auto_lock(lock_);
PauseClockAndStopRendering_Locked(); PauseClockAndStopRendering_Locked();
...@@ -939,6 +940,7 @@ void Pipeline::StartPlayback() { ...@@ -939,6 +940,7 @@ void Pipeline::StartPlayback() {
DCHECK_EQ(state_, kPlaying); DCHECK_EQ(state_, kPlaying);
DCHECK_EQ(clock_state_, CLOCK_PAUSED); DCHECK_EQ(clock_state_, CLOCK_PAUSED);
DCHECK(!WaitingForEnoughData()); DCHECK(!WaitingForEnoughData());
DCHECK(task_runner_->BelongsToCurrentThread());
if (audio_renderer_) { if (audio_renderer_) {
// We use audio stream to update the clock. So if there is such a // We use audio stream to update the clock. So if there is such a
......
media/base/pipeline.h
View file @ e27f0305
...@@ -309,8 +309,6 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost { ...@@ -309,8 +309,6 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
void DoStop(const PipelineStatusCB& done_cb); void DoStop(const PipelineStatusCB& done_cb);
void OnStopCompleted(PipelineStatus status); void OnStopCompleted(PipelineStatus status);
void OnAudioUnderflow();
// Collection of callback methods and helpers for tracking changes in // Collection of callback methods and helpers for tracking changes in
// buffering state and transition from paused/underflow states and playing // buffering state and transition from paused/underflow states and playing
// states. // states.
...@@ -319,11 +317,11 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost { ...@@ -319,11 +317,11 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
// - A waiting to non-waiting transition indicates preroll has completed // - A waiting to non-waiting transition indicates preroll has completed
// and StartPlayback() should be called // and StartPlayback() should be called
// - A non-waiting to waiting transition indicates underflow has occurred // - A non-waiting to waiting transition indicates underflow has occurred
// and StartWaitingForEnoughData() should be called // and PausePlayback() should be called
void BufferingStateChanged(BufferingState* buffering_state, void BufferingStateChanged(BufferingState* buffering_state,
BufferingState new_buffering_state); BufferingState new_buffering_state);
bool WaitingForEnoughData() const; bool WaitingForEnoughData() const;
void StartWaitingForEnoughData(); void PausePlayback();
void StartPlayback(); void StartPlayback();
void PauseClockAndStopRendering_Locked(); void PauseClockAndStopRendering_Locked();
......
media/base/pipeline_unittest.cc
View file @ e27f0305
...@@ -51,6 +51,10 @@ ACTION_P2(SetError, pipeline, status) { ...@@ -51,6 +51,10 @@ ACTION_P2(SetError, pipeline, status) {
pipeline->SetErrorForTesting(status); pipeline->SetErrorForTesting(status);
} }
ACTION_P2(SetBufferingState, cb, buffering_state) {
cb->Run(buffering_state);
}
// Used for setting expectations on pipeline callbacks. Using a StrictMock // Used for setting expectations on pipeline callbacks. Using a StrictMock
// also lets us test for missing callbacks. // also lets us test for missing callbacks.
class CallbackHelper { class CallbackHelper {
...@@ -183,7 +187,8 @@ class PipelineTest : public ::testing::Test { ...@@ -183,7 +187,8 @@ class PipelineTest : public ::testing::Test {
// Sets up expectations to allow the audio renderer to initialize. // Sets up expectations to allow the audio renderer to initialize.
void InitializeAudioRenderer(DemuxerStream* stream) { void InitializeAudioRenderer(DemuxerStream* stream) {
EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _)) EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _))
.WillOnce(DoAll(SaveArg<4>(&audio_time_cb_), .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
SaveArg<4>(&audio_buffering_state_cb_),
RunCallback<1>(PIPELINE_OK))); RunCallback<1>(PIPELINE_OK)));
} }
...@@ -205,10 +210,9 @@ class PipelineTest : public ::testing::Test { ...@@ -205,10 +210,9 @@ class PipelineTest : public ::testing::Test {
if (audio_stream_) { if (audio_stream_) {
EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f)); EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
EXPECT_CALL(*audio_renderer_, SetVolume(1.0f)); EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
// Startup sequence. .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _)) BUFFERING_HAVE_ENOUGH));
.WillOnce(RunCallback<1>(PIPELINE_OK));
EXPECT_CALL(*audio_renderer_, StartRendering()); EXPECT_CALL(*audio_renderer_, StartRendering());
} }
EXPECT_CALL(callbacks_, OnPrerollCompleted()); EXPECT_CALL(callbacks_, OnPrerollCompleted());
...@@ -254,17 +258,21 @@ class PipelineTest : public ::testing::Test { ...@@ -254,17 +258,21 @@ class PipelineTest : public ::testing::Test {
return text_stream_.get(); return text_stream_.get();
} }
void ExpectSeek(const base::TimeDelta& seek_time) { void ExpectSeek(const base::TimeDelta& seek_time, bool underflowed) {
// Every filter should receive a call to Seek(). // Every filter should receive a call to Seek().
EXPECT_CALL(*demuxer_, Seek(seek_time, _)) EXPECT_CALL(*demuxer_, Seek(seek_time, _))
.WillOnce(RunCallback<1>(PIPELINE_OK)); .WillOnce(RunCallback<1>(PIPELINE_OK));
if (audio_stream_) { if (audio_stream_) {
EXPECT_CALL(*audio_renderer_, StopRendering()); if (!underflowed)
EXPECT_CALL(*audio_renderer_, StopRendering());
EXPECT_CALL(*audio_renderer_, Flush(_)) EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(RunClosure<0>()); .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _)) BUFFERING_HAVE_NOTHING),
.WillOnce(RunCallback<1>(PIPELINE_OK)); RunClosure<0>()));
EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
.WillOnce(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_ENOUGH));
EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
EXPECT_CALL(*audio_renderer_, SetVolume(_)); EXPECT_CALL(*audio_renderer_, SetVolume(_));
EXPECT_CALL(*audio_renderer_, StartRendering()); EXPECT_CALL(*audio_renderer_, StartRendering());
...@@ -333,6 +341,7 @@ class PipelineTest : public ::testing::Test { ...@@ -333,6 +341,7 @@ class PipelineTest : public ::testing::Test {
scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_; scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
scoped_ptr<FakeTextTrackStream> text_stream_; scoped_ptr<FakeTextTrackStream> text_stream_;
AudioRenderer::TimeCB audio_time_cb_; AudioRenderer::TimeCB audio_time_cb_;
AudioRenderer::BufferingStateCB audio_buffering_state_cb_;
VideoDecoderConfig video_decoder_config_; VideoDecoderConfig video_decoder_config_;
PipelineMetadata metadata_; PipelineMetadata metadata_;
...@@ -510,7 +519,7 @@ TEST_F(PipelineTest, Seek) { ...@@ -510,7 +519,7 @@ TEST_F(PipelineTest, Seek) {
// Every filter should receive a call to Seek(). // Every filter should receive a call to Seek().
base::TimeDelta expected = base::TimeDelta::FromSeconds(2000); base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
ExpectSeek(expected); ExpectSeek(expected, false);
DoSeek(expected); DoSeek(expected);
} }
...@@ -568,7 +577,7 @@ TEST_F(PipelineTest, GetBufferedTimeRanges) { ...@@ -568,7 +577,7 @@ TEST_F(PipelineTest, GetBufferedTimeRanges) {
EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0)); EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
base::TimeDelta kSeekTime = kDuration / 2; base::TimeDelta kSeekTime = kDuration / 2;
ExpectSeek(kSeekTime); ExpectSeek(kSeekTime, false);
DoSeek(kSeekTime); DoSeek(kSeekTime);
EXPECT_FALSE(pipeline_->DidLoadingProgress()); EXPECT_FALSE(pipeline_->DidLoadingProgress());
...@@ -670,7 +679,9 @@ TEST_F(PipelineTest, ErrorDuringSeek) { ...@@ -670,7 +679,9 @@ TEST_F(PipelineTest, ErrorDuringSeek) {
// Preroll() isn't called as the demuxer errors out first. // Preroll() isn't called as the demuxer errors out first.
EXPECT_CALL(*audio_renderer_, StopRendering()); EXPECT_CALL(*audio_renderer_, StopRendering());
EXPECT_CALL(*audio_renderer_, Flush(_)) EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(RunClosure<0>()); .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_NOTHING),
RunClosure<0>()));
EXPECT_CALL(*audio_renderer_, Stop(_)) EXPECT_CALL(*audio_renderer_, Stop(_))
.WillOnce(RunClosure<0>()); .WillOnce(RunClosure<0>());
...@@ -724,7 +735,9 @@ TEST_F(PipelineTest, NoMessageDuringTearDownFromError) { ...@@ -724,7 +735,9 @@ TEST_F(PipelineTest, NoMessageDuringTearDownFromError) {
// Seek() isn't called as the demuxer errors out first. // Seek() isn't called as the demuxer errors out first.
EXPECT_CALL(*audio_renderer_, StopRendering()); EXPECT_CALL(*audio_renderer_, StopRendering());
EXPECT_CALL(*audio_renderer_, Flush(_)) EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(RunClosure<0>()); .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_NOTHING),
RunClosure<0>()));
EXPECT_CALL(*audio_renderer_, Stop(_)) EXPECT_CALL(*audio_renderer_, Stop(_))
.WillOnce(RunClosure<0>()); .WillOnce(RunClosure<0>());
...@@ -814,9 +827,12 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) { ...@@ -814,9 +827,12 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
EXPECT_CALL(*audio_renderer_, StopRendering()); EXPECT_CALL(*audio_renderer_, StopRendering());
EXPECT_CALL(*audio_renderer_, Flush(_)) EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(RunClosure<0>()); .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _)) BUFFERING_HAVE_NOTHING),
.WillOnce(RunCallback<1>(PIPELINE_OK)); RunClosure<0>()));
EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
.WillOnce(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_ENOUGH));
EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
EXPECT_CALL(*audio_renderer_, SetVolume(_)); EXPECT_CALL(*audio_renderer_, SetVolume(_));
EXPECT_CALL(*audio_renderer_, StartRendering()); EXPECT_CALL(*audio_renderer_, StartRendering());
...@@ -854,6 +870,28 @@ TEST_F(PipelineTest, DeleteAfterStop) { ...@@ -854,6 +870,28 @@ TEST_F(PipelineTest, DeleteAfterStop) {
message_loop_.RunUntilIdle(); message_loop_.RunUntilIdle();
} }
TEST_F(PipelineTest, Underflow) {
CreateAudioStream();
CreateVideoStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
streams.push_back(video_stream());
InitializeDemuxer(&streams);
InitializeAudioRenderer(audio_stream());
InitializeVideoRenderer(video_stream());
InitializePipeline(PIPELINE_OK);
// Simulate underflow.
EXPECT_CALL(*audio_renderer_, StopRendering());
audio_buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
// Seek while underflowed. We shouldn't call StopRendering() again.
base::TimeDelta expected = base::TimeDelta::FromSeconds(5);
ExpectSeek(expected, true);
DoSeek(expected);
}
class PipelineTeardownTest : public PipelineTest { class PipelineTeardownTest : public PipelineTest {
public: public:
enum TeardownState { enum TeardownState {
...@@ -966,7 +1004,8 @@ class PipelineTeardownTest : public PipelineTest { ...@@ -966,7 +1004,8 @@ class PipelineTeardownTest : public PipelineTest {
} }
EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _)) EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
.WillOnce(RunCallback<1>(PIPELINE_OK)); .WillOnce(DoAll(SaveArg<4>(&audio_buffering_state_cb_),
RunCallback<1>(PIPELINE_OK)));
if (state == kInitVideoRenderer) { if (state == kInitVideoRenderer) {
if (stop_or_error == kStop) { if (stop_or_error == kStop) {
...@@ -992,8 +1031,9 @@ class PipelineTeardownTest : public PipelineTest { ...@@ -992,8 +1031,9 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(callbacks_, OnMetadata(_)); EXPECT_CALL(callbacks_, OnMetadata(_));
// If we get here it's a successful initialization. // If we get here it's a successful initialization.
EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _)) EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
.WillOnce(RunCallback<1>(PIPELINE_OK)); .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_ENOUGH));
EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _)) EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
.WillOnce(RunCallback<1>(PIPELINE_OK)); .WillOnce(RunCallback<1>(PIPELINE_OK));
...@@ -1040,17 +1080,26 @@ class PipelineTeardownTest : public PipelineTest { ...@@ -1040,17 +1080,26 @@ class PipelineTeardownTest : public PipelineTest {
if (state == kFlushing) { if (state == kFlushing) {
if (stop_or_error == kStop) { if (stop_or_error == kStop) {
EXPECT_CALL(*audio_renderer_, Flush(_)) EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>())); .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_NOTHING),
RunClosure<0>()));
} else { } else {
status = PIPELINE_ERROR_READ; status = PIPELINE_ERROR_READ;
EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce( EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(
DoAll(SetError(pipeline_.get(), status), RunClosure<0>())); DoAll(SetError(pipeline_.get(), status),
SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_NOTHING),
RunClosure<0>()));
} }
return status; return status;
} }
EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>()); EXPECT_CALL(*audio_renderer_, Flush(_))
.WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
BUFFERING_HAVE_NOTHING),
RunClosure<0>()));
EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>()); EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
if (state == kSeeking) { if (state == kSeeking) {
...@@ -1072,20 +1121,18 @@ class PipelineTeardownTest : public PipelineTest { ...@@ -1072,20 +1121,18 @@ class PipelineTeardownTest : public PipelineTest {
if (state == kPrerolling) { if (state == kPrerolling) {
if (stop_or_error == kStop) { if (stop_or_error == kStop) {
EXPECT_CALL(*audio_renderer_, Preroll(_, _)) EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_))
.WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), .WillOnce(Stop(pipeline_.get(), stop_cb));
RunCallback<1>(PIPELINE_OK)));
} else { } else {
status = PIPELINE_ERROR_READ; status = PIPELINE_ERROR_READ;
EXPECT_CALL(*audio_renderer_, Preroll(_, _)) EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_))
.WillOnce(RunCallback<1>(status)); .WillOnce(SetError(pipeline_.get(), status));
} }
return status; return status;
} }
EXPECT_CALL(*audio_renderer_, Preroll(_, _)) EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_));
.WillOnce(RunCallback<1>(PIPELINE_OK));
EXPECT_CALL(*video_renderer_, Preroll(_, _)) EXPECT_CALL(*video_renderer_, Preroll(_, _))
.WillOnce(RunCallback<1>(PIPELINE_OK)); .WillOnce(RunCallback<1>(PIPELINE_OK));
......
media/filters/audio_renderer_impl.cc
View file @ e27f0305
...@@ -54,12 +54,12 @@ AudioRendererImpl::AudioRendererImpl( ...@@ -54,12 +54,12 @@ AudioRendererImpl::AudioRendererImpl(
hardware_config_(hardware_config), hardware_config_(hardware_config),
now_cb_(base::Bind(&base::TimeTicks::Now)), now_cb_(base::Bind(&base::TimeTicks::Now)),
state_(kUninitialized), state_(kUninitialized),
buffering_state_(BUFFERING_HAVE_NOTHING),
rendering_(false), rendering_(false),
sink_playing_(false), sink_playing_(false),
pending_read_(false), pending_read_(false),
received_end_of_stream_(false), received_end_of_stream_(false),
rendered_end_of_stream_(false), rendered_end_of_stream_(false),
preroll_aborted_(false),
weak_factory_(this) { weak_factory_(this) {
audio_buffer_stream_.set_splice_observer(base::Bind( audio_buffer_stream_.set_splice_observer(base::Bind(
&AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr())); &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
...@@ -92,8 +92,7 @@ void AudioRendererImpl::StartRendering() { ...@@ -92,8 +92,7 @@ void AudioRendererImpl::StartRendering() {
void AudioRendererImpl::StartRendering_Locked() { void AudioRendererImpl::StartRendering_Locked() {
DVLOG(1) << __FUNCTION__; DVLOG(1) << __FUNCTION__;
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow) DCHECK_EQ(state_, kPlaying);
<< "state_=" << state_;
DCHECK(!sink_playing_); DCHECK(!sink_playing_);
DCHECK_NE(algorithm_->playback_rate(), 0); DCHECK_NE(algorithm_->playback_rate(), 0);
lock_.AssertAcquired(); lock_.AssertAcquired();
...@@ -123,8 +122,7 @@ void AudioRendererImpl::StopRendering() { ...@@ -123,8 +122,7 @@ void AudioRendererImpl::StopRendering() {
void AudioRendererImpl::StopRendering_Locked() { void AudioRendererImpl::StopRendering_Locked() {
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow) DCHECK_EQ(state_, kPlaying);
<< "state_=" << state_;
DCHECK(sink_playing_); DCHECK(sink_playing_);
lock_.AssertAcquired(); lock_.AssertAcquired();
...@@ -139,16 +137,14 @@ void AudioRendererImpl::Flush(const base::Closure& callback) { ...@@ -139,16 +137,14 @@ void AudioRendererImpl::Flush(const base::Closure& callback) {
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
base::AutoLock auto_lock(lock_); base::AutoLock auto_lock(lock_);
DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow) DCHECK_EQ(state_, kPlaying);
<< "state_=" << state_;
DCHECK(flush_cb_.is_null()); DCHECK(flush_cb_.is_null());
flush_cb_ = callback; flush_cb_ = callback;
ChangeState_Locked(kFlushing);
if (pending_read_) { if (pending_read_)
ChangeState_Locked(kFlushing);
return; return;
}
ChangeState_Locked(kFlushed); ChangeState_Locked(kFlushed);
DoFlush_Locked(); DoFlush_Locked();
...@@ -178,7 +174,10 @@ void AudioRendererImpl::ResetDecoderDone() { ...@@ -178,7 +174,10 @@ void AudioRendererImpl::ResetDecoderDone() {
audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate())); audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
received_end_of_stream_ = false; received_end_of_stream_ = false;
rendered_end_of_stream_ = false; rendered_end_of_stream_ = false;
preroll_aborted_ = false;
// Flush() may have been called while underflowed/not fully buffered.
if (buffering_state_ != BUFFERING_HAVE_NOTHING)
SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
earliest_end_time_ = now_cb_.Run(); earliest_end_time_ = now_cb_.Run();
splicer_->Reset(); splicer_->Reset();
...@@ -207,7 +206,6 @@ void AudioRendererImpl::Stop(const base::Closure& callback) { ...@@ -207,7 +206,6 @@ void AudioRendererImpl::Stop(const base::Closure& callback) {
ChangeState_Locked(kStopped); ChangeState_Locked(kStopped);
algorithm_.reset(); algorithm_.reset();
underflow_cb_.Reset();
time_cb_.Reset(); time_cb_.Reset();
flush_cb_.Reset(); flush_cb_.Reset();
} }
...@@ -220,20 +218,18 @@ void AudioRendererImpl::Stop(const base::Closure& callback) { ...@@ -220,20 +218,18 @@ void AudioRendererImpl::Stop(const base::Closure& callback) {
audio_buffer_stream_.Stop(callback); audio_buffer_stream_.Stop(callback);
} }
void AudioRendererImpl::Preroll(base::TimeDelta time, void AudioRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
const PipelineStatusCB& cb) { DVLOG(1) << __FUNCTION__ << "(" << timestamp.InMicroseconds() << ")";
DVLOG(1) << __FUNCTION__ << "(" << time.InMicroseconds() << ")";
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
base::AutoLock auto_lock(lock_); base::AutoLock auto_lock(lock_);
DCHECK(!sink_playing_); DCHECK(!sink_playing_);
DCHECK_EQ(state_, kFlushed); DCHECK_EQ(state_, kFlushed);
DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
DCHECK(!pending_read_) << "Pending read must complete before seeking"; DCHECK(!pending_read_) << "Pending read must complete before seeking";
DCHECK(preroll_cb_.is_null());
ChangeState_Locked(kPrerolling); ChangeState_Locked(kPlaying);
preroll_cb_ = cb; start_timestamp_ = timestamp;
preroll_timestamp_ = time;
AttemptRead_Locked(); AttemptRead_Locked();
} }
...@@ -241,8 +237,8 @@ void AudioRendererImpl::Preroll(base::TimeDelta time, ...@@ -241,8 +237,8 @@ void AudioRendererImpl::Preroll(base::TimeDelta time,
void AudioRendererImpl::Initialize(DemuxerStream* stream, void AudioRendererImpl::Initialize(DemuxerStream* stream,
const PipelineStatusCB& init_cb, const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb, const StatisticsCB& statistics_cb,
const base::Closure& underflow_cb,
const TimeCB& time_cb, const TimeCB& time_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb, const base::Closure& ended_cb,
const PipelineStatusCB& error_cb) { const PipelineStatusCB& error_cb) {
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
...@@ -250,8 +246,8 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream, ...@@ -250,8 +246,8 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream,
DCHECK_EQ(stream->type(), DemuxerStream::AUDIO); DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
DCHECK(!init_cb.is_null()); DCHECK(!init_cb.is_null());
DCHECK(!statistics_cb.is_null()); DCHECK(!statistics_cb.is_null());
DCHECK(!underflow_cb.is_null());
DCHECK(!time_cb.is_null()); DCHECK(!time_cb.is_null());
DCHECK(!buffering_state_cb.is_null());
DCHECK(!ended_cb.is_null()); DCHECK(!ended_cb.is_null());
DCHECK(!error_cb.is_null()); DCHECK(!error_cb.is_null());
DCHECK_EQ(kUninitialized, state_); DCHECK_EQ(kUninitialized, state_);
...@@ -260,8 +256,9 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream, ...@@ -260,8 +256,9 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream,
state_ = kInitializing; state_ = kInitializing;
init_cb_ = init_cb; init_cb_ = init_cb;
underflow_cb_ = underflow_cb;
time_cb_ = time_cb; time_cb_ = time_cb;
// Callback can be run from audio callback thread in Render().
buffering_state_cb_ = BindToCurrentLoop(buffering_state_cb);
ended_cb_ = ended_cb; ended_cb_ = ended_cb;
error_cb_ = error_cb; error_cb_ = error_cb;
...@@ -351,23 +348,6 @@ void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) { ...@@ -351,23 +348,6 @@ void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK); base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
} }
void AudioRendererImpl::ResumeAfterUnderflow() {
DCHECK(task_runner_->BelongsToCurrentThread());
base::AutoLock auto_lock(lock_);
if (state_ == kUnderflow) {
// The "!preroll_aborted_" is a hack. If preroll is aborted, then we
// shouldn't even reach the kUnderflow state to begin with. But for now
// we're just making sure that the audio buffer capacity (i.e. the
// number of bytes that need to be buffered for preroll to complete)
// does not increase due to an aborted preroll.
// TODO(vrk): Fix this bug correctly! (crbug.com/151352)
if (!preroll_aborted_)
algorithm_->IncreaseQueueCapacity();
ChangeState_Locked(kRebuffering);
}
}
void AudioRendererImpl::SetVolume(float volume) { void AudioRendererImpl::SetVolume(float volume) {
DCHECK(task_runner_->BelongsToCurrentThread()); DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(sink_); DCHECK(sink_);
...@@ -429,7 +409,7 @@ void AudioRendererImpl::DecodedAudioReady( ...@@ -429,7 +409,7 @@ void AudioRendererImpl::DecodedAudioReady(
bool need_another_buffer = false; bool need_another_buffer = false;
while (splicer_->HasNextBuffer()) while (splicer_->HasNextBuffer())
need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer()); need_another_buffer = HandleSplicerBuffer_Locked(splicer_->GetNextBuffer());
if (!need_another_buffer && !CanRead_Locked()) if (!need_another_buffer && !CanRead_Locked())
return; return;
...@@ -437,23 +417,18 @@ void AudioRendererImpl::DecodedAudioReady( ...@@ -437,23 +417,18 @@ void AudioRendererImpl::DecodedAudioReady(
AttemptRead_Locked(); AttemptRead_Locked();
} }
bool AudioRendererImpl::HandleSplicerBuffer( bool AudioRendererImpl::HandleSplicerBuffer_Locked(
const scoped_refptr<AudioBuffer>& buffer) { const scoped_refptr<AudioBuffer>& buffer) {
lock_.AssertAcquired();
if (buffer->end_of_stream()) { if (buffer->end_of_stream()) {
received_end_of_stream_ = true; 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)
ChangeState_Locked(kPlaying);
} else { } else {
if (state_ == kPrerolling) { if (state_ == kPlaying) {
if (IsBeforePrerollTime(buffer)) if (IsBeforeStartTime(buffer))
return true; return true;
// Trim off any additional time before the preroll timestamp. // Trim off any additional time before the start timestamp.
const base::TimeDelta trim_time = const base::TimeDelta trim_time = start_timestamp_ - buffer->timestamp();
preroll_timestamp_ - buffer->timestamp();
if (trim_time > base::TimeDelta()) { if (trim_time > base::TimeDelta()) {
buffer->TrimStart(buffer->frame_count() * buffer->TrimStart(buffer->frame_count() *
(static_cast<double>(trim_time.InMicroseconds()) / (static_cast<double>(trim_time.InMicroseconds()) /
...@@ -479,22 +454,13 @@ bool AudioRendererImpl::HandleSplicerBuffer( ...@@ -479,22 +454,13 @@ bool AudioRendererImpl::HandleSplicerBuffer(
DCHECK(!pending_read_); DCHECK(!pending_read_);
return false; return false;
case kPrerolling:
if (!buffer->end_of_stream() && !algorithm_->IsQueueFull())
return true;
ChangeState_Locked(kPlaying);
base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
return false;
case kPlaying: case kPlaying:
case kUnderflow: if (buffer->end_of_stream() || algorithm_->IsQueueFull()) {
return false; if (buffering_state_ == BUFFERING_HAVE_NOTHING)
SetBufferingState_Locked(BUFFERING_HAVE_ENOUGH);
case kRebuffering: return false;
if (!algorithm_->IsQueueFull()) }
return true; return true;
ChangeState_Locked(kPlaying);
return false;
case kStopped: case kStopped:
return false; return false;
...@@ -525,15 +491,12 @@ bool AudioRendererImpl::CanRead_Locked() { ...@@ -525,15 +491,12 @@ bool AudioRendererImpl::CanRead_Locked() {
switch (state_) { switch (state_) {
case kUninitialized: case kUninitialized:
case kInitializing: case kInitializing:
case kFlushed:
case kFlushing: case kFlushing:
case kFlushed:
case kStopped: case kStopped:
return false; return false;
case kPrerolling:
case kPlaying: case kPlaying:
case kUnderflow:
case kRebuffering:
break; break;
} }
...@@ -569,11 +532,11 @@ void AudioRendererImpl::SetPlaybackRate(float playback_rate) { ...@@ -569,11 +532,11 @@ void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
} }
} }
bool AudioRendererImpl::IsBeforePrerollTime( bool AudioRendererImpl::IsBeforeStartTime(
const scoped_refptr<AudioBuffer>& buffer) { const scoped_refptr<AudioBuffer>& buffer) {
DCHECK_EQ(state_, kPrerolling); DCHECK_EQ(state_, kPlaying);
return buffer && !buffer->end_of_stream() && return buffer && !buffer->end_of_stream() &&
(buffer->timestamp() + buffer->duration()) < preroll_timestamp_; (buffer->timestamp() + buffer->duration()) < start_timestamp_;
} }
int AudioRendererImpl::Render(AudioBus* audio_bus, int AudioRendererImpl::Render(AudioBus* audio_bus,
...@@ -585,7 +548,6 @@ int AudioRendererImpl::Render(AudioBus* audio_bus, ...@@ -585,7 +548,6 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
audio_parameters_.sample_rate()); audio_parameters_.sample_rate());
int frames_written = 0; int frames_written = 0;
base::Closure time_cb; base::Closure time_cb;
base::Closure underflow_cb;
{ {
base::AutoLock auto_lock(lock_); base::AutoLock auto_lock(lock_);
...@@ -639,8 +601,10 @@ int AudioRendererImpl::Render(AudioBus* audio_bus, ...@@ -639,8 +601,10 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
rendered_end_of_stream_ = true; rendered_end_of_stream_ = true;
ended_cb_.Run(); ended_cb_.Run();
} else if (!received_end_of_stream_ && state_ == kPlaying) { } else if (!received_end_of_stream_ && state_ == kPlaying) {
ChangeState_Locked(kUnderflow); if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
underflow_cb = underflow_cb_; algorithm_->IncreaseQueueCapacity();
SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
}
} else { } else {
// We can't write any data this cycle. For example, we may have // We can't write any data this cycle. For example, we may have
// sent all available data to the audio device while not reaching // sent all available data to the audio device while not reaching
...@@ -673,9 +637,6 @@ int AudioRendererImpl::Render(AudioBus* audio_bus, ...@@ -673,9 +637,6 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
if (!time_cb.is_null()) if (!time_cb.is_null())
time_cb.Run(); time_cb.Run();
if (!underflow_cb.is_null())
underflow_cb.Run();
DCHECK_LE(frames_written, requested_frames); DCHECK_LE(frames_written, requested_frames);
return frames_written; return frames_written;
} }
...@@ -714,7 +675,6 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) { ...@@ -714,7 +675,6 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
return; return;
case kFlushing: case kFlushing:
ChangeState_Locked(kFlushed); ChangeState_Locked(kFlushed);
if (status == PIPELINE_OK) { if (status == PIPELINE_OK) {
DoFlush_Locked(); DoFlush_Locked();
return; return;
...@@ -723,16 +683,9 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) { ...@@ -723,16 +683,9 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
error_cb_.Run(status); error_cb_.Run(status);
base::ResetAndReturn(&flush_cb_).Run(); base::ResetAndReturn(&flush_cb_).Run();
return; return;
case kPrerolling:
// This is a signal for abort if it's not an error.
preroll_aborted_ = !is_decode_error;
ChangeState_Locked(kPlaying);
base::ResetAndReturn(&preroll_cb_).Run(status);
return;
case kFlushed: case kFlushed:
case kPlaying: case kPlaying:
case kUnderflow:
case kRebuffering:
case kStopped: case kStopped:
if (status != PIPELINE_OK) if (status != PIPELINE_OK)
error_cb_.Run(status); error_cb_.Run(status);
...@@ -762,4 +715,14 @@ void AudioRendererImpl::OnConfigChange() { ...@@ -762,4 +715,14 @@ void AudioRendererImpl::OnConfigChange() {
CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer())); CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
} }
void AudioRendererImpl::SetBufferingState_Locked(
BufferingState buffering_state) {
DVLOG(1) << __FUNCTION__ << " : " << buffering_state_ << " -> "
<< buffering_state;
DCHECK_NE(buffering_state_, buffering_state);
lock_.AssertAcquired();
buffering_state_ = buffering_state;
buffering_state_cb_.Run(buffering_state_);
}
} // namespace media } // namespace media
media/filters/audio_renderer_impl.h
View file @ e27f0305
...@@ -68,8 +68,8 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -68,8 +68,8 @@ class MEDIA_EXPORT AudioRendererImpl
virtual void Initialize(DemuxerStream* stream, virtual void Initialize(DemuxerStream* stream,
const PipelineStatusCB& init_cb, const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb, const StatisticsCB& statistics_cb,
const base::Closure& underflow_cb,
const TimeCB& time_cb, const TimeCB& time_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb, const base::Closure& ended_cb,
const PipelineStatusCB& error_cb) OVERRIDE; const PipelineStatusCB& error_cb) OVERRIDE;
virtual void StartRendering() OVERRIDE; virtual void StartRendering() OVERRIDE;
...@@ -77,9 +77,7 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -77,9 +77,7 @@ class MEDIA_EXPORT AudioRendererImpl
virtual void Flush(const base::Closure& callback) OVERRIDE; virtual void Flush(const base::Closure& callback) OVERRIDE;
virtual void Stop(const base::Closure& callback) OVERRIDE; virtual void Stop(const base::Closure& callback) OVERRIDE;
virtual void SetPlaybackRate(float rate) OVERRIDE; virtual void SetPlaybackRate(float rate) OVERRIDE;
virtual void Preroll(base::TimeDelta time, virtual void StartPlayingFrom(base::TimeDelta timestamp) OVERRIDE;
const PipelineStatusCB& cb) OVERRIDE;
virtual void ResumeAfterUnderflow() OVERRIDE;
virtual void SetVolume(float volume) OVERRIDE; virtual void SetVolume(float volume) OVERRIDE;
// Allows injection of a custom time callback for non-realtime testing. // Allows injection of a custom time callback for non-realtime testing.
...@@ -104,25 +102,17 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -104,25 +102,17 @@ class MEDIA_EXPORT AudioRendererImpl
// | // |
// V Decoders reset // V Decoders reset
// kFlushed <------------------ kFlushing // kFlushed <------------------ kFlushing
// | Preroll() ^ // | StartPlayingFrom() ^
// | | // | |
// V | Flush() // | | Flush()
// kPrerolling ----------------> kPlaying ---------. // `---------> kPlaying --------'
// Enough data buffered ^ | Not enough data
// | | buffered
// Enough data buffered | V
// kRebuffering <--- kUnderflow
// ResumeAfterUnderflow()
enum State { enum State {
kUninitialized, kUninitialized,
kInitializing, kInitializing,
kFlushing, kFlushing,
kFlushed, kFlushed,
kPrerolling,
kPlaying, kPlaying,
kStopped, kStopped,
kUnderflow,
kRebuffering,
}; };
// Callback from the audio decoder delivering decoded audio samples. // Callback from the audio decoder delivering decoded audio samples.
...@@ -131,7 +121,7 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -131,7 +121,7 @@ class MEDIA_EXPORT AudioRendererImpl
// Handles buffers that come out of |splicer_|. // Handles buffers that come out of |splicer_|.
// Returns true if more buffers are needed. // Returns true if more buffers are needed.
bool HandleSplicerBuffer(const scoped_refptr<AudioBuffer>& buffer); bool HandleSplicerBuffer_Locked(const scoped_refptr<AudioBuffer>& buffer);
// Helper functions for AudioDecoder::Status values passed to // Helper functions for AudioDecoder::Status values passed to
// DecodedAudioReady(). // DecodedAudioReady().
...@@ -177,10 +167,9 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -177,10 +167,9 @@ class MEDIA_EXPORT AudioRendererImpl
bool CanRead_Locked(); bool CanRead_Locked();
void ChangeState_Locked(State new_state); void ChangeState_Locked(State new_state);
// Returns true if the data in the buffer is all before // Returns true if the data in the buffer is all before |start_timestamp_|.
// |preroll_timestamp_|. This can only return true while // This can only return true while in the kPlaying state.
// in the kPrerolling state. bool IsBeforeStartTime(const scoped_refptr<AudioBuffer>& buffer);
bool IsBeforePrerollTime(const scoped_refptr<AudioBuffer>& buffer);
// Called upon AudioBufferStream initialization, or failure thereof (indicated // Called upon AudioBufferStream initialization, or failure thereof (indicated
// by the value of |success|). // by the value of |success|).
...@@ -203,6 +192,9 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -203,6 +192,9 @@ class MEDIA_EXPORT AudioRendererImpl
// Called by the AudioBufferStream when a config change occurs. // Called by the AudioBufferStream when a config change occurs.
void OnConfigChange(); void OnConfigChange();
// Updates |buffering_state_| and fires |buffering_state_cb_|.
void SetBufferingState_Locked(BufferingState buffering_state);
scoped_refptr<base::SingleThreadTaskRunner> task_runner_; scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
scoped_ptr<AudioSplicer> splicer_; scoped_ptr<AudioSplicer> splicer_;
...@@ -226,17 +218,14 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -226,17 +218,14 @@ class MEDIA_EXPORT AudioRendererImpl
// Callbacks provided during Initialize(). // Callbacks provided during Initialize().
PipelineStatusCB init_cb_; PipelineStatusCB init_cb_;
base::Closure underflow_cb_;
TimeCB time_cb_; TimeCB time_cb_;
BufferingStateCB buffering_state_cb_;
base::Closure ended_cb_; base::Closure ended_cb_;
PipelineStatusCB error_cb_; PipelineStatusCB error_cb_;
// Callback provided to Flush(). // Callback provided to Flush().
base::Closure flush_cb_; base::Closure flush_cb_;
// Callback provided to Preroll().
PipelineStatusCB preroll_cb_;
// Typically calls base::TimeTicks::Now() but can be overridden by a test. // Typically calls base::TimeTicks::Now() but can be overridden by a test.
NowCB now_cb_; NowCB now_cb_;
...@@ -250,6 +239,8 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -250,6 +239,8 @@ class MEDIA_EXPORT AudioRendererImpl
// Simple state tracking variable. // Simple state tracking variable.
State state_; State state_;
BufferingState buffering_state_;
// Keep track of whether or not the sink is playing and whether we should be // Keep track of whether or not the sink is playing and whether we should be
// rendering. // rendering.
bool rendering_; bool rendering_;
...@@ -264,7 +255,7 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -264,7 +255,7 @@ class MEDIA_EXPORT AudioRendererImpl
scoped_ptr<AudioClock> audio_clock_; scoped_ptr<AudioClock> audio_clock_;
base::TimeDelta preroll_timestamp_; base::TimeDelta start_timestamp_;
// We're supposed to know amount of audio data OS or hardware buffered, but // We're supposed to know amount of audio data OS or hardware buffered, but
// that is not always so -- on my Linux box // that is not always so -- on my Linux box
...@@ -283,10 +274,6 @@ class MEDIA_EXPORT AudioRendererImpl ...@@ -283,10 +274,6 @@ class MEDIA_EXPORT AudioRendererImpl
base::TimeTicks earliest_end_time_; base::TimeTicks earliest_end_time_;
size_t total_frames_filled_; size_t total_frames_filled_;
// True if the renderer receives a buffer with kAborted status during preroll,
// false otherwise. This flag is cleared on the next Preroll() call.
bool preroll_aborted_;
// End variables which must be accessed under |lock_|. ---------------------- // End variables which must be accessed under |lock_|. ----------------------
// NOTE: Weak pointers must be invalidated before all other member variables. // NOTE: Weak pointers must be invalidated before all other member variables.
......
media/filters/audio_renderer_impl_unittest.cc
View file @ e27f0305
...@@ -117,7 +117,7 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -117,7 +117,7 @@ class AudioRendererImplTest : public ::testing::Test {
} }
MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&)); MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
MOCK_METHOD0(OnUnderflow, void()); MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
MOCK_METHOD1(OnError, void(PipelineStatus)); MOCK_METHOD1(OnError, void(PipelineStatus));
void OnAudioTimeCallback(TimeDelta current_time, TimeDelta max_time) { void OnAudioTimeCallback(TimeDelta current_time, TimeDelta max_time) {
...@@ -131,10 +131,10 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -131,10 +131,10 @@ class AudioRendererImplTest : public ::testing::Test {
pipeline_status_cb, pipeline_status_cb,
base::Bind(&AudioRendererImplTest::OnStatistics, base::Bind(&AudioRendererImplTest::OnStatistics,
base::Unretained(this)), base::Unretained(this)),
base::Bind(&AudioRendererImplTest::OnUnderflow,
base::Unretained(this)),
base::Bind(&AudioRendererImplTest::OnAudioTimeCallback, base::Bind(&AudioRendererImplTest::OnAudioTimeCallback,
base::Unretained(this)), base::Unretained(this)),
base::Bind(&AudioRendererImplTest::OnBufferingStateChange,
base::Unretained(this)),
ended_event_.GetClosure(), ended_event_.GetClosure(),
base::Bind(&AudioRendererImplTest::OnError, base::Bind(&AudioRendererImplTest::OnError,
base::Unretained(this))); base::Unretained(this)));
...@@ -200,6 +200,7 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -200,6 +200,7 @@ class AudioRendererImplTest : public ::testing::Test {
} }
void Flush() { void Flush() {
SCOPED_TRACE("Flush()");
WaitableMessageLoopEvent flush_event; WaitableMessageLoopEvent flush_event;
renderer_->Flush(flush_event.GetClosure()); renderer_->Flush(flush_event.GetClosure());
flush_event.RunAndWait(); flush_event.RunAndWait();
...@@ -218,11 +219,10 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -218,11 +219,10 @@ class AudioRendererImplTest : public ::testing::Test {
next_timestamp_->SetBaseTimestamp(timestamp); next_timestamp_->SetBaseTimestamp(timestamp);
// Fill entire buffer to complete prerolling. // Fill entire buffer to complete prerolling.
WaitableMessageLoopEvent event; renderer_->StartPlayingFrom(timestamp);
renderer_->Preroll(timestamp, event.GetPipelineStatusCB());
WaitForPendingRead(); WaitForPendingRead();
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
DeliverRemainingAudio(); DeliverRemainingAudio();
event.RunAndWaitForStatus(PIPELINE_OK);
// We should have no reads. // We should have no reads.
EXPECT_TRUE(decode_cb_.is_null()); EXPECT_TRUE(decode_cb_.is_null());
...@@ -360,10 +360,6 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -360,10 +360,6 @@ class AudioRendererImplTest : public ::testing::Test {
return buffer_capacity() - frames_buffered(); return buffer_capacity() - frames_buffered();
} }
void CallResumeAfterUnderflow() {
renderer_->ResumeAfterUnderflow();
}
TimeDelta CalculatePlayTime(int frames_filled) { TimeDelta CalculatePlayTime(int frames_filled) {
return TimeDelta::FromMicroseconds( return TimeDelta::FromMicroseconds(
frames_filled * Time::kMicrosecondsPerSecond / frames_filled * Time::kMicrosecondsPerSecond /
...@@ -377,6 +373,7 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -377,6 +373,7 @@ class AudioRendererImplTest : public ::testing::Test {
renderer_->SetPlaybackRate(playback_rate); renderer_->SetPlaybackRate(playback_rate);
// Drain internal buffer, we should have a pending read. // Drain internal buffer, we should have a pending read.
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
int total_frames = frames_buffered(); int total_frames = frames_buffered();
int frames_filled = ConsumeAllBufferedData(); int frames_filled = ConsumeAllBufferedData();
WaitForPendingRead(); WaitForPendingRead();
...@@ -394,6 +391,7 @@ class AudioRendererImplTest : public ::testing::Test { ...@@ -394,6 +391,7 @@ class AudioRendererImplTest : public ::testing::Test {
// Fulfill the read with an end-of-stream packet. We shouldn't report ended // Fulfill the read with an end-of-stream packet. We shouldn't report ended
// nor have a read until we drain the internal buffer. // nor have a read until we drain the internal buffer.
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
DeliverEndOfStream(); DeliverEndOfStream();
// Advance time half way without an ended expectation. // Advance time half way without an ended expectation.
...@@ -539,33 +537,28 @@ TEST_F(AudioRendererImplTest, EndOfStream_SlowerPlaybackSpeed) { ...@@ -539,33 +537,28 @@ TEST_F(AudioRendererImplTest, EndOfStream_SlowerPlaybackSpeed) {
TEST_F(AudioRendererImplTest, Underflow) { TEST_F(AudioRendererImplTest, Underflow) {
Initialize(); Initialize();
Preroll(); Preroll();
int initial_capacity = buffer_capacity();
StartRendering(); StartRendering();
// Drain internal buffer, we should have a pending read. // Drain internal buffer, we should have a pending read.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL)); EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead(); WaitForPendingRead();
// Verify the next FillBuffer() call triggers the underflow callback // Verify the next FillBuffer() call triggers a buffering state change
// since the decoder hasn't delivered any data after it was drained. // update.
EXPECT_CALL(*this, OnUnderflow()); EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL)); EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
renderer_->ResumeAfterUnderflow(); // Verify we're still not getting audio data.
// Verify after resuming that we're still not getting data.
bool muted = false; bool muted = false;
EXPECT_EQ(0, frames_buffered()); EXPECT_EQ(0, frames_buffered());
EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted)); EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
EXPECT_TRUE(muted); EXPECT_TRUE(muted);
// Verify that the buffer capacity increased as a result of the underflow. // Deliver enough data to have enough for buffering.
EXPECT_GT(buffer_capacity(), initial_capacity); EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
// Deliver data, we should get non-muted audio.
DeliverRemainingAudio(); DeliverRemainingAudio();
// Verify we're getting audio data.
EXPECT_TRUE(ConsumeBufferedData(kDataSize, &muted)); EXPECT_TRUE(ConsumeBufferedData(kDataSize, &muted));
EXPECT_FALSE(muted); EXPECT_FALSE(muted);
} }
...@@ -573,9 +566,6 @@ TEST_F(AudioRendererImplTest, Underflow) { ...@@ -573,9 +566,6 @@ TEST_F(AudioRendererImplTest, Underflow) {
TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) { TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) {
Initialize(); Initialize();
Preroll(); Preroll();
int initial_capacity = buffer_capacity();
StartRendering(); StartRendering();
// Drain internal buffer, we should have a pending read. // Drain internal buffer, we should have a pending read.
...@@ -584,13 +574,11 @@ TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) { ...@@ -584,13 +574,11 @@ TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) {
// Verify the next FillBuffer() call triggers the underflow callback // Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained. // since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow()); int initial_capacity = buffer_capacity();
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL)); EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
// Verify that the buffer capacity increased as a result of resuming after // Verify that the buffer capacity increased as a result of underflowing.
// underflow.
EXPECT_EQ(buffer_capacity(), initial_capacity);
renderer_->ResumeAfterUnderflow();
EXPECT_GT(buffer_capacity(), initial_capacity); EXPECT_GT(buffer_capacity(), initial_capacity);
// Verify that the buffer capacity is restored to the |initial_capacity|. // Verify that the buffer capacity is restored to the |initial_capacity|.
...@@ -599,177 +587,33 @@ TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) { ...@@ -599,177 +587,33 @@ TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) {
EXPECT_EQ(buffer_capacity(), initial_capacity); EXPECT_EQ(buffer_capacity(), initial_capacity);
} }
TEST_F(AudioRendererImplTest, Underflow_FlushWhileUnderflowed) { TEST_F(AudioRendererImplTest, Underflow_Flush) {
Initialize(); Initialize();
Preroll(); Preroll();
StartRendering(); StartRendering();
// Drain internal buffer, we should have a pending read. // Force underflow.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL)); EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead(); WaitForPendingRead();
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
// Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow());
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL)); EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
WaitForPendingRead();
StopRendering();
// Verify that we can still Flush() before entering the rebuffering state. // We shouldn't expect another buffering state change whenn flushing.
AbortPendingRead(); AbortPendingRead();
Flush(); Flush();
} }
TEST_F(AudioRendererImplTest, Underflow_EndOfStream) {
Initialize();
Preroll();
StartRendering();
// Figure out how long until the ended event should fire. Since
// ConsumeBufferedData() doesn't provide audio delay information, the time
// until the ended event fires is equivalent to the longest buffered section,
// which is the initial frames_buffered() read.
TimeDelta time_until_ended = CalculatePlayTime(frames_buffered());
// Drain internal buffer, we should have a pending read.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead();
// Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow());
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
// Deliver a little bit of data.
SatisfyPendingRead(kDataSize);
WaitForPendingRead();
// Verify we're getting muted audio during underflow. Note: Since resampling
// is active, the number of frames_buffered() won't always match kDataSize.
bool muted = false;
const int kInitialFramesBuffered = 1114;
EXPECT_EQ(kInitialFramesBuffered, frames_buffered());
EXPECT_FALSE(ConsumeBufferedData(kInitialFramesBuffered, &muted));
EXPECT_TRUE(muted);
// Now deliver end of stream, we should get our little bit of data back.
DeliverEndOfStream();
const int kNextFramesBuffered = 1408;
EXPECT_EQ(kNextFramesBuffered, frames_buffered());
EXPECT_TRUE(ConsumeBufferedData(kNextFramesBuffered, &muted));
EXPECT_FALSE(muted);
// Attempt to read to make sure we're truly at the end of stream.
AdvanceTime(time_until_ended);
EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
EXPECT_TRUE(muted);
WaitForEnded();
}
TEST_F(AudioRendererImplTest, Underflow_ResumeFromCallback) {
Initialize();
Preroll();
StartRendering();
// Drain internal buffer, we should have a pending read.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead();
// Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow())
.WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
// Verify after resuming that we're still not getting data.
bool muted = false;
EXPECT_EQ(0, frames_buffered());
EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
EXPECT_TRUE(muted);
// Deliver data, we should get non-muted audio.
DeliverRemainingAudio();
EXPECT_TRUE(ConsumeBufferedData(kDataSize, &muted));
EXPECT_FALSE(muted);
}
TEST_F(AudioRendererImplTest, Underflow_SetPlaybackRate) {
Initialize();
Preroll();
StartRendering();
// Drain internal buffer, we should have a pending read.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead();
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
// Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow())
.WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
EXPECT_EQ(0, frames_buffered());
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
// Simulate playback being paused.
renderer_->SetPlaybackRate(0);
EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
// Deliver data to resolve the underflow.
DeliverRemainingAudio();
EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
// Simulate playback being resumed.
renderer_->SetPlaybackRate(1);
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
}
TEST_F(AudioRendererImplTest, Underflow_PausePlay) {
Initialize();
Preroll();
StartRendering();
// Drain internal buffer, we should have a pending read.
EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
WaitForPendingRead();
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
// Verify the next FillBuffer() call triggers the underflow callback
// since the decoder hasn't delivered any data after it was drained.
EXPECT_CALL(*this, OnUnderflow())
.WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
EXPECT_EQ(0, frames_buffered());
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
// Simulate playback being paused, and then played again.
renderer_->SetPlaybackRate(0.0);
renderer_->SetPlaybackRate(1.0);
// Deliver data to resolve the underflow.
DeliverRemainingAudio();
// We should have resumed playing now.
EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
}
TEST_F(AudioRendererImplTest, AbortPendingRead_Preroll) { TEST_F(AudioRendererImplTest, AbortPendingRead_Preroll) {
Initialize(); Initialize();
// Start prerolling and wait for a read. // Start prerolling and wait for a read.
WaitableMessageLoopEvent event; renderer_->StartPlayingFrom(TimeDelta());
renderer_->Preroll(TimeDelta(), event.GetPipelineStatusCB());
WaitForPendingRead(); WaitForPendingRead();
// Simulate the decoder aborting the pending read. // Simulate the decoder aborting the pending read.
AbortPendingRead(); AbortPendingRead();
event.RunAndWaitForStatus(PIPELINE_OK);
Flush(); Flush();
// Preroll again to a different timestamp and verify it completed normally. // Preroll again to a different timestamp and verify it completed normally.
...@@ -796,6 +640,7 @@ TEST_F(AudioRendererImplTest, AbortPendingRead_Flush) { ...@@ -796,6 +640,7 @@ TEST_F(AudioRendererImplTest, AbortPendingRead_Flush) {
// Simulate the decoder aborting the pending read. // Simulate the decoder aborting the pending read.
AbortPendingRead(); AbortPendingRead();
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
flush_event.RunAndWait(); flush_event.RunAndWait();
EXPECT_FALSE(IsReadPending()); EXPECT_FALSE(IsReadPending());
...@@ -823,7 +668,7 @@ TEST_F(AudioRendererImplTest, PendingRead_Flush) { ...@@ -823,7 +668,7 @@ TEST_F(AudioRendererImplTest, PendingRead_Flush) {
renderer_->Flush(flush_event.GetClosure()); renderer_->Flush(flush_event.GetClosure());
SatisfyPendingRead(kDataSize); SatisfyPendingRead(kDataSize);
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
flush_event.RunAndWait(); flush_event.RunAndWait();
EXPECT_FALSE(IsReadPending()); EXPECT_FALSE(IsReadPending());
...@@ -942,11 +787,10 @@ TEST_F(AudioRendererImplTest, ImmediateEndOfStream) { ...@@ -942,11 +787,10 @@ TEST_F(AudioRendererImplTest, ImmediateEndOfStream) {
Initialize(); Initialize();
{ {
SCOPED_TRACE("Preroll()"); SCOPED_TRACE("Preroll()");
WaitableMessageLoopEvent event; renderer_->StartPlayingFrom(base::TimeDelta());
renderer_->Preroll(base::TimeDelta(), event.GetPipelineStatusCB());
WaitForPendingRead(); WaitForPendingRead();
EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
DeliverEndOfStream(); DeliverEndOfStream();
event.RunAndWaitForStatus(PIPELINE_OK);
} }
StartRendering(); StartRendering();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment