Add delay in FFmpegVideoDecoder::Decode().

media/filters/ffmpeg_video_decoder.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 "media/filters/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
 
 static size_t RoundUp(size_t value, size_t alignment) {
   // Check that |alignment| is a power of 2.
   DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
   return ((value + (alignment - 1)) & ~(alignment - 1));
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner), state_(kUninitialized),
-      decode_nalus_(false) {}
+      decode_nalus_(false), weak_factory_(this) {}
 
 int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context,
                                        AVFrame* frame,
                                        int flags) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
   // updated width/height/pix_fmt, which can change for adaptive
   // content.
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context->pix_fmt);
@@ skipping 57 matching lines @@
                        ReleaseVideoBufferImpl,
                        opaque,
                        0);
   return 0;
 }
 
 void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                     bool low_delay,
                                     const PipelineStatusCB& status_cb,
                                     const OutputCB& output_cb) {
+  DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!config.is_encrypted());
   DCHECK(!output_cb.is_null());
 
   FFmpegGlue::InitializeFFmpeg();
 
   config_ = config;
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
   if (!config.IsValidConfig() || !ConfigureDecoder(low_delay)) {
     initialize_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   output_cb_ = BindToCurrentLoop(output_cb);
 
   // Success!
   state_ = kNormal;
   initialize_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                                 const DecodeCB& decode_cb) {
+  DVLOG(2) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  static int count = 1;
+  count++;
+  int delay = 1;
+  if (count % 100 == 0)
+    delay = 2000;
+
+  //base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(delay));
+  //DecodeInternal(buffer, decode_cb);
+
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&FFmpegVideoDecoder::DecodeInternal,
+                                           weak_factory_.GetWeakPtr(),
+                                           buffer,
+                                           decode_cb),
+                                base::TimeDelta::FromMilliseconds(delay));
+}
+
+void FFmpegVideoDecoder::DecodeInternal(const scoped_refptr<DecoderBuffer>& buffer,
+                                const DecodeCB& decode_cb) {
+  DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(buffer);
   DCHECK(!decode_cb.is_null());
   CHECK_NE(state_, kUninitialized);
 
   DecodeCB decode_cb_bound = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError) {
     decode_cb_bound.Run(kDecodeError);
     return;
   }
 
   if (state_ == kDecodeFinished) {
     decode_cb_bound.Run(kOk);
     return;
   }
 
+  //base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(40));
+
   DCHECK_EQ(state_, kNormal);
 
   // During decode, because reads are issued asynchronously, it is possible to
   // receive multiple end of stream buffers since each decode is acked. When the
   // first end of stream buffer is read, FFmpeg may still have frames queued
   // up in the decoder so we need to go through the decode loop until it stops
   // giving sensible data.  After that, the decoder should output empty
   // frames.  There are three states the decoder can be in:
   //
   //   kNormal: This is the starting state. Buffers are decoded. Decode errors
@@ skipping 95 matching lines @@
     LOG(ERROR) << "Video frame was produced yet has invalid frame data.";
     av_frame_unref(av_frame_.get());
     return false;
   }
 
   scoped_refptr<VideoFrame> frame =
       reinterpret_cast<VideoFrame*>(av_buffer_get_opaque(av_frame_->buf[0]));
   frame->set_timestamp(
       base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
   *has_produced_frame = true;
+
   output_cb_.Run(frame);
 
   av_frame_unref(av_frame_.get());
   return true;
 }
 
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
   codec_context_.reset();
   av_frame_.reset();
 }
@@ skipping 20 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media