media/filters/fake_video_decoder.cc

   1 // Copyright 2013 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 "media/filters/fake_video_decoder.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/location.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "media/base/bind_to_current_loop.h"
  12 #include "media/base/test_helpers.h"
  13
  14 namespace media {
  15
  16 FakeVideoDecoder::FakeVideoDecoder(int decoding_delay,
  17                                    int max_parallel_decoding_requests)
  18     : decoding_delay_(decoding_delay),
  19       max_parallel_decoding_requests_(max_parallel_decoding_requests),
  20       state_(STATE_UNINITIALIZED),
  21       hold_decode_(false),
  22       total_bytes_decoded_(0),
  23       weak_factory_(this) {
  24   DCHECK_GE(decoding_delay, 0);
  25 }
  26
  27 FakeVideoDecoder::~FakeVideoDecoder() {
  28   DCHECK_EQ(state_, STATE_UNINITIALIZED);
  29 }
  30
  31 void FakeVideoDecoder::Initialize(const VideoDecoderConfig& config,
  32                                   bool low_delay,
  33                                   const PipelineStatusCB& status_cb,
  34                                   const OutputCB& output_cb) {
  35   DCHECK(thread_checker_.CalledOnValidThread());
  36   DCHECK(config.IsValidConfig());
  37   DCHECK(held_decode_callbacks_.empty())
  38       << "No reinitialization during pending decode.";
  39   DCHECK(reset_cb_.IsNull()) << "No reinitialization during pending reset.";
  40
  41   current_config_ = config;
  42   init_cb_.SetCallback(BindToCurrentLoop(status_cb));
  43
  44   // Don't need BindToCurrentLoop() because |output_cb_| is only called from
  45   // RunDecodeCallback() which is posted from Decode().
  46   output_cb_ = output_cb;
  47
  48   if (!decoded_frames_.empty()) {
  49     DVLOG(1) << "Decoded frames dropped during reinitialization.";
  50     decoded_frames_.clear();
  51   }
  52
  53   state_ = STATE_NORMAL;
  54   init_cb_.RunOrHold(PIPELINE_OK);
  55 }
  56
  57 void FakeVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
  58                               const DecodeCB& decode_cb) {
  59   DCHECK(thread_checker_.CalledOnValidThread());
  60   DCHECK(reset_cb_.IsNull());
  61   DCHECK_LE(decoded_frames_.size(),
  62             decoding_delay_ + held_decode_callbacks_.size());
  63   DCHECK_LT(static_cast<int>(held_decode_callbacks_.size()),
  64             max_parallel_decoding_requests_);
  65
  66   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
  67   DecodeCB wrapped_decode_cb =
  68       BindToCurrentLoop(base::Bind(&FakeVideoDecoder::OnFrameDecoded,
  69                                    weak_factory_.GetWeakPtr(),
  70                                    buffer_size, decode_cb));
  71
  72   if (state_ == STATE_ERROR) {
  73     wrapped_decode_cb.Run(kDecodeError);
  74     return;
  75   }
  76
  77   if (buffer->end_of_stream()) {
  78     state_ = STATE_END_OF_STREAM;
  79   } else {
  80     DCHECK(VerifyFakeVideoBufferForTest(buffer, current_config_));
  81     scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateColorFrame(
  82         current_config_.coded_size(), 0, 0, 0, buffer->timestamp());
  83     decoded_frames_.push_back(video_frame);
  84   }
  85
  86   RunOrHoldDecode(wrapped_decode_cb);
  87 }
  88
  89 void FakeVideoDecoder::Reset(const base::Closure& closure) {
  90   DCHECK(thread_checker_.CalledOnValidThread());
  91   DCHECK(reset_cb_.IsNull());
  92
  93   reset_cb_.SetCallback(BindToCurrentLoop(closure));
  94   decoded_frames_.clear();
  95
  96   // Defer the reset if a decode is pending.
  97   if (!held_decode_callbacks_.empty())
  98     return;
  99
 100   DoReset();
 101 }
 102
 103 void FakeVideoDecoder::Stop() {
 104   DCHECK(thread_checker_.CalledOnValidThread());
 105
 106   if (!init_cb_.IsNull())
 107     SatisfyInit();
 108   if (!held_decode_callbacks_.empty())
 109     SatisfyDecode();
 110   if (!reset_cb_.IsNull())
 111     SatisfyReset();
 112
 113   decoded_frames_.clear();
 114   state_ = STATE_UNINITIALIZED;
 115 }
 116
 117 void FakeVideoDecoder::HoldNextInit() {
 118   DCHECK(thread_checker_.CalledOnValidThread());
 119   init_cb_.HoldCallback();
 120 }
 121
 122 void FakeVideoDecoder::HoldDecode() {
 123   DCHECK(thread_checker_.CalledOnValidThread());
 124   hold_decode_ = true;
 125 }
 126
 127 void FakeVideoDecoder::HoldNextReset() {
 128   DCHECK(thread_checker_.CalledOnValidThread());
 129   reset_cb_.HoldCallback();
 130 }
 131
 132 void FakeVideoDecoder::SatisfyInit() {
 133   DCHECK(thread_checker_.CalledOnValidThread());
 134   DCHECK(held_decode_callbacks_.empty());
 135   DCHECK(reset_cb_.IsNull());
 136
 137   init_cb_.RunHeldCallback();
 138 }
 139
 140 void FakeVideoDecoder::SatisfyDecode() {
 141   DCHECK(thread_checker_.CalledOnValidThread());
 142   DCHECK(hold_decode_);
 143
 144   hold_decode_ = false;
 145
 146   while (!held_decode_callbacks_.empty()) {
 147     SatisfySingleDecode();
 148   }
 149 }
 150
 151 void FakeVideoDecoder::SatisfySingleDecode() {
 152   DCHECK(thread_checker_.CalledOnValidThread());
 153   DCHECK(!held_decode_callbacks_.empty());
 154
 155   DecodeCB decode_cb = held_decode_callbacks_.front();
 156   held_decode_callbacks_.pop_front();
 157   RunDecodeCallback(decode_cb);
 158
 159   if (!reset_cb_.IsNull() && held_decode_callbacks_.empty())
 160     DoReset();
 161 }
 162
 163 void FakeVideoDecoder::SatisfyReset() {
 164   DCHECK(thread_checker_.CalledOnValidThread());
 165   DCHECK(held_decode_callbacks_.empty());
 166   reset_cb_.RunHeldCallback();
 167 }
 168
 169 void FakeVideoDecoder::SimulateError() {
 170   DCHECK(thread_checker_.CalledOnValidThread());
 171
 172   state_ = STATE_ERROR;
 173   while (!held_decode_callbacks_.empty()) {
 174     held_decode_callbacks_.front().Run(kDecodeError);
 175     held_decode_callbacks_.pop_front();
 176   }
 177   decoded_frames_.clear();
 178 }
 179
 180 int FakeVideoDecoder::GetMaxDecodeRequests() const {
 181   return max_parallel_decoding_requests_;
 182 }
 183
 184 void FakeVideoDecoder::OnFrameDecoded(int buffer_size,
 185                                       const DecodeCB& decode_cb,
 186                                       Status status) {
 187   DCHECK(thread_checker_.CalledOnValidThread());
 188
 189   if (status == kOk)
 190     total_bytes_decoded_ += buffer_size;
 191   decode_cb.Run(status);
 192 }
 193
 194 void FakeVideoDecoder::RunOrHoldDecode(const DecodeCB& decode_cb) {
 195   DCHECK(thread_checker_.CalledOnValidThread());
 196
 197   if (hold_decode_) {
 198     held_decode_callbacks_.push_back(decode_cb);
 199   } else {
 200     DCHECK(held_decode_callbacks_.empty());
 201     RunDecodeCallback(decode_cb);
 202   }
 203 }
 204
 205 void FakeVideoDecoder::RunDecodeCallback(const DecodeCB& decode_cb) {
 206   DCHECK(thread_checker_.CalledOnValidThread());
 207
 208   if (!reset_cb_.IsNull()) {
 209     DCHECK(decoded_frames_.empty());
 210     decode_cb.Run(kAborted);
 211     return;
 212   }
 213
 214   // Make sure we leave decoding_delay_ frames in the queue and also frames for
 215   // all pending decode callbacks, except the current one.
 216   if (decoded_frames_.size() >
 217       decoding_delay_ + held_decode_callbacks_.size()) {
 218     output_cb_.Run(decoded_frames_.front());
 219     decoded_frames_.pop_front();
 220   } else if (state_ == STATE_END_OF_STREAM) {
 221     // Drain the queue if this was the last request in the stream, otherwise
 222     // just pop the last frame from the queue.
 223     if (held_decode_callbacks_.empty()) {
 224       while (!decoded_frames_.empty()) {
 225         output_cb_.Run(decoded_frames_.front());
 226         decoded_frames_.pop_front();
 227       }
 228     } else if (!decoded_frames_.empty()) {
 229       output_cb_.Run(decoded_frames_.front());
 230       decoded_frames_.pop_front();
 231     }
 232   }
 233
 234   decode_cb.Run(kOk);
 235 }
 236
 237 void FakeVideoDecoder::DoReset() {
 238   DCHECK(thread_checker_.CalledOnValidThread());
 239   DCHECK(held_decode_callbacks_.empty());
 240   DCHECK(!reset_cb_.IsNull());
 241
 242   reset_cb_.RunOrHold();
 243 }
 244
 245 }  // namespace media