Reland r101418: Fix aspect ratio and clarify video frame dimensions

media/filters/ffmpeg_video_decoder.cc

 // Copyright (c) 2011 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 <deque>
 
 #include "base/bind.h"
 #include "base/task.h"
 #include "media/base/callback.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 #include "media/video/video_decode_context.h"
+#include "ui/gfx/rect.h"
 
 namespace media {
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(MessageLoop* message_loop,
                                        VideoDecodeContext* decode_context)
     : message_loop_(message_loop),
       state_(kUnInitialized),
       decode_engine_(new FFmpegVideoDecodeEngine()),
       decode_context_(decode_context) {
   memset(&info_, 0, sizeof(info_));
@@ skipping 32 matching lines @@
 
   AVStream* av_stream = demuxer_stream->GetAVStream();
   if (!av_stream) {
     VideoCodecInfo info = {0};
     OnInitializeComplete(info);
     return;
   }
 
   pts_stream_.Initialize(GetFrameDuration(av_stream));
 
-  int width = av_stream->codec->coded_width;
-  int height = av_stream->codec->coded_height;
+  gfx::Size coded_size(
+      av_stream->codec->coded_width, av_stream->codec->coded_height);
+  // TODO(vrk): This assumes decoded frame data starts at (0, 0), which is true
+  // for now, but may not always be true forever. Fix this in the future.
+  gfx::Rect visible_rect(
+      av_stream->codec->width, av_stream->codec->height);
+  gfx::Size natural_size(
+      GetNaturalWidth(av_stream), GetNaturalHeight(av_stream));
 
-  int surface_width = GetSurfaceWidth(av_stream);
-  int surface_height = GetSurfaceHeight(av_stream);
-
-  if (surface_width > Limits::kMaxDimension ||
-      surface_height > Limits::kMaxDimension ||
-      (surface_width * surface_height) > Limits::kMaxCanvas) {
+  if (natural_size.width() > Limits::kMaxDimension ||
+      natural_size.height() > Limits::kMaxDimension ||
+      natural_size.GetArea() > Limits::kMaxCanvas) {
     VideoCodecInfo info = {0};
     OnInitializeComplete(info);
     return;
   }
 
   VideoDecoderConfig config(CodecIDToVideoCodec(av_stream->codec->codec_id),
-                            width, height,
-                            surface_width, surface_height,
+                            coded_size, visible_rect, natural_size,
                             av_stream->r_frame_rate.num,
                             av_stream->r_frame_rate.den,
                             av_stream->codec->extradata,
                             av_stream->codec->extradata_size);
   state_ = kInitializing;
   decode_engine_->Initialize(message_loop_, this, NULL, config);
 }
 
 void FFmpegVideoDecoder::OnInitializeComplete(const VideoCodecInfo& info) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ skipping 233 matching lines @@
 
 void FFmpegVideoDecoder::ProduceVideoSample(
     scoped_refptr<Buffer> buffer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kStopped);
 
   demuxer_stream_->Read(base::Bind(&FFmpegVideoDecoder::OnReadComplete,
                                    this));
 }
 
-int FFmpegVideoDecoder::width() {
+gfx::Size FFmpegVideoDecoder::natural_size() {
   DCHECK(info_.success);
-  return info_.surface_width;
-}
-
-int FFmpegVideoDecoder::height() {
-  DCHECK(info_.success);
-  return info_.surface_height;
+  return info_.natural_size;
 }
 
 void FFmpegVideoDecoder::FlushBuffers() {
   while (!frame_queue_flushed_.empty()) {
     scoped_refptr<VideoFrame> video_frame;
     video_frame = frame_queue_flushed_.front();
     frame_queue_flushed_.pop_front();
 
     // Return frames back to the decode engine.
     decode_engine_->ProduceVideoFrame(video_frame);
   }
 }
 
 void FFmpegVideoDecoder::SetVideoDecodeEngineForTest(
     VideoDecodeEngine* engine) {
   decode_engine_.reset(engine);
 }
 
 }  // namespace media