Merge 70703 - Handle changes in video frame size....

media/video/ffmpeg_video_decode_engine.cc

 // Copyright (c) 2010 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/video/ffmpeg_video_decode_engine.h"
 
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "media/base/buffers.h"
@@ skipping 109 matching lines @@
       avcodec_thread_init(codec_context_, decode_threads) >= 0 &&
       avcodec_open(codec_context_, codec) >= 0 &&
       av_frame_.get() &&
       buffer_allocated) {
     info.success = true;
   }
   event_handler_ = event_handler;
   event_handler_->OnInitializeComplete(info);
 }
 
-// TODO(fbarchard): Find way to remove this memcpy of the entire image.
+// TODO(scherkus): Move this function to a utility class and unit test.
 static void CopyPlane(size_t plane,
                       scoped_refptr<VideoFrame> video_frame,
-                      const AVFrame* frame) {
+                      const AVFrame* frame,
+                      size_t source_height) {
   DCHECK_EQ(video_frame->width() % 2, 0u);
   const uint8* source = frame->data[plane];
   const size_t source_stride = frame->linesize[plane];
   uint8* dest = video_frame->data(plane);
   const size_t dest_stride = video_frame->stride(plane);
+
+  // Calculate amounts to copy and clamp to minium frame dimensions.
   size_t bytes_per_line = video_frame->width();
-  size_t copy_lines = video_frame->height();
+  size_t copy_lines = std::min(video_frame->height(), source_height);
   if (plane != VideoFrame::kYPlane) {
     bytes_per_line /= 2;
     if (video_frame->format() == VideoFrame::YV12) {
       copy_lines = (copy_lines + 1) / 2;
     }
   }
-  DCHECK(bytes_per_line <= source_stride && bytes_per_line <= dest_stride);
+  bytes_per_line = std::min(bytes_per_line, source_stride);
+
+  // Copy!
   for (size_t i = 0; i < copy_lines; ++i) {
     memcpy(dest, source, bytes_per_line);
     source += source_stride;
     dest += dest_stride;
   }
 }
 
 void FFmpegVideoDecodeEngine::ConsumeVideoSample(
     scoped_refptr<Buffer> buffer) {
   pending_input_buffers_--;
@@ skipping 115 matching lines @@
     // Available frame is guaranteed, because we issue as much reads as
     // available frame, except the case of |frame_decoded| == 0, which
     // implies decoder order delay, and force us to read more inputs.
     DCHECK(frame_queue_available_.size());
     video_frame = frame_queue_available_.front();
     frame_queue_available_.pop_front();
 
     // Copy the frame data since FFmpeg reuses internal buffers for AVFrame
     // output, meaning the data is only valid until the next
     // avcodec_decode_video() call.
-    CopyPlane(VideoFrame::kYPlane, video_frame.get(), av_frame_.get());
-    CopyPlane(VideoFrame::kUPlane, video_frame.get(), av_frame_.get());
-    CopyPlane(VideoFrame::kVPlane, video_frame.get(), av_frame_.get());
+    size_t height = codec_context_->height;
+    CopyPlane(VideoFrame::kYPlane, video_frame.get(), av_frame_.get(), height);
+    CopyPlane(VideoFrame::kUPlane, video_frame.get(), av_frame_.get(), height);
+    CopyPlane(VideoFrame::kVPlane, video_frame.get(), av_frame_.get(), height);
   } else {
     // Get the VideoFrame from allocator which associate with av_frame_.
     video_frame = allocator_->DecodeDone(codec_context_, av_frame_.get());
   }
 
   video_frame->SetTimestamp(timestamp);
   video_frame->SetDuration(duration);
 
   pending_output_buffers_--;
   event_handler_->ConsumeVideoFrame(video_frame);
@@ skipping 60 matching lines @@
       // TODO(scherkus): More formats here?
       return VideoFrame::INVALID;
   }
 }
 
 }  // namespace media
 
 // Disable refcounting for this object because this object only lives
 // on the video decoder thread and there's no need to refcount it.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(media::FFmpegVideoDecodeEngine);