Handle end of stream for media...

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 media {
@@ skipping 69 matching lines @@
 void FFmpegVideoDecoder::OnDecode(Buffer* buffer) {
   // Check for end of stream.
   // TODO(scherkus): check for end of stream.
 
   // 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_);
   }
 
-  // Queue the incoming timestamp.
-  TimeTuple times;
-  times.timestamp = buffer->GetTimestamp();
-  times.duration = buffer->GetDuration();
-  time_queue_.push(times);
-
   // 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().
   int decoded = 0;
   scoped_ptr_malloc<AVFrame, ScopedPtrAVFree> yuv_frame(avcodec_alloc_frame());
   int result = avcodec_decode_video2(codec_context_, yuv_frame.get(), &decoded,
                                      &packet);
 
   // Log the problem if we can't decode a video frame.
   if (result < 0) {
     LOG(INFO) << "Error decoding a video frame with timestamp: "
               << buffer->GetTimestamp().InMicroseconds() << " us"
               << " , duration: "
               << buffer->GetDuration().InMicroseconds() << " us"
               << " , packet size: "
               << buffer->GetDataSize() << " bytes";
   }
 
   // Check for a decoded frame instead of checking the return value of
   // avcodec_decode_video(). We don't need to stop the pipeline on
   // decode errors.
-  if (!decoded)
+  if (decoded == 0) {
+    // Three conditions to meet to declare end of stream for this decoder:
+    // 1. FFmpeg didn't read anything.
+    // 2. FFmpeg didn't output anything.
+    // 3. An end of stream buffer is received.
+    if (result == 0 && buffer->IsEndOfStream()) {
+      // Create an empty video frame and queue it.
+      scoped_refptr<VideoFrame> video_frame;
+      VideoFrameImpl::CreateEmptyFrame(&video_frame);
+      EnqueueResult(video_frame);
+    }
     return;
+  }
+
+  // Queue the incoming timestamp only if we can decode the frame successfully.
+  TimeTuple times;
+  times.timestamp = buffer->GetTimestamp();
+  times.duration = buffer->GetDuration();
+  time_queue_.push(times);
 
   // J (Motion JPEG) versions of YUV are full range 0..255.
   // Regular (MPEG) YUV is 16..240.
   // For now we will ignore the distinction and treat them the same.
 
   VideoSurface::Format surface_format;
   switch (codec_context_->pix_fmt) {
     case PIX_FMT_YUV420P:
     case PIX_FMT_YUVJ420P:
       surface_format = VideoSurface::YV12;
@@ skipping 61 matching lines @@
   }
   DCHECK(bytes_per_line <= source_stride && bytes_per_line <= dest_stride);
   for (size_t i = 0; i < copy_lines; ++i) {
     memcpy(dest, source, bytes_per_line);
     source += source_stride;
     dest += dest_stride;
   }
 }
 
 }  // namespace