Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/ffmpeg_video_decoder_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 <list>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/limits.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_data_util.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
+using ::testing::AtMost;
 using ::testing::InSequence;
 using ::testing::IsNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
 static const VideoFrame::Format kVideoFormat = VideoFrame::YV12;
 static const gfx::Size kCodedSize(320, 240);
 static const gfx::Rect kVisibleRect(320, 240);
 static const gfx::Size kNaturalSize(320, 240);
 
 ACTION_P(ReturnBuffer, buffer) {
   arg0.Run(buffer.get() ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
+ACTION_P(PushBackTo, output) {
+  output->push_back(arg0);
+}
+
 class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decoder_(new FFmpegVideoDecoder(message_loop_.message_loop_proxy())),
-        decode_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
+        decode_cb_(base::Bind(&FFmpegVideoDecoderTest::DecodeDone,
                               base::Unretained(this))) {
     FFmpegGlue::InitializeFFmpeg();
 
     // Initialize various test buffers.
     frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);
     end_of_stream_buffer_ = DecoderBuffer::CreateEOSBuffer();
     i_frame_buffer_ = ReadTestDataFile("vp8-I-frame-320x240");
     corrupt_i_frame_buffer_ = ReadTestDataFile("vp8-corrupt-I-frame");
   }
 
   virtual ~FFmpegVideoDecoderTest() {
     Stop();
   }
 
   void Initialize() {
     InitializeWithConfig(TestVideoConfig::Normal());
   }
 
   void InitializeWithConfigAndStatus(const VideoDecoderConfig& config,
                                      PipelineStatus status) {
-    decoder_->Initialize(config, false, NewExpectedStatusCB(status));
+    decoder_->Initialize(config, false, NewExpectedStatusCB(status),
+                         base::Bind(&FFmpegVideoDecoderTest::FrameReady,
+                                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void InitializeWithConfig(const VideoDecoderConfig& config) {
     InitializeWithConfigAndStatus(config, PIPELINE_OK);
   }
 
   void Reinitialize() {
     InitializeWithConfig(TestVideoConfig::Large());
   }
@@ skipping 32 matching lines @@
   }
 
   typedef std::vector<scoped_refptr<DecoderBuffer> > InputBuffers;
   typedef std::vector<scoped_refptr<VideoFrame> > OutputFrames;
 
   // Decodes all buffers in |input_buffers| and push all successfully decoded
   // output frames (excluding EOS frames) into |output_frames|.
   // Returns the last decode status returned by the decoder.
   VideoDecoder::Status DecodeMultipleFrames(const InputBuffers& input_buffers,
                                             OutputFrames* output_frames) {
+    output_frames->clear();

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

DCHECK(output_frames->empty())?

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

Done.

     InputBuffers::const_iterator input_iter = input_buffers.begin();
 
-    for (;;) {
+    while (output_frames->empty() || !output_frames->back()->end_of_stream()) {
       // Prepare input buffer.
       scoped_refptr<DecoderBuffer> buffer;
       if (input_iter != input_buffers.end()) {
         buffer = *input_iter;
         ++input_iter;
       } else {
         buffer = end_of_stream_buffer_;
       }
 
       VideoDecoder::Status status;
-      scoped_refptr<VideoFrame> frame;
-      Decode(buffer, &status, &frame);
+      Decode(buffer, &status, output_frames);
 
       switch (status) {
         case VideoDecoder::kOk:
-          DCHECK(frame);
-          if (!frame->end_of_stream()) {
-            output_frames->push_back(frame);
-            continue;
-          } else {  // EOS
-            return status;
-          }
-        case VideoDecoder::kNotEnoughData:
-          DCHECK(!frame);
-          continue;
+          break;
         case VideoDecoder::kAborted:
           NOTREACHED();
         case VideoDecoder::kDecodeError:
         case VideoDecoder::kDecryptError:
-          DCHECK(!frame);
+          DCHECK(output_frames->empty());
           return status;
       }
     }
+
+    // Remove the EOS frame.
+    output_frames->erase(--output_frames->end());
+
+    return VideoDecoder::kOk;
   }
 
   // Decodes the single compressed frame in |buffer| and writes the
   // uncompressed output to |video_frame|. This method works with single
   // and multithreaded decoders. End of stream buffers are used to trigger
   // the frame to be returned in the multithreaded decoder case.
   void DecodeSingleFrame(const scoped_refptr<DecoderBuffer>& buffer,
                          VideoDecoder::Status* status,
                          scoped_refptr<VideoFrame>* video_frame) {

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

should this be OutputFrames as well? In theory, we could have multiple outputs.

Since we use OutputFrames in all decode related methods, probably we could make
it a class variable, as we did in FFADTest.

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

Done.

     InputBuffers input_buffers;
     input_buffers.push_back(buffer);
 
     OutputFrames output_frames;
     *status = DecodeMultipleFrames(input_buffers, &output_frames);
 
     if (*status != VideoDecoder::kOk)
       return;
 
     ASSERT_LE(output_frames.size(), 1U);
@@ skipping 29 matching lines @@
     EXPECT_EQ(original_size.height(),
               output_frames[0]->visible_rect().size().height());
     EXPECT_EQ(expected_width,
               output_frames[1]->visible_rect().size().width());
     EXPECT_EQ(expected_height,
               output_frames[1]->visible_rect().size().height());
   }
 
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
               VideoDecoder::Status* status,
-              scoped_refptr<VideoFrame>* video_frame) {
-    EXPECT_CALL(*this, FrameReady(_, _))
-        .WillOnce(DoAll(SaveArg<0>(status), SaveArg<1>(video_frame)));
+              OutputFrames* video_frames) {
+    EXPECT_CALL(*this, FrameReady(_))
+        .WillRepeatedly(PushBackTo(video_frames));
+    EXPECT_CALL(*this, DecodeDone(_)).WillOnce(SaveArg<0>(status));
 
     decoder_->Decode(buffer, decode_cb_);
 
     message_loop_.RunUntilIdle();
   }
 
-  MOCK_METHOD2(FrameReady, void(VideoDecoder::Status,
-                                const scoped_refptr<VideoFrame>&));
+  MOCK_METHOD1(FrameReady, void(const scoped_refptr<VideoFrame>&));
+  MOCK_METHOD1(DecodeDone, void(VideoDecoder::Status));
 
   base::MessageLoop message_loop_;
   scoped_ptr<FFmpegVideoDecoder> decoder_;
 
   VideoDecoder::DecodeCB decode_cb_;
 
   // Various buffers for testing.
   scoped_ptr<uint8_t[]> frame_buffer_;
   scoped_refptr<DecoderBuffer> end_of_stream_buffer_;
   scoped_refptr<DecoderBuffer> i_frame_buffer_;
@@ skipping 145 matching lines @@
   ASSERT_EQ(2U, output_frames.size());
 
   EXPECT_FALSE(output_frames[0]->end_of_stream());
   EXPECT_FALSE(output_frames[1]->end_of_stream());
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeError) {
   Initialize();
 
   VideoDecoder::Status status;
-  scoped_refptr<VideoFrame> frame;
+  OutputFrames frames;
 
   // The error is only raised on the second decode attempt, so we expect at
   // least one successful decode but we don't expect valid frame to be decoded.
   // During the second decode attempt an error is raised.
-  Decode(corrupt_i_frame_buffer_, &status, &frame);
-  DCHECK(!frame);
-  DCHECK_EQ(VideoDecoder::kNotEnoughData, status);
-  Decode(i_frame_buffer_, &status, &frame);
-  DCHECK(!frame);
-  DCHECK_EQ(VideoDecoder::kDecodeError, status);
+  Decode(corrupt_i_frame_buffer_, &status, &frames);
+  EXPECT_TRUE(frames.empty());
+  EXPECT_EQ(VideoDecoder::kOk, status);
+  Decode(i_frame_buffer_, &status, &frames);
+  EXPECT_TRUE(frames.empty());
+  EXPECT_EQ(VideoDecoder::kDecodeError, status);
 
   // After a decode error occurred, all following decodes will return
   // kDecodeError.
-  Decode(i_frame_buffer_, &status, &frame);
-  DCHECK(!frame);
-  DCHECK_EQ(VideoDecoder::kDecodeError, status);
+  Decode(i_frame_buffer_, &status, &frames);
+  EXPECT_TRUE(frames.empty());
+  EXPECT_EQ(VideoDecoder::kDecodeError, status);
 }
 
 // Multi-threaded decoders have different behavior than single-threaded
 // decoders at the end of the stream. Multithreaded decoders hide errors
 // that happen on the last |codec_context_->thread_count| frames to avoid
 // prematurely signalling EOS. This test just exposes that behavior so we can
 // detect if it changes.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeErrorAtEndOfStream) {
   Initialize();
 
@@ skipping 66 matching lines @@
 
 // Test stopping when decoder has hit end of stream.
 TEST_F(FFmpegVideoDecoderTest, Stop_EndOfStream) {
   Initialize();
   EnterDecodingState();
   EnterEndOfStreamState();
   Stop();
 }
 
 }  // namespace media