chromecast/media/cma/test/mock_frame_consumer.cc

   1 // Copyright 2014 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 "chromecast/media/cma/test/mock_frame_consumer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "base/time/time.h"
  11 #include "chromecast/media/cma/base/coded_frame_provider.h"
  12 #include "chromecast/media/cma/base/decoder_buffer_base.h"
  13 #include "chromecast/media/cma/test/frame_generator_for_test.h"
  14 #include "media/base/video_decoder_config.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace chromecast {
  18 namespace media {
  19
  20 MockFrameConsumer::MockFrameConsumer(
  21     CodedFrameProvider* coded_frame_provider)
  22     : coded_frame_provider_(coded_frame_provider),
  23       pattern_idx_(0),
  24       last_read_aborted_by_flush_(false) {
  25 }
  26
  27 MockFrameConsumer::~MockFrameConsumer() {
  28 }
  29
  30 void MockFrameConsumer::Configure(
  31     const std::vector<bool>& delayed_task_pattern,
  32     bool last_read_aborted_by_flush,
  33     scoped_ptr<FrameGeneratorForTest> frame_generator) {
  34   delayed_task_pattern_ = delayed_task_pattern;
  35   last_read_aborted_by_flush_ = last_read_aborted_by_flush;
  36   frame_generator_.reset(frame_generator.release());
  37 }
  38
  39 void MockFrameConsumer::Start(const base::Closure& done_cb) {
  40   done_cb_ = done_cb;
  41
  42   pattern_idx_ = 0;
  43
  44   base::MessageLoopProxy::current()->PostTask(
  45       FROM_HERE,
  46       base::Bind(&MockFrameConsumer::ReadFrame, base::Unretained(this)));
  47 }
  48
  49 void MockFrameConsumer::ReadFrame() {
  50   // Once all the frames have been read, flush the frame provider.
  51   if (frame_generator_->RemainingFrameCount() == 0 &&
  52       !last_read_aborted_by_flush_) {
  53     coded_frame_provider_->Flush(
  54         base::Bind(&MockFrameConsumer::OnFlushCompleted,
  55                    base::Unretained(this)));
  56     return;
  57   }
  58
  59   coded_frame_provider_->Read(
  60       base::Bind(&MockFrameConsumer::OnNewFrame,
  61                  base::Unretained(this)));
  62
  63   // The last read is right away aborted by a Flush.
  64   if (frame_generator_->RemainingFrameCount() == 0 &&
  65       last_read_aborted_by_flush_) {
  66     coded_frame_provider_->Flush(
  67         base::Bind(&MockFrameConsumer::OnFlushCompleted,
  68                    base::Unretained(this)));
  69     return;
  70   }
  71 }
  72
  73 void MockFrameConsumer::OnNewFrame(
  74     const scoped_refptr<DecoderBufferBase>& buffer,
  75     const ::media::AudioDecoderConfig& audio_config,
  76     const ::media::VideoDecoderConfig& video_config) {
  77   bool ref_has_config = frame_generator_->HasDecoderConfig();
  78   scoped_refptr<DecoderBufferBase> ref_buffer = frame_generator_->Generate();
  79
  80   ASSERT_TRUE(buffer.get());
  81   ASSERT_TRUE(ref_buffer.get());
  82
  83   EXPECT_EQ(video_config.IsValidConfig(), ref_has_config);
  84
  85   EXPECT_EQ(buffer->end_of_stream(), ref_buffer->end_of_stream());
  86   if (!ref_buffer->end_of_stream()) {
  87     EXPECT_EQ(buffer->timestamp(), ref_buffer->timestamp());
  88     ASSERT_EQ(buffer->data_size(), ref_buffer->data_size());
  89     for (size_t k = 0; k < ref_buffer->data_size(); k++)
  90       EXPECT_EQ(buffer->data()[k], ref_buffer->data()[k]);
  91   }
  92
  93   bool delayed = delayed_task_pattern_[pattern_idx_];
  94   pattern_idx_ = (pattern_idx_ + 1) % delayed_task_pattern_.size();
  95
  96   if (delayed) {
  97     base::MessageLoopProxy::current()->PostDelayedTask(
  98         FROM_HERE,
  99         base::Bind(&MockFrameConsumer::ReadFrame,
 100                    base::Unretained(this)),
 101         base::TimeDelta::FromMilliseconds(1));
 102   } else {
 103     base::MessageLoopProxy::current()->PostTask(
 104         FROM_HERE,
 105         base::Bind(&MockFrameConsumer::ReadFrame,
 106                    base::Unretained(this)));
 107   }
 108 }
 109
 110 void MockFrameConsumer::OnFlushCompleted() {
 111   EXPECT_EQ(frame_generator_->RemainingFrameCount(), 0);
 112   done_cb_.Run();
 113 }
 114
 115 }  // namespace media
 116 }  // namespace chromecast