Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/audio_renderer_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 11 matching lines @@
 #include "media/filters/audio_renderer_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::base::Time;
 using ::base::TimeTicks;
 using ::base::TimeDelta;
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Return;
+using ::testing::SaveArg;
 
 namespace media {
 
 // Constants to specify the type of audio data used.
 static AudioCodec kCodec = kCodecVorbis;
 static SampleFormat kSampleFormat = kSampleFormatPlanarF32;
 static ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 static int kChannelCount = 2;
 static int kChannels = ChannelLayoutToChannelCount(kChannelLayout);
 static int kSamplesPerSecond = 44100;
@@ skipping 28 matching lines @@
                                     0,
                                     false);
     demuxer_stream_.set_audio_decoder_config(audio_config);
 
     // Used to save callbacks and run them at a later time.
     EXPECT_CALL(*decoder_, Decode(_, _))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
 
-    // Mock out demuxer reads
+    // Mock out demuxer reads.
     EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
-        RunCallback<0>(DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer()));
+        RunCallback<0>(DemuxerStream::kOk,
+                       scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
     EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
         .WillRepeatedly(Return(true));
     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                kChannelLayout,
                                kOutputSamplesPerSecond,
                                SampleFormatToBytesPerChannel(kSampleFormat) * 8,
                                512);
     hardware_config_.UpdateOutputConfig(out_params);
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
@@ skipping 12 matching lines @@
   virtual ~AudioRendererImplTest() {
     SCOPED_TRACE("~AudioRendererImplTest()");
     if (needs_stop_) {
       WaitableMessageLoopEvent event;
       renderer_->Stop(event.GetClosure());
       event.RunAndWait();
     }
   }
 
   void ExpectUnsupportedAudioDecoder() {
-    EXPECT_CALL(*decoder_, Initialize(_, _))
-        .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
+                        RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED)));
   }
 
   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
   MOCK_METHOD0(OnUnderflow, void());
   MOCK_METHOD1(OnError, void(PipelineStatus));
 
   void OnAudioTimeCallback(TimeDelta current_time, TimeDelta max_time) {
     CHECK(current_time <= max_time);
     last_time_update_ = current_time;
   }
 
   void InitializeRenderer(const PipelineStatusCB& pipeline_status_cb) {
     renderer_->Initialize(
         &demuxer_stream_,
         pipeline_status_cb,
         base::Bind(&AudioRendererImplTest::OnStatistics,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnUnderflow,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnAudioTimeCallback,
                    base::Unretained(this)),
         ended_event_.GetClosure(),
         base::Bind(&AudioRendererImplTest::OnError,
                    base::Unretained(this)));
   }
 
   void Initialize() {
-    EXPECT_CALL(*decoder_, Initialize(_, _))
-        .WillOnce(RunCallback<1>(PIPELINE_OK));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
+                        RunCallback<1>(PIPELINE_OK)));
     EXPECT_CALL(*decoder_, Stop());
     InitializeWithStatus(PIPELINE_OK);
 
     next_timestamp_.reset(new AudioTimestampHelper(
         hardware_config_.GetOutputConfig().sample_rate()));
   }
 
   void InitializeWithStatus(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("InitializeWithStatus(%d)", expected));
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(expected);
 
     // We should have no reads.
     EXPECT_TRUE(decode_cb_.is_null());
   }
 
   void InitializeAndStop() {
-    EXPECT_CALL(*decoder_, Initialize(_, _))
-        .WillOnce(RunCallback<1>(PIPELINE_OK));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
+                        RunCallback<1>(PIPELINE_OK)));
     EXPECT_CALL(*decoder_, Stop());
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
 
     // Stop before we let the MessageLoop run, this simulates an interleaving
     // in which we end up calling Stop() while the OnDecoderSelected callback
     // is in flight.
     renderer_->Stop(NewExpectedClosure());
     event.RunAndWaitForStatus(PIPELINE_ERROR_ABORT);
     EXPECT_EQ(renderer_->state_, AudioRendererImpl::kStopped);
   }
 
   void InitializeAndStopDuringDecoderInit() {
-    EXPECT_CALL(*decoder_, Initialize(_, _))
-        .WillOnce(EnterPendingDecoderInitStateAction(this));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
+                        EnterPendingDecoderInitStateAction(this)));
     EXPECT_CALL(*decoder_, Stop());
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
 
     base::RunLoop().RunUntilIdle();
     DCHECK(!init_decoder_cb_.is_null());
 
     renderer_->Stop(NewExpectedClosure());
     base::ResetAndReturn(&init_decoder_cb_).Run(PIPELINE_OK);
@@ skipping 23 matching lines @@
 
     TimeDelta timestamp = TimeDelta::FromMilliseconds(timestamp_ms);
     next_timestamp_->SetBaseTimestamp(timestamp);
 
     // Fill entire buffer to complete prerolling.
     WaitableMessageLoopEvent event;
     renderer_->Preroll(timestamp, event.GetPipelineStatusCB());
     WaitForPendingRead();
     DeliverRemainingAudio();
     event.RunAndWaitForStatus(PIPELINE_OK);
-
-    // We should have no reads.
-    EXPECT_TRUE(decode_cb_.is_null());
   }
 
   void StartRendering() {
     renderer_->StartRendering();
     renderer_->SetPlaybackRate(1.0f);
   }
 
   void StopRendering() {
     renderer_->StopRendering();
   }
@@ skipping 40 matching lines @@
                                kSamplesPerSecond,
                                kPlayingAudio,
                                0.0f,
                                size,
                                next_timestamp_->GetTimestamp());
     next_timestamp_->AddFrames(size);
 
     DeliverBuffer(AudioDecoder::kOk, buffer);
   }
 
-  void AbortPendingRead() {
-    DeliverBuffer(AudioDecoder::kAborted, NULL);
-  }
-
   void DeliverEndOfStream() {
-    DeliverBuffer(AudioDecoder::kOk, AudioBuffer::CreateEOSBuffer());
+    // Repeatedly return EOS buffer
+    while (!decode_cb_.is_null()) {
+      DeliverBuffer(AudioDecoder::kOk, AudioBuffer::CreateEOSBuffer());
+    }
   }
 
   // Delivers frames until |renderer_|'s internal buffer is full and no longer
   // has pending reads.
   void DeliverRemainingAudio() {
     SatisfyPendingRead(frames_remaining_in_buffer());
   }
 
   // Attempts to consume |requested_frames| frames from |renderer_|'s internal
   // buffer, returning true if all |requested_frames| frames were consumed,
@@ skipping 153 matching lines @@
 
     CHECK(decode_cb_.is_null()) << "Overlapping decodes are not permitted";
     decode_cb_ = decode_cb;
 
     // Wake up WaitForPendingRead() if needed.
     if (!wait_for_pending_decode_cb_.is_null())
       base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
   }
 
   void ResetDecoder(const base::Closure& reset_cb) {
-    CHECK(decode_cb_.is_null())
-        << "Reset overlapping with reads is not permitted";
+    if (!decode_cb_.is_null()) {
+      // |reset_cb| will be called in DeliverBuffer(), after the decoder is
+      // flushed.
+      reset_cb_ = reset_cb;
+      return;
+    }
 
     message_loop_.PostTask(FROM_HERE, reset_cb);
   }
 
   void DeliverBuffer(AudioDecoder::Status status,
                      const scoped_refptr<AudioBuffer>& buffer) {
     CHECK(!decode_cb_.is_null());
-    base::ResetAndReturn(&decode_cb_).Run(status, buffer);
+    if (buffer)
+      output_cb_.Run(buffer);
+    base::ResetAndReturn(&decode_cb_).Run(status);
+
+    if (!reset_cb_.is_null())
+      base::ResetAndReturn(&reset_cb_).Run();
+
+    message_loop_.RunUntilIdle();
   }
 
   MockDemuxerStream demuxer_stream_;
   MockAudioDecoder* decoder_;
 
   // Used for stubbing out time in the audio callback thread.
   base::Lock lock_;
   TimeTicks time_;
 
   // Used for satisfying reads.
+  AudioDecoder::OutputCB output_cb_;
   AudioDecoder::DecodeCB decode_cb_;
+  base::Closure reset_cb_;
   scoped_ptr<AudioTimestampHelper> next_timestamp_;
 
   WaitableMessageLoopEvent ended_event_;
 
   // Run during DecodeDecoder() to unblock WaitForPendingRead().
   base::Closure wait_for_pending_decode_cb_;
   base::Closure stop_decoder_cb_;
 
   PipelineStatusCB init_decoder_cb_;
   base::TimeDelta last_time_update_;
@@ skipping 88 matching lines @@
   EXPECT_CALL(*this, OnUnderflow());
   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
 
   // Verify that the buffer capacity increased as a result of resuming after
   // underflow.
   EXPECT_EQ(buffer_capacity(), initial_capacity);
   renderer_->ResumeAfterUnderflow();
   EXPECT_GT(buffer_capacity(), initial_capacity);
 
   // Verify that the buffer capacity is restored to the |initial_capacity|.
-  AbortPendingRead();
+  DeliverEndOfStream();
   Flush();
   EXPECT_EQ(buffer_capacity(), initial_capacity);
 }
 
 TEST_F(AudioRendererImplTest, Underflow_FlushWhileUnderflowed) {
   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());
   EXPECT_FALSE(ConsumeBufferedData(kDataSize, NULL));
 
   // Verify that we can still Flush() before entering the rebuffering state.
-  AbortPendingRead();
+  DeliverEndOfStream();
   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
@@ skipping 123 matching lines @@
   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) {
-  Initialize();
-
-  // Start prerolling and wait for a read.
-  WaitableMessageLoopEvent event;
-  renderer_->Preroll(TimeDelta(), event.GetPipelineStatusCB());
-  WaitForPendingRead();
-
-  // Simulate the decoder aborting the pending read.
-  AbortPendingRead();
-  event.RunAndWaitForStatus(PIPELINE_OK);
-
-  Flush();
-
-  // Preroll again to a different timestamp and verify it completed normally.
-  Preroll(1000, PIPELINE_OK);
-}
-
-TEST_F(AudioRendererImplTest, AbortPendingRead_Flush) {
-  Initialize();
-
-  Preroll();
-  StartRendering();
-
-  // Partially drain internal buffer so we get a pending read.
-  EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
-  WaitForPendingRead();
-
-  StopRendering();
-
-  EXPECT_TRUE(IsReadPending());
-
-  // Start flushing.
-  WaitableMessageLoopEvent flush_event;
-  renderer_->Flush(flush_event.GetClosure());
-
-  // Simulate the decoder aborting the pending read.
-  AbortPendingRead();
-  flush_event.RunAndWait();
-
-  EXPECT_FALSE(IsReadPending());
-
-  // Preroll again to a different timestamp and verify it completed normally.
-  Preroll(1000, PIPELINE_OK);
-}
-
 TEST_F(AudioRendererImplTest, PendingRead_Flush) {
   Initialize();
 
   Preroll();
   StartRendering();
 
   // Partially drain internal buffer so we get a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
   WaitForPendingRead();
 
@@ skipping 101 matching lines @@
   Preroll();
   StartRendering();
 
   AudioTimestampHelper timestamp_helper(kOutputSamplesPerSecond);
   EXPECT_EQ(kNoTimestamp(), last_time_update());
 
   // Preroll() should be buffered some data, consume half of it now.
   int frames_to_consume = frames_buffered() / 2;
   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume, NULL));
   WaitForPendingRead();
+  base::RunLoop().RunUntilIdle();
 
   // ConsumeBufferedData() uses an audio delay of zero, so ensure we received
   // a time update that's equal to |kFramesToConsume| from above.
   timestamp_helper.SetBaseTimestamp(base::TimeDelta());
   timestamp_helper.AddFrames(frames_to_consume);
   EXPECT_EQ(timestamp_helper.GetTimestamp(), last_time_update());
 
   // The next time update should match the remaining frames_buffered(), but only
   // after running the message loop.
   frames_to_consume = frames_buffered();
@@ skipping 60 matching lines @@
   // Start rendering with zero playback rate. Sink should be paused until
   // non-zero rate is set.
   renderer_->SetPlaybackRate(0.0f);
   renderer_->StartRendering();
   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
   renderer_->SetPlaybackRate(1.0f);
   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
 }
 
 }  // namespace media