Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/fake_video_decoder_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "media/filters/fake_video_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const int kDecodingDelay = 9;
 static const int kTotalBuffers = 12;
 static const int kDurationMs = 30;
 
 class FakeVideoDecoderTest : public testing::Test,
                              public testing::WithParamInterface<int> {
  public:
   FakeVideoDecoderTest()
-      : decoder_(new FakeVideoDecoder(kDecodingDelay, false, GetParam())),
+      : decoder_(new FakeVideoDecoder(kDecodingDelay, GetParam())),
         num_input_buffers_(0),
         num_decoded_frames_(0),
-        last_decode_status_(VideoDecoder::kNotEnoughData),
+        last_decode_status_(VideoDecoder::kOk),
         pending_decode_requests_(0),
         is_reset_pending_(false) {}
 
   virtual ~FakeVideoDecoderTest() {
     Stop();
   }
 
   void InitializeWithConfig(const VideoDecoderConfig& config) {
-    decoder_->Initialize(config, false, NewExpectedStatusCB(PIPELINE_OK));
+    decoder_->Initialize(
+        config, false, NewExpectedStatusCB(PIPELINE_OK),
+        base::Bind(&FakeVideoDecoderTest::FrameReady, base::Unretained(this)));
     message_loop_.RunUntilIdle();
     current_config_ = config;
   }
 
   void Initialize() {
     InitializeWithConfig(TestVideoConfig::Normal());
   }
 
   void EnterPendingInitState() {
     decoder_->HoldNextInit();
     Initialize();
   }
 
   void SatisfyInit() {
     decoder_->SatisfyInit();
     message_loop_.RunUntilIdle();
   }
 
-  // Callback for VideoDecoder::Read().
-  void FrameReady(VideoDecoder::Status status,
-                  const scoped_refptr<VideoFrame>& frame) {
+  // Callback for VideoDecoder::Decode().
+  void DecodeDone(VideoDecoder::Status status) {
+    LOG(ERROR) << "DONE";
     DCHECK_GT(pending_decode_requests_, 0);
-
     --pending_decode_requests_;
     last_decode_status_ = status;
+  }
+
+  void FrameReady(const scoped_refptr<VideoFrame>& frame) {
     last_decoded_frame_ = frame;
-
-    if (frame && !frame->end_of_stream())
+    if (!frame->end_of_stream())
       num_decoded_frames_++;
   }
 
   enum CallbackResult {
     PENDING,
     OK,
     NOT_ENOUGH_DATA,
     ABORTED,
     EOS
   };
 
   void ExpectReadResult(CallbackResult result) {
     switch (result) {
       case PENDING:
         EXPECT_GT(pending_decode_requests_, 0);
         break;
       case OK:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kOk, last_decode_status_);
         ASSERT_TRUE(last_decoded_frame_);
         EXPECT_FALSE(last_decoded_frame_->end_of_stream());
         break;
       case NOT_ENOUGH_DATA:
         EXPECT_EQ(0, pending_decode_requests_);
-        ASSERT_EQ(VideoDecoder::kNotEnoughData, last_decode_status_);
+        ASSERT_EQ(VideoDecoder::kOk, last_decode_status_);
         ASSERT_FALSE(last_decoded_frame_);
         break;
       case ABORTED:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kAborted, last_decode_status_);
         EXPECT_FALSE(last_decoded_frame_);
         break;
       case EOS:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kOk, last_decode_status_);
         ASSERT_TRUE(last_decoded_frame_);
         EXPECT_TRUE(last_decoded_frame_->end_of_stream());
         break;
     }
   }
 
   void Decode() {
     scoped_refptr<DecoderBuffer> buffer;
 
+    LOG(ERROR) << "Dec " << num_input_buffers_;

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

remove?

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

Done.

     if (num_input_buffers_ < kTotalBuffers) {
       buffer = CreateFakeVideoBufferForTest(
           current_config_,
           base::TimeDelta::FromMilliseconds(kDurationMs * num_input_buffers_),
           base::TimeDelta::FromMilliseconds(kDurationMs));
       num_input_buffers_++;
     } else {
       buffer = DecoderBuffer::CreateEOSBuffer();
     }
 
     ++pending_decode_requests_;
 
     decoder_->Decode(
         buffer,
-        base::Bind(&FakeVideoDecoderTest::FrameReady, base::Unretained(this)));
+        base::Bind(&FakeVideoDecoderTest::DecodeDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ReadOneFrame() {
+    last_decoded_frame_ = NULL;
     do {
       Decode();
-    } while (last_decode_status_ == VideoDecoder::kNotEnoughData &&
-             pending_decode_requests_ == 0);
+    } while (!last_decoded_frame_ && pending_decode_requests_ == 0);
   }
 
   void ReadUntilEOS() {
     do {
       ReadOneFrame();
     } while (last_decoded_frame_ && !last_decoded_frame_->end_of_stream());
   }
 
   void EnterPendingReadState() {
     // Pass the initial NOT_ENOUGH_DATA stage.
     ReadOneFrame();
     decoder_->HoldDecode();
+        LOG(ERROR) << "WTF";

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

remove :)

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

Done.

     ReadOneFrame();
     ExpectReadResult(PENDING);
   }
 
   void SatisfyReadAndExpect(CallbackResult result) {

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

nit: this should be renamed to SatisfyDecodeAnd...

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

Done.

     decoder_->SatisfyDecode();
     message_loop_.RunUntilIdle();
     ExpectReadResult(result);
   }
 
   void SatisfyRead() {
     SatisfyReadAndExpect(OK);
   }
 
   // Callback for VideoDecoder::Reset().
@@ skipping 81 matching lines @@
 TEST_P(FakeVideoDecoderTest, Read_DecodingDelay) {
   Initialize();
 
   while (num_input_buffers_ < kTotalBuffers) {
     ReadOneFrame();
     EXPECT_EQ(num_input_buffers_, num_decoded_frames_ + kDecodingDelay);
   }
 }
 
 TEST_P(FakeVideoDecoderTest, Read_ZeroDelay) {
-  decoder_.reset(new FakeVideoDecoder(0, false, 1));
+  decoder_.reset(new FakeVideoDecoder(0, 1));
   Initialize();
 
   while (num_input_buffers_ < kTotalBuffers) {
     ReadOneFrame();
     EXPECT_EQ(num_input_buffers_, num_decoded_frames_);
   }
 }
 
 TEST_P(FakeVideoDecoderTest, Read_Pending_NotEnoughData) {
   Initialize();
   decoder_->HoldDecode();
   ReadOneFrame();
   ExpectReadResult(PENDING);
   SatisfyReadAndExpect(NOT_ENOUGH_DATA);
+
+  // Verify that FrameReady() hasn't been called.
+  EXPECT_FALSE(last_decoded_frame_);
 }
 
 TEST_P(FakeVideoDecoderTest, Read_Pending_OK) {
   Initialize();
-  ReadOneFrame();
   EnterPendingReadState();
   SatisfyReadAndExpect(OK);
 }
 
 TEST_P(FakeVideoDecoderTest, Read_Parallel) {
   int max_decode_requests = GetParam();
   if (max_decode_requests < 2)
     return;
 
   Initialize();
-  ReadOneFrame();
   decoder_->HoldDecode();
   for (int i = 0; i < max_decode_requests; ++i) {
     ReadOneFrame();
     ExpectReadResult(PENDING);
   }
   EXPECT_EQ(max_decode_requests, pending_decode_requests_);
-  SatisfyReadAndExpect(OK);
+  SatisfyReadAndExpect(NOT_ENOUGH_DATA);

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

hmm, if max_decode_requests > decoding_delay, should we expect OK?

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

Yes, but we didn't have tests with max_decode_requests > decoding_delay. Added
them now.

 }
 
 TEST_P(FakeVideoDecoderTest, ReadWithHold_DecodingDelay) {
   Initialize();
 
   // Hold all decodes and satisfy one decode at a time.
   decoder_->HoldDecode();
   int num_decodes_satisfied = 0;
   while (num_decoded_frames_ == 0) {
     while (pending_decode_requests_ < decoder_->GetMaxDecodeRequests())
@@ skipping 75 matching lines @@
   Stop();
 }
 
 TEST_P(FakeVideoDecoderTest, Stop_DuringPendingReadAndPendingReset) {
   Initialize();
   EnterPendingReadState();
   EnterPendingResetState();
   Stop();
 }
 
-TEST_P(FakeVideoDecoderTest, GetDecodeOutput) {
-  decoder_.reset(new FakeVideoDecoder(kDecodingDelay, true, 1));
-  Initialize();
-
-  while (num_input_buffers_ < kTotalBuffers) {
-    ReadOneFrame();
-    while (decoder_->GetDecodeOutput())
-      ++num_decoded_frames_;
-    EXPECT_EQ(num_input_buffers_, num_decoded_frames_);
-  }
-}
-
 }  // namespace media