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))));

[xhwang, 2014/06/05 21:53:49]

why making this change?

[Sergey Ulanov, 2014/06/06 22:49:39]

DecoderStream<StreamType>::OnBufferReady() stops reading after EOF packet has
been demuxed. This breaks Underflow_EndOfStream() which calls
WaitForPendingRead() after SatisfyPendingRead().

     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 38 matching lines @@
                                kChannelLayout,
                                kChannelCount,
                                kSamplesPerSecond,
                                kPlayingAudio,
                                0.0f,
                                size,
                                next_timestamp_->GetTimestamp());
     next_timestamp_->AddFrames(size);
 
     DeliverBuffer(AudioDecoder::kOk, buffer);
+    message_loop_.RunUntilIdle();
   }
 
   void AbortPendingRead() {
     DeliverBuffer(AudioDecoder::kAborted, NULL);
   }
 
   void DeliverEndOfStream() {
-    DeliverBuffer(AudioDecoder::kOk, AudioBuffer::CreateEOSBuffer());
+    while (!decode_cb_.is_null()) {
+      DeliverBuffer(AudioDecoder::kOk, AudioBuffer::CreateEOSBuffer());
+      message_loop_.RunUntilIdle();

[xhwang, 2014/06/05 21:53:49]

Run the message loop in DeliverBuffer()?

[Sergey Ulanov, 2014/06/06 22:49:40]

Done.

+    }

[xhwang, 2014/06/05 21:53:49]

why "while" loop? There could be only one pending |decode_cb_|, which will be
reset in DliverBuffer?

[Sergey Ulanov, 2014/06/06 22:49:40]

DecoderStream::OnDecodeDone() may get another buffer from the stream. and call
the decoder again. This loop fills up the queue in DecodeStream with EOF
buffers. I agree it's ugly.
I would prefer to rewrite tests in this file to use a fake demuxer, then it
would be possible to control what's being read from the demuxer, but I don't
think it's needs to be in this CL.

   }
 
   // Delivers frames until |renderer_|'s internal buffer is full and no longer
   // has pending reads.
   void DeliverRemainingAudio() {
     SatisfyPendingRead(frames_remaining_in_buffer());
+    message_loop_.RunUntilIdle();

[xhwang, 2014/06/05 21:53:49]

SatisfyPendingRead() already runs the message loop at the end of the function.

[Sergey Ulanov, 2014/06/06 22:49:39]

Done.

   }
 
   // Attempts to consume |requested_frames| frames from |renderer_|'s internal
   // buffer, returning true if all |requested_frames| frames were consumed,
   // false if less than |requested_frames| frames were consumed.
   //
   // |muted| is optional and if passed will get set if the value of
   // the consumed data is muted audio.
   bool ConsumeBufferedData(int requested_frames, bool* muted) {
     scoped_ptr<AudioBus> bus =
@@ skipping 147 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_ = reset_cb;

[xhwang, 2014/06/05 21:53:49]

Add a comment that in this case the |reset_cb| is fired in DeliverBuffer() after
the decoder is flushed.

[Sergey Ulanov, 2014/06/06 22:49:39]

Done.

+      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();
   }
 
   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 494 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