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