Home | History | Annotate | Download | only in filters 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/bind.h"
      6 #include "base/callback_helpers.h"
      7 #include "base/gtest_prod_util.h"
      8 #include "base/memory/scoped_vector.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/run_loop.h"
     11 #include "base/stl_util.h"
     12 #include "base/strings/stringprintf.h"
     13 #include "media/base/audio_buffer.h"
     14 #include "media/base/audio_buffer_converter.h"
     15 #include "media/base/audio_hardware_config.h"
     16 #include "media/base/audio_splicer.h"
     17 #include "media/base/audio_timestamp_helper.h"
     18 #include "media/base/fake_audio_renderer_sink.h"
     19 #include "media/base/gmock_callback_support.h"
     20 #include "media/base/mock_filters.h"
     21 #include "media/base/test_helpers.h"
     22 #include "media/filters/audio_renderer_impl.h"
     23 #include "testing/gtest/include/gtest/gtest.h"
     24 
     25 using ::base::Time;
     26 using ::base::TimeTicks;
     27 using ::base::TimeDelta;
     28 using ::testing::_;
     29 using ::testing::AnyNumber;
     30 using ::testing::Invoke;
     31 using ::testing::Return;
     32 using ::testing::SaveArg;
     33 
     34 namespace media {
     35 
     36 // Constants to specify the type of audio data used.
     37 static AudioCodec kCodec = kCodecVorbis;
     38 static SampleFormat kSampleFormat = kSampleFormatPlanarF32;
     39 static ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
     40 static int kChannelCount = 2;
     41 static int kChannels = ChannelLayoutToChannelCount(kChannelLayout);
     42 static int kSamplesPerSecond = 44100;
     43 // Use a different output sample rate so the AudioBufferConverter is invoked.
     44 static int kOutputSamplesPerSecond = 48000;
     45 
     46 // Constants for distinguishing between muted audio and playing audio when using
     47 // ConsumeBufferedData(). Must match the type needed by kSampleFormat.
     48 static float kMutedAudio = 0.0f;
     49 static float kPlayingAudio = 0.5f;
     50 
     51 static const int kDataSize = 1024;
     52 
     53 ACTION_P(EnterPendingDecoderInitStateAction, test) {
     54   test->EnterPendingDecoderInitState(arg1);
     55 }
     56 
     57 class AudioRendererImplTest : public ::testing::Test {
     58  public:
     59   // Give the decoder some non-garbage media properties.
     60   AudioRendererImplTest()
     61       : hardware_config_(AudioParameters(), AudioParameters()),
     62         needs_stop_(true),
     63         demuxer_stream_(DemuxerStream::AUDIO),
     64         decoder_(new MockAudioDecoder()),
     65         last_time_update_(kNoTimestamp()) {
     66     AudioDecoderConfig audio_config(kCodec,
     67                                     kSampleFormat,
     68                                     kChannelLayout,
     69                                     kSamplesPerSecond,
     70                                     NULL,
     71                                     0,
     72                                     false);
     73     demuxer_stream_.set_audio_decoder_config(audio_config);
     74 
     75     // Used to save callbacks and run them at a later time.
     76     EXPECT_CALL(*decoder_, Decode(_, _))
     77         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
     78     EXPECT_CALL(*decoder_, Reset(_))
     79         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
     80 
     81     // Mock out demuxer reads.
     82     EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
     83         RunCallback<0>(DemuxerStream::kOk,
     84                        scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
     85     EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
     86         .WillRepeatedly(Return(true));
     87     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
     88                                kChannelLayout,
     89                                kOutputSamplesPerSecond,
     90                                SampleFormatToBytesPerChannel(kSampleFormat) * 8,
     91                                512);
     92     hardware_config_.UpdateOutputConfig(out_params);
     93     ScopedVector<AudioDecoder> decoders;
     94     decoders.push_back(decoder_);
     95     sink_ = new FakeAudioRendererSink();
     96     renderer_.reset(new AudioRendererImpl(message_loop_.message_loop_proxy(),
     97                                           sink_,
     98                                           decoders.Pass(),
     99                                           SetDecryptorReadyCB(),
    100                                           &hardware_config_));
    101 
    102     // Stub out time.
    103     renderer_->set_now_cb_for_testing(base::Bind(
    104         &AudioRendererImplTest::GetTime, base::Unretained(this)));
    105   }
    106 
    107   virtual ~AudioRendererImplTest() {
    108     SCOPED_TRACE("~AudioRendererImplTest()");
    109     if (needs_stop_) {
    110       WaitableMessageLoopEvent event;
    111       renderer_->Stop(event.GetClosure());
    112       event.RunAndWait();
    113     }
    114   }
    115 
    116   void ExpectUnsupportedAudioDecoder() {
    117     EXPECT_CALL(*decoder_, Initialize(_, _, _))
    118         .WillOnce(DoAll(SaveArg<2>(&output_cb_),
    119                         RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED)));
    120   }
    121 
    122   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
    123   MOCK_METHOD0(OnUnderflow, void());
    124   MOCK_METHOD1(OnError, void(PipelineStatus));
    125 
    126   void OnAudioTimeCallback(TimeDelta current_time, TimeDelta max_time) {
    127     CHECK(current_time <= max_time);
    128     last_time_update_ = current_time;
    129   }
    130 
    131   void InitializeRenderer(const PipelineStatusCB& pipeline_status_cb) {
    132     renderer_->Initialize(
    133         &demuxer_stream_,
    134         pipeline_status_cb,
    135         base::Bind(&AudioRendererImplTest::OnStatistics,
    136                    base::Unretained(this)),
    137         base::Bind(&AudioRendererImplTest::OnUnderflow,
    138                    base::Unretained(this)),
    139         base::Bind(&AudioRendererImplTest::OnAudioTimeCallback,
    140                    base::Unretained(this)),
    141         ended_event_.GetClosure(),
    142         base::Bind(&AudioRendererImplTest::OnError,
    143                    base::Unretained(this)));
    144   }
    145 
    146   void Initialize() {
    147     EXPECT_CALL(*decoder_, Initialize(_, _, _))
    148         .WillOnce(DoAll(SaveArg<2>(&output_cb_),
    149                         RunCallback<1>(PIPELINE_OK)));
    150     EXPECT_CALL(*decoder_, Stop());
    151     InitializeWithStatus(PIPELINE_OK);
    152 
    153     next_timestamp_.reset(new AudioTimestampHelper(
    154         hardware_config_.GetOutputConfig().sample_rate()));
    155   }
    156 
    157   void InitializeWithStatus(PipelineStatus expected) {
    158     SCOPED_TRACE(base::StringPrintf("InitializeWithStatus(%d)", expected));
    159 
    160     WaitableMessageLoopEvent event;
    161     InitializeRenderer(event.GetPipelineStatusCB());
    162     event.RunAndWaitForStatus(expected);
    163 
    164     // We should have no reads.
    165     EXPECT_TRUE(decode_cb_.is_null());
    166   }
    167 
    168   void InitializeAndStop() {
    169     EXPECT_CALL(*decoder_, Initialize(_, _, _))
    170         .WillOnce(DoAll(SaveArg<2>(&output_cb_),
    171                         RunCallback<1>(PIPELINE_OK)));
    172     EXPECT_CALL(*decoder_, Stop());
    173 
    174     WaitableMessageLoopEvent event;
    175     InitializeRenderer(event.GetPipelineStatusCB());
    176 
    177     // Stop before we let the MessageLoop run, this simulates an interleaving
    178     // in which we end up calling Stop() while the OnDecoderSelected callback
    179     // is in flight.
    180     renderer_->Stop(NewExpectedClosure());
    181     event.RunAndWaitForStatus(PIPELINE_ERROR_ABORT);
    182     EXPECT_EQ(renderer_->state_, AudioRendererImpl::kStopped);
    183   }
    184 
    185   void InitializeAndStopDuringDecoderInit() {
    186     EXPECT_CALL(*decoder_, Initialize(_, _, _))
    187         .WillOnce(DoAll(SaveArg<2>(&output_cb_),
    188                         EnterPendingDecoderInitStateAction(this)));
    189     EXPECT_CALL(*decoder_, Stop());
    190 
    191     WaitableMessageLoopEvent event;
    192     InitializeRenderer(event.GetPipelineStatusCB());
    193 
    194     base::RunLoop().RunUntilIdle();
    195     DCHECK(!init_decoder_cb_.is_null());
    196 
    197     renderer_->Stop(NewExpectedClosure());
    198     base::ResetAndReturn(&init_decoder_cb_).Run(PIPELINE_OK);
    199 
    200     event.RunAndWaitForStatus(PIPELINE_ERROR_ABORT);
    201     EXPECT_EQ(renderer_->state_, AudioRendererImpl::kStopped);
    202   }
    203 
    204   void EnterPendingDecoderInitState(PipelineStatusCB cb) {
    205     init_decoder_cb_ = cb;
    206   }
    207 
    208   void Flush() {
    209     WaitableMessageLoopEvent flush_event;
    210     renderer_->Flush(flush_event.GetClosure());
    211     flush_event.RunAndWait();
    212 
    213     EXPECT_FALSE(IsReadPending());
    214   }
    215 
    216   void Preroll() {
    217     Preroll(0, PIPELINE_OK);
    218   }
    219 
    220   void Preroll(int timestamp_ms, PipelineStatus expected) {
    221     SCOPED_TRACE(base::StringPrintf("Preroll(%d, %d)", timestamp_ms, expected));
    222 
    223     TimeDelta timestamp = TimeDelta::FromMilliseconds(timestamp_ms);
    224     next_timestamp_->SetBaseTimestamp(timestamp);
    225 
    226     // Fill entire buffer to complete prerolling.
    227     WaitableMessageLoopEvent event;
    228     renderer_->Preroll(timestamp, event.GetPipelineStatusCB());
    229     WaitForPendingRead();
    230     DeliverRemainingAudio();
    231     event.RunAndWaitForStatus(PIPELINE_OK);
    232   }
    233 
    234   void StartRendering() {
    235     renderer_->StartRendering();
    236     renderer_->SetPlaybackRate(1.0f);
    237   }
    238 
    239   void StopRendering() {
    240     renderer_->StopRendering();
    241   }
    242 
    243   void Seek() {
    244     StopRendering();
    245     Flush();
    246     Preroll();
    247   }
    248 
    249   void WaitForEnded() {
    250     SCOPED_TRACE("WaitForEnded()");
    251     ended_event_.RunAndWait();
    252   }
    253 
    254   bool IsReadPending() const {
    255     return !decode_cb_.is_null();
    256   }
    257 
    258   void WaitForPendingRead() {
    259     SCOPED_TRACE("WaitForPendingRead()");
    260     if (!decode_cb_.is_null())
    261       return;
    262 
    263     DCHECK(wait_for_pending_decode_cb_.is_null());
    264 
    265     WaitableMessageLoopEvent event;
    266     wait_for_pending_decode_cb_ = event.GetClosure();
    267     event.RunAndWait();
    268 
    269     DCHECK(!decode_cb_.is_null());
    270     DCHECK(wait_for_pending_decode_cb_.is_null());
    271   }
    272 
    273   // Delivers |size| frames with value kPlayingAudio to |renderer_|.
    274   void SatisfyPendingRead(int size) {
    275     CHECK_GT(size, 0);
    276     CHECK(!decode_cb_.is_null());
    277 
    278     scoped_refptr<AudioBuffer> buffer =
    279         MakeAudioBuffer<float>(kSampleFormat,
    280                                kChannelLayout,
    281                                kChannelCount,
    282                                kSamplesPerSecond,
    283                                kPlayingAudio,
    284                                0.0f,
    285                                size,
    286                                next_timestamp_->GetTimestamp());
    287     next_timestamp_->AddFrames(size);
    288 
    289     DeliverBuffer(AudioDecoder::kOk, buffer);
    290   }
    291 
    292   void DeliverEndOfStream() {
    293     DCHECK(!decode_cb_.is_null());
    294 
    295     // Return EOS buffer to trigger EOS frame.
    296     EXPECT_CALL(demuxer_stream_, Read(_))
    297         .WillOnce(RunCallback<0>(DemuxerStream::kOk,
    298                                  DecoderBuffer::CreateEOSBuffer()));
    299 
    300     // Satify pending |decode_cb_| to trigger a new DemuxerStream::Read().
    301     message_loop_.PostTask(
    302         FROM_HERE,
    303         base::Bind(base::ResetAndReturn(&decode_cb_), AudioDecoder::kOk));
    304 
    305     WaitForPendingRead();
    306 
    307     message_loop_.PostTask(
    308         FROM_HERE,
    309         base::Bind(base::ResetAndReturn(&decode_cb_), AudioDecoder::kOk));
    310 
    311     message_loop_.RunUntilIdle();
    312   }
    313 
    314   // Delivers frames until |renderer_|'s internal buffer is full and no longer
    315   // has pending reads.
    316   void DeliverRemainingAudio() {
    317     SatisfyPendingRead(frames_remaining_in_buffer());
    318   }
    319 
    320   // Attempts to consume |requested_frames| frames from |renderer_|'s internal
    321   // buffer, returning true if all |requested_frames| frames were consumed,
    322   // false if less than |requested_frames| frames were consumed.
    323   //
    324   // |muted| is optional and if passed will get set if the value of
    325   // the consumed data is muted audio.
    326   bool ConsumeBufferedData(int requested_frames, bool* muted) {
    327     scoped_ptr<AudioBus> bus =
    328         AudioBus::Create(kChannels, std::max(requested_frames, 1));
    329     int frames_read;
    330     if (!sink_->Render(bus.get(), 0, &frames_read)) {
    331       if (muted)
    332         *muted = true;
    333       return false;
    334     }
    335 
    336     if (muted)
    337       *muted = frames_read < 1 || bus->channel(0)[0] == kMutedAudio;
    338     return frames_read == requested_frames;
    339   }
    340 
    341   // Attempts to consume all data available from the renderer.  Returns the
    342   // number of frames read.  Since time is frozen, the audio delay will increase
    343   // as frames come in.
    344   int ConsumeAllBufferedData() {
    345     int frames_read = 0;
    346     int total_frames_read = 0;
    347 
    348     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, 1024);
    349 
    350     do {
    351       TimeDelta audio_delay = TimeDelta::FromMicroseconds(
    352           total_frames_read * Time::kMicrosecondsPerSecond /
    353           static_cast<float>(hardware_config_.GetOutputConfig().sample_rate()));
    354 
    355       frames_read = renderer_->Render(
    356           bus.get(), audio_delay.InMilliseconds());
    357       total_frames_read += frames_read;
    358     } while (frames_read > 0);
    359 
    360     return total_frames_read;
    361   }
    362 
    363   int frames_buffered() {
    364     return renderer_->algorithm_->frames_buffered();
    365   }
    366 
    367   int buffer_capacity() {
    368     return renderer_->algorithm_->QueueCapacity();
    369   }
    370 
    371   int frames_remaining_in_buffer() {
    372     // This can happen if too much data was delivered, in which case the buffer
    373     // will accept the data but not increase capacity.
    374     if (frames_buffered() > buffer_capacity()) {
    375       return 0;
    376     }
    377     return buffer_capacity() - frames_buffered();
    378   }
    379 
    380   void CallResumeAfterUnderflow() {
    381     renderer_->ResumeAfterUnderflow();
    382   }
    383 
    384   TimeDelta CalculatePlayTime(int frames_filled) {
    385     return TimeDelta::FromMicroseconds(
    386         frames_filled * Time::kMicrosecondsPerSecond /
    387         renderer_->audio_parameters_.sample_rate());
    388   }
    389 
    390   void EndOfStreamTest(float playback_rate) {
    391     Initialize();
    392     Preroll();
    393     StartRendering();
    394     renderer_->SetPlaybackRate(playback_rate);
    395 
    396     // Drain internal buffer, we should have a pending read.
    397     int total_frames = frames_buffered();
    398     int frames_filled = ConsumeAllBufferedData();
    399     WaitForPendingRead();
    400 
    401     // Due to how the cross-fade algorithm works we won't get an exact match
    402     // between the ideal and expected number of frames consumed.  In the faster
    403     // than normal playback case, more frames are created than should exist and
    404     // vice versa in the slower than normal playback case.
    405     const float kEpsilon = 0.20 * (total_frames / playback_rate);
    406     EXPECT_NEAR(frames_filled, total_frames / playback_rate, kEpsilon);
    407 
    408     // Figure out how long until the ended event should fire.
    409     TimeDelta audio_play_time = CalculatePlayTime(frames_filled);
    410     DVLOG(1) << "audio_play_time = " << audio_play_time.InSecondsF();
    411 
    412     // Fulfill the read with an end-of-stream packet.  We shouldn't report ended
    413     // nor have a read until we drain the internal buffer.
    414     DeliverEndOfStream();
    415 
    416     // Advance time half way without an ended expectation.
    417     AdvanceTime(audio_play_time / 2);
    418     ConsumeBufferedData(frames_buffered(), NULL);
    419 
    420     // Advance time by other half and expect the ended event.
    421     AdvanceTime(audio_play_time / 2);
    422     ConsumeBufferedData(frames_buffered(), NULL);
    423     WaitForEnded();
    424   }
    425 
    426   void AdvanceTime(TimeDelta time) {
    427     base::AutoLock auto_lock(lock_);
    428     time_ += time;
    429   }
    430 
    431   void force_config_change() {
    432     renderer_->OnConfigChange();
    433   }
    434 
    435   int converter_input_frames_left() const {
    436     return renderer_->buffer_converter_->input_frames_left_for_testing();
    437   }
    438 
    439   bool splicer_has_next_buffer() const {
    440     return renderer_->splicer_->HasNextBuffer();
    441   }
    442 
    443   base::TimeDelta last_time_update() const {
    444     return last_time_update_;
    445   }
    446 
    447   // Fixture members.
    448   base::MessageLoop message_loop_;
    449   scoped_ptr<AudioRendererImpl> renderer_;
    450   scoped_refptr<FakeAudioRendererSink> sink_;
    451   AudioHardwareConfig hardware_config_;
    452 
    453   // Whether or not the test needs the destructor to call Stop() on
    454   // |renderer_| at destruction.
    455   bool needs_stop_;
    456 
    457  private:
    458   TimeTicks GetTime() {
    459     base::AutoLock auto_lock(lock_);
    460     return time_;
    461   }
    462 
    463   void DecodeDecoder(const scoped_refptr<DecoderBuffer>& buffer,
    464                      const AudioDecoder::DecodeCB& decode_cb) {
    465     // We shouldn't ever call Read() after Stop():
    466     EXPECT_TRUE(stop_decoder_cb_.is_null());
    467 
    468     // TODO(scherkus): Make this a DCHECK after threading semantics are fixed.
    469     if (base::MessageLoop::current() != &message_loop_) {
    470       message_loop_.PostTask(FROM_HERE, base::Bind(
    471           &AudioRendererImplTest::DecodeDecoder,
    472           base::Unretained(this), buffer, decode_cb));
    473       return;
    474     }
    475 
    476     CHECK(decode_cb_.is_null()) << "Overlapping decodes are not permitted";
    477     decode_cb_ = decode_cb;
    478 
    479     // Wake up WaitForPendingRead() if needed.
    480     if (!wait_for_pending_decode_cb_.is_null())
    481       base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
    482   }
    483 
    484   void ResetDecoder(const base::Closure& reset_cb) {
    485     if (!decode_cb_.is_null()) {
    486       // |reset_cb| will be called in DeliverBuffer(), after the decoder is
    487       // flushed.
    488       reset_cb_ = reset_cb;
    489       return;
    490     }
    491 
    492     message_loop_.PostTask(FROM_HERE, reset_cb);
    493   }
    494 
    495   void DeliverBuffer(AudioDecoder::Status status,
    496                      const scoped_refptr<AudioBuffer>& buffer) {
    497     CHECK(!decode_cb_.is_null());
    498     if (buffer && !buffer->end_of_stream())
    499       output_cb_.Run(buffer);
    500     base::ResetAndReturn(&decode_cb_).Run(status);
    501 
    502     if (!reset_cb_.is_null())
    503       base::ResetAndReturn(&reset_cb_).Run();
    504 
    505     message_loop_.RunUntilIdle();
    506   }
    507 
    508   MockDemuxerStream demuxer_stream_;
    509   MockAudioDecoder* decoder_;
    510 
    511   // Used for stubbing out time in the audio callback thread.
    512   base::Lock lock_;
    513   TimeTicks time_;
    514 
    515   // Used for satisfying reads.
    516   AudioDecoder::OutputCB output_cb_;
    517   AudioDecoder::DecodeCB decode_cb_;
    518   base::Closure reset_cb_;
    519   scoped_ptr<AudioTimestampHelper> next_timestamp_;
    520 
    521   WaitableMessageLoopEvent ended_event_;
    522 
    523   // Run during DecodeDecoder() to unblock WaitForPendingRead().
    524   base::Closure wait_for_pending_decode_cb_;
    525   base::Closure stop_decoder_cb_;
    526 
    527   PipelineStatusCB init_decoder_cb_;
    528   base::TimeDelta last_time_update_;
    529 
    530   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
    531 };
    532 
    533 TEST_F(AudioRendererImplTest, Initialize_Successful) {
    534   Initialize();
    535 }
    536 
    537 TEST_F(AudioRendererImplTest, Initialize_DecoderInitFailure) {
    538   ExpectUnsupportedAudioDecoder();
    539   InitializeWithStatus(DECODER_ERROR_NOT_SUPPORTED);
    540 }
    541 
    542 TEST_F(AudioRendererImplTest, Preroll) {
    543   Initialize();
    544   Preroll();
    545 }
    546 
    547 TEST_F(AudioRendererImplTest, StartRendering) {
    548   Initialize();
    549   Preroll();
    550   StartRendering();
    551 
    552   // Drain internal buffer, we should have a pending read.
    553   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    554   WaitForPendingRead();
    555 }
    556 
    557 TEST_F(AudioRendererImplTest, EndOfStream) {
    558   EndOfStreamTest(1.0);
    559 }
    560 
    561 TEST_F(AudioRendererImplTest, EndOfStream_FasterPlaybackSpeed) {
    562   EndOfStreamTest(2.0);
    563 }
    564 
    565 TEST_F(AudioRendererImplTest, EndOfStream_SlowerPlaybackSpeed) {
    566   EndOfStreamTest(0.5);
    567 }
    568 
    569 TEST_F(AudioRendererImplTest, Underflow) {
    570   Initialize();
    571   Preroll();
    572 
    573   int initial_capacity = buffer_capacity();
    574 
    575   StartRendering();
    576 
    577   // Drain internal buffer, we should have a pending read.
    578   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    579   WaitForPendingRead();
    580 
    581   // Verify the next FillBuffer() call triggers the underflow callback
    582   // since the decoder hasn't delivered any data after it was drained.
    583   EXPECT_CALL(*this, OnUnderflow());
    584   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    585 
    586   renderer_->ResumeAfterUnderflow();
    587 
    588   // Verify after resuming that we're still not getting data.
    589   bool muted = false;
    590   EXPECT_EQ(0, frames_buffered());
    591   EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
    592   EXPECT_TRUE(muted);
    593 
    594   // Verify that the buffer capacity increased as a result of the underflow.
    595   EXPECT_GT(buffer_capacity(), initial_capacity);
    596 
    597   // Deliver data, we should get non-muted audio.
    598   DeliverRemainingAudio();
    599   EXPECT_TRUE(ConsumeBufferedData(kDataSize, &muted));
    600   EXPECT_FALSE(muted);
    601 }
    602 
    603 TEST_F(AudioRendererImplTest, Underflow_CapacityResetsAfterFlush) {
    604   Initialize();
    605   Preroll();
    606 
    607   int initial_capacity = buffer_capacity();
    608 
    609   StartRendering();
    610 
    611   // Drain internal buffer, we should have a pending read.
    612   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    613   WaitForPendingRead();
    614 
    615   // Verify the next FillBuffer() call triggers the underflow callback
    616   // since the decoder hasn't delivered any data after it was drained.
    617   EXPECT_CALL(*this, OnUnderflow());
    618   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    619 
    620   // Verify that the buffer capacity increased as a result of resuming after
    621   // underflow.
    622   EXPECT_EQ(buffer_capacity(), initial_capacity);
    623   renderer_->ResumeAfterUnderflow();
    624   EXPECT_GT(buffer_capacity(), initial_capacity);
    625 
    626   // Verify that the buffer capacity is restored to the |initial_capacity|.
    627   DeliverEndOfStream();
    628   Flush();
    629   EXPECT_EQ(buffer_capacity(), initial_capacity);
    630 }
    631 
    632 TEST_F(AudioRendererImplTest, Underflow_FlushWhileUnderflowed) {
    633   Initialize();
    634   Preroll();
    635   StartRendering();
    636 
    637   // Drain internal buffer, we should have a pending read.
    638   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    639   WaitForPendingRead();
    640 
    641   // Verify the next FillBuffer() call triggers the underflow callback
    642   // since the decoder hasn't delivered any data after it was drained.
    643   EXPECT_CALL(*this, OnUnderflow());
    644   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    645 
    646   // Verify that we can still Flush() before entering the rebuffering state.
    647   DeliverEndOfStream();
    648   Flush();
    649 }
    650 
    651 TEST_F(AudioRendererImplTest, Underflow_EndOfStream) {
    652   Initialize();
    653   Preroll();
    654   StartRendering();
    655 
    656   // Figure out how long until the ended event should fire.  Since
    657   // ConsumeBufferedData() doesn't provide audio delay information, the time
    658   // until the ended event fires is equivalent to the longest buffered section,
    659   // which is the initial frames_buffered() read.
    660   TimeDelta time_until_ended = CalculatePlayTime(frames_buffered());
    661 
    662   // Drain internal buffer, we should have a pending read.
    663   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    664   WaitForPendingRead();
    665 
    666   // Verify the next FillBuffer() call triggers the underflow callback
    667   // since the decoder hasn't delivered any data after it was drained.
    668   EXPECT_CALL(*this, OnUnderflow());
    669   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    670 
    671   // Deliver a little bit of data.
    672   SatisfyPendingRead(kDataSize);
    673   WaitForPendingRead();
    674 
    675   // Verify we're getting muted audio during underflow.  Note: Since resampling
    676   // is active, the number of frames_buffered() won't always match kDataSize.
    677   bool muted = false;
    678   const int kInitialFramesBuffered = 1114;
    679   EXPECT_EQ(kInitialFramesBuffered, frames_buffered());
    680   EXPECT_FALSE(ConsumeBufferedData(kInitialFramesBuffered, &muted));
    681   EXPECT_TRUE(muted);
    682 
    683   // Now deliver end of stream, we should get our little bit of data back.
    684   DeliverEndOfStream();
    685   const int kNextFramesBuffered = 1408;
    686   EXPECT_EQ(kNextFramesBuffered, frames_buffered());
    687   EXPECT_TRUE(ConsumeBufferedData(kNextFramesBuffered, &muted));
    688   EXPECT_FALSE(muted);
    689 
    690   // Attempt to read to make sure we're truly at the end of stream.
    691   AdvanceTime(time_until_ended);
    692   EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
    693   EXPECT_TRUE(muted);
    694   WaitForEnded();
    695 }
    696 
    697 TEST_F(AudioRendererImplTest, Underflow_ResumeFromCallback) {
    698   Initialize();
    699   Preroll();
    700   StartRendering();
    701 
    702   // Drain internal buffer, we should have a pending read.
    703   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    704   WaitForPendingRead();
    705 
    706   // Verify the next FillBuffer() call triggers the underflow callback
    707   // since the decoder hasn't delivered any data after it was drained.
    708   EXPECT_CALL(*this, OnUnderflow())
    709       .WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
    710   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    711 
    712   // Verify after resuming that we're still not getting data.
    713   bool muted = false;
    714   EXPECT_EQ(0, frames_buffered());
    715   EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
    716   EXPECT_TRUE(muted);
    717 
    718   // Deliver data, we should get non-muted audio.
    719   DeliverRemainingAudio();
    720   EXPECT_TRUE(ConsumeBufferedData(kDataSize, &muted));
    721   EXPECT_FALSE(muted);
    722 }
    723 
    724 TEST_F(AudioRendererImplTest, Underflow_SetPlaybackRate) {
    725   Initialize();
    726   Preroll();
    727   StartRendering();
    728 
    729   // Drain internal buffer, we should have a pending read.
    730   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    731   WaitForPendingRead();
    732 
    733   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    734 
    735   // Verify the next FillBuffer() call triggers the underflow callback
    736   // since the decoder hasn't delivered any data after it was drained.
    737   EXPECT_CALL(*this, OnUnderflow())
    738       .WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
    739   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    740   EXPECT_EQ(0, frames_buffered());
    741 
    742   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    743 
    744   // Simulate playback being paused.
    745   renderer_->SetPlaybackRate(0);
    746 
    747   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    748 
    749   // Deliver data to resolve the underflow.
    750   DeliverRemainingAudio();
    751 
    752   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    753 
    754   // Simulate playback being resumed.
    755   renderer_->SetPlaybackRate(1);
    756 
    757   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    758 }
    759 
    760 TEST_F(AudioRendererImplTest, Underflow_PausePlay) {
    761   Initialize();
    762   Preroll();
    763   StartRendering();
    764 
    765   // Drain internal buffer, we should have a pending read.
    766   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    767   WaitForPendingRead();
    768 
    769   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    770 
    771   // Verify the next FillBuffer() call triggers the underflow callback
    772   // since the decoder hasn't delivered any data after it was drained.
    773   EXPECT_CALL(*this, OnUnderflow())
    774       .WillOnce(Invoke(this, &AudioRendererImplTest::CallResumeAfterUnderflow));
    775   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
    776   EXPECT_EQ(0, frames_buffered());
    777 
    778   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    779 
    780   // Simulate playback being paused, and then played again.
    781   renderer_->SetPlaybackRate(0.0);
    782   renderer_->SetPlaybackRate(1.0);
    783 
    784   // Deliver data to resolve the underflow.
    785   DeliverRemainingAudio();
    786 
    787   // We should have resumed playing now.
    788   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    789 }
    790 
    791 TEST_F(AudioRendererImplTest, PendingRead_Flush) {
    792   Initialize();
    793 
    794   Preroll();
    795   StartRendering();
    796 
    797   // Partially drain internal buffer so we get a pending read.
    798   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
    799   WaitForPendingRead();
    800 
    801   StopRendering();
    802 
    803   EXPECT_TRUE(IsReadPending());
    804 
    805   // Start flushing.
    806   WaitableMessageLoopEvent flush_event;
    807   renderer_->Flush(flush_event.GetClosure());
    808 
    809   SatisfyPendingRead(kDataSize);
    810 
    811   flush_event.RunAndWait();
    812 
    813   EXPECT_FALSE(IsReadPending());
    814 
    815   // Preroll again to a different timestamp and verify it completed normally.
    816   Preroll(1000, PIPELINE_OK);
    817 }
    818 
    819 TEST_F(AudioRendererImplTest, PendingRead_Stop) {
    820   Initialize();
    821 
    822   Preroll();
    823   StartRendering();
    824 
    825   // Partially drain internal buffer so we get a pending read.
    826   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
    827   WaitForPendingRead();
    828 
    829   StopRendering();
    830 
    831   EXPECT_TRUE(IsReadPending());
    832 
    833   WaitableMessageLoopEvent stop_event;
    834   renderer_->Stop(stop_event.GetClosure());
    835   needs_stop_ = false;
    836 
    837   SatisfyPendingRead(kDataSize);
    838 
    839   stop_event.RunAndWait();
    840 
    841   EXPECT_FALSE(IsReadPending());
    842 }
    843 
    844 TEST_F(AudioRendererImplTest, PendingFlush_Stop) {
    845   Initialize();
    846 
    847   Preroll();
    848   StartRendering();
    849 
    850   // Partially drain internal buffer so we get a pending read.
    851   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
    852   WaitForPendingRead();
    853 
    854   StopRendering();
    855 
    856   EXPECT_TRUE(IsReadPending());
    857 
    858   // Start flushing.
    859   WaitableMessageLoopEvent flush_event;
    860   renderer_->Flush(flush_event.GetClosure());
    861 
    862   SatisfyPendingRead(kDataSize);
    863 
    864   WaitableMessageLoopEvent event;
    865   renderer_->Stop(event.GetClosure());
    866   event.RunAndWait();
    867   needs_stop_ = false;
    868 }
    869 
    870 TEST_F(AudioRendererImplTest, InitializeThenStop) {
    871   InitializeAndStop();
    872 }
    873 
    874 TEST_F(AudioRendererImplTest, InitializeThenStopDuringDecoderInit) {
    875   InitializeAndStopDuringDecoderInit();
    876 }
    877 
    878 TEST_F(AudioRendererImplTest, ConfigChangeDrainsConverter) {
    879   Initialize();
    880   Preroll();
    881   StartRendering();
    882 
    883   // Drain internal buffer, we should have a pending read.
    884   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
    885   WaitForPendingRead();
    886 
    887   // Deliver a little bit of data.  Use an odd data size to ensure there is data
    888   // left in the AudioBufferConverter.  Ensure no buffers are in the splicer.
    889   SatisfyPendingRead(2053);
    890   EXPECT_FALSE(splicer_has_next_buffer());
    891   EXPECT_GT(converter_input_frames_left(), 0);
    892 
    893   // Force a config change and then ensure all buffered data has been put into
    894   // the splicer.
    895   force_config_change();
    896   EXPECT_TRUE(splicer_has_next_buffer());
    897   EXPECT_EQ(0, converter_input_frames_left());
    898 }
    899 
    900 TEST_F(AudioRendererImplTest, TimeUpdatesOnFirstBuffer) {
    901   Initialize();
    902   Preroll();
    903   StartRendering();
    904 
    905   AudioTimestampHelper timestamp_helper(kOutputSamplesPerSecond);
    906   EXPECT_EQ(kNoTimestamp(), last_time_update());
    907 
    908   // Preroll() should be buffered some data, consume half of it now.
    909   int frames_to_consume = frames_buffered() / 2;
    910   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume, NULL));
    911   WaitForPendingRead();
    912   base::RunLoop().RunUntilIdle();
    913 
    914   // ConsumeBufferedData() uses an audio delay of zero, so ensure we received
    915   // a time update that's equal to |kFramesToConsume| from above.
    916   timestamp_helper.SetBaseTimestamp(base::TimeDelta());
    917   timestamp_helper.AddFrames(frames_to_consume);
    918   EXPECT_EQ(timestamp_helper.GetTimestamp(), last_time_update());
    919 
    920   // The next time update should match the remaining frames_buffered(), but only
    921   // after running the message loop.
    922   frames_to_consume = frames_buffered();
    923   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume, NULL));
    924   EXPECT_EQ(timestamp_helper.GetTimestamp(), last_time_update());
    925 
    926   base::RunLoop().RunUntilIdle();
    927   timestamp_helper.AddFrames(frames_to_consume);
    928   EXPECT_EQ(timestamp_helper.GetTimestamp(), last_time_update());
    929 }
    930 
    931 TEST_F(AudioRendererImplTest, ImmediateEndOfStream) {
    932   Initialize();
    933   {
    934     SCOPED_TRACE("Preroll()");
    935     WaitableMessageLoopEvent event;
    936     renderer_->Preroll(base::TimeDelta(), event.GetPipelineStatusCB());
    937     WaitForPendingRead();
    938     DeliverEndOfStream();
    939     event.RunAndWaitForStatus(PIPELINE_OK);
    940   }
    941   StartRendering();
    942 
    943   // Read a single frame. We shouldn't be able to satisfy it.
    944   EXPECT_FALSE(ConsumeBufferedData(1, NULL));
    945   WaitForEnded();
    946 }
    947 
    948 TEST_F(AudioRendererImplTest, OnRenderErrorCausesDecodeError) {
    949   Initialize();
    950   Preroll();
    951   StartRendering();
    952 
    953   EXPECT_CALL(*this, OnError(PIPELINE_ERROR_DECODE));
    954   sink_->OnRenderError();
    955 }
    956 
    957 // Test for AudioRendererImpl calling Pause()/Play() on the sink when the
    958 // playback rate is set to zero and non-zero.
    959 TEST_F(AudioRendererImplTest, SetPlaybackRate) {
    960   Initialize();
    961   Preroll();
    962 
    963   // Rendering hasn't started. Sink should always be paused.
    964   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    965   renderer_->SetPlaybackRate(0.0f);
    966   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    967   renderer_->SetPlaybackRate(1.0f);
    968   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    969 
    970   // Rendering has started with non-zero rate. Rate changes will affect sink
    971   // state.
    972   renderer_->StartRendering();
    973   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    974   renderer_->SetPlaybackRate(0.0f);
    975   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    976   renderer_->SetPlaybackRate(1.0f);
    977   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    978 
    979   // Rendering has stopped. Sink should be paused.
    980   renderer_->StopRendering();
    981   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    982 
    983   // Start rendering with zero playback rate. Sink should be paused until
    984   // non-zero rate is set.
    985   renderer_->SetPlaybackRate(0.0f);
    986   renderer_->StartRendering();
    987   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
    988   renderer_->SetPlaybackRate(1.0f);
    989   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
    990 }
    991 
    992 }  // namespace media
    993