Merge 21611 - Implemented proper pausethenseek behaviour for the media pipeli...

media/filters/ffmpeg_video_decoder.cc

 // Copyright (c) 2009 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/base/video_frame_impl.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 
 namespace {
@@ skipping 77 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 void FFmpegVideoDecoder::OnSeek(base::TimeDelta time) {
   // Everything in the presentation time queue is invalid, clear the queue.
   while (!pts_queue_.empty())
     pts_queue_.pop();
+
+  // We're back where we started.  It should be completely safe to flush here
+  // since DecoderBase uses |expecting_discontinuous_| to verify that the next
+  // time OnDecode() is called we will have a discontinuous buffer.
+  state_ = kNormal;
+  avcodec_flush_buffers(codec_context_);
 }
 
 void FFmpegVideoDecoder::OnDecode(Buffer* buffer) {
   // During decode, because reads are issued asynchronously, it is possible to
-  // recieve multiple end of stream buffers since each read is acked. When the
+  // receive multiple end of stream buffers since each read 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
   //            are discarded.
   //   kFlushCodec: There isn't any more input data. Call avcodec_decode_video2
   //                until no more data is returned to flush out remaining
   //                frames. The input buffer is ignored at this point.
   //   kDecodeFinished: All calls return empty frames.
   //
   // These are the possible state transitions.
   //
   // kNormal -> kFlushCodec:
   //     When buffer->IsEndOfStream() is first true.
   // kNormal -> kDecodeFinished:
   //     A catastrophic failure occurs, and decoding needs to stop.
   // kFlushCodec -> kDecodeFinished:
   //     When avcodec_decode_video2() returns 0 data or errors out.
+  // (any state) -> kNormal:
+  //     Any time buffer->IsDiscontinuous() is true.
   //
   // If the decoding is finished, we just always return empty frames.
   if (state_ == kDecodeFinished) {
     EnqueueEmptyFrame();
     return;
   }
 
   // Transition to kFlushCodec on the first end of stream buffer.
   if (state_ == kNormal && buffer->IsEndOfStream()) {
     state_ = kFlushCodec;
@@ skipping 100 matching lines @@
 
 void FFmpegVideoDecoder::EnqueueEmptyFrame() {
   scoped_refptr<VideoFrame> video_frame;
   VideoFrameImpl::CreateEmptyFrame(&video_frame);
   EnqueueResult(video_frame);
 }
 
 bool FFmpegVideoDecoder::DecodeFrame(const Buffer& buffer,
                                      AVCodecContext* codec_context,
                                      AVFrame* yuv_frame) {
-  // Check for discontinuous buffer. If we receive a discontinuous buffer here,
-  // flush the internal buffer of FFmpeg.
-  if (buffer.IsDiscontinuous()) {
-    avcodec_flush_buffers(codec_context);
-  }
-
   // Create a packet for input data.
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
   av_init_packet(&packet);
   packet.data = const_cast<uint8*>(buffer.GetData());
   packet.size = buffer.GetDataSize();
 
   // We don't allocate AVFrame on the stack since different versions of FFmpeg
   // may change the size of AVFrame, causing stack corruption.  The solution is
   // to let FFmpeg allocate the structure via avcodec_alloc_frame().
@@ skipping 85 matching lines @@
 // static
 bool FFmpegVideoDecoder::PtsHeapOrdering::operator()(
     const base::TimeDelta& lhs,
     const base::TimeDelta& rhs) const {
   // std::priority_queue is a max-heap. We want lower timestamps to show up
   // first so reverse the natural less-than comparison.
   return rhs < lhs;
 }
 
 }  // namespace