Reland r101418: Fix aspect ratio and clarify video frame dimensions

Fixes shared build errors for windows and linux.

BUG=18941,94861
TEST=shared builds compile
TBR=acolwell

Review URL: http://codereview.chromium.org/7932005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@101808 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 35 insertions, 39 deletions

diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index 70ef517..61a8771 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -18,6 +18,7 @@
 #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 {
 
@@ -70,23 +71,25 @@ void FFmpegVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
 
   pts_stream_.Initialize(GetFrameDuration(av_stream));
 
-  int width = av_stream->codec->coded_width;
-  int height = av_stream->codec->coded_height;
-
-  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) {
+  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));
+
+  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,
@@ -340,14 +343,9 @@ void FFmpegVideoDecoder::ProduceVideoSample(
                                    this));
 }
 
-int FFmpegVideoDecoder::width() {
-  DCHECK(info_.success);
-  return info_.surface_width;
-}
-
-int FFmpegVideoDecoder::height() {
+gfx::Size FFmpegVideoDecoder::natural_size() {
   DCHECK(info_.success);
-  return info_.surface_height;
+  return info_.natural_size;
 }
 
 void FFmpegVideoDecoder::FlushBuffers() {
diff --git a/media/filters/ffmpeg_video_decoder.h b/media/filters/ffmpeg_video_decoder.h
index edca948..a09ab5d 100644
--- a/media/filters/ffmpeg_video_decoder.h
+++ b/media/filters/ffmpeg_video_decoder.h
@@ -38,8 +38,7 @@ class MEDIA_EXPORT FFmpegVideoDecoder
                           StatisticsCallback* stats_callback) OVERRIDE;
   virtual void ProduceVideoFrame(
       scoped_refptr<VideoFrame> video_frame) OVERRIDE;
-  virtual int width() OVERRIDE;
-  virtual int height() OVERRIDE;
+  virtual gfx::Size natural_size() OVERRIDE;
 
  private:
   // VideoDecodeEngine::EventHandler interface.
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 460dcb4..e5b9eeb 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -34,8 +34,9 @@ using ::testing::Invoke;
 
 namespace media {
 
-static const int kWidth = 1280;
-static const int kHeight = 720;
+static const gfx::Size kCodedSize(1280, 720);
+static const gfx::Rect kVisibleRect(1280, 720);
+static const gfx::Size kNaturalSize(1280, 720);
 
 // Holds timestamp and duration data needed for properly enqueuing a frame.
 struct TimeTuple {
@@ -98,8 +99,7 @@ class DecoderPrivateMock : public FFmpegVideoDecoder {
 ACTION_P2(EngineInitialize, engine, success) {
   engine->event_handler_ = arg1;
   engine->info_.success = success;
-  engine->info_.surface_width = kWidth;
-  engine->info_.surface_height = kHeight;
+  engine->info_.natural_size = kNaturalSize;
   engine->event_handler_->OnInitializeComplete(engine->info_);
 }
 
@@ -144,11 +144,13 @@ class FFmpegVideoDecoderTest : public testing::Test {
     memset(&codec_, 0, sizeof(codec_));
     memset(&yuv_frame_, 0, sizeof(yuv_frame_));
     base::TimeDelta zero;
-    video_frame_ = VideoFrame::CreateFrame(VideoFrame::YV12, kWidth, kHeight,
+    video_frame_ = VideoFrame::CreateFrame(VideoFrame::YV12,
+                                           kVisibleRect.width(),
+                                           kVisibleRect.height(),
                                            zero, zero);
     stream_.codec = &codec_context_;
-    codec_context_.width = kWidth;
-    codec_context_.height = kHeight;
+    codec_context_.width = kVisibleRect.width();
+    codec_context_.height = kVisibleRect.height();
     codec_context_.codec_id = CODEC_ID_H264;
     stream_.r_frame_rate.num = 1;
     stream_.r_frame_rate.den = 1;
@@ -244,8 +246,7 @@ TEST_F(FFmpegVideoDecoderTest, Initialize_Successful) {
 
   // Test that the uncompressed video surface matches the dimensions
   // specified by FFmpeg.
-  EXPECT_EQ(kWidth, decoder_->width());
-  EXPECT_EQ(kHeight, decoder_->height());
+  EXPECT_EQ(kNaturalSize, decoder_->natural_size());
 }
 
 TEST_F(FFmpegVideoDecoderTest, OnError) {
diff --git a/media/filters/video_renderer_base.cc b/media/filters/video_renderer_base.cc
index b40ec67..c7d37811 100644
--- a/media/filters/video_renderer_base.cc
+++ b/media/filters/video_renderer_base.cc
@@ -148,7 +148,7 @@ void VideoRendererBase::Initialize(VideoDecoder* decoder,
                  base::Unretained(this)));
 
   // Notify the pipeline of the video dimensions.
-  host()->SetVideoSize(decoder_->width(), decoder_->height());
+  host()->SetNaturalVideoSize(decoder_->natural_size());
 
   // Initialize the subclass.
   // TODO(scherkus): do we trust subclasses not to do something silly while
diff --git a/media/filters/video_renderer_base_unittest.cc b/media/filters/video_renderer_base_unittest.cc
index ccef901..b43c805 100644
--- a/media/filters/video_renderer_base_unittest.cc
+++ b/media/filters/video_renderer_base_unittest.cc
@@ -58,8 +58,7 @@ class VideoRendererBaseTest : public ::testing::Test {
     EXPECT_CALL(*decoder_, ProduceVideoFrame(_))
         .WillRepeatedly(Invoke(this, &VideoRendererBaseTest::EnqueueCallback));
 
-    EXPECT_CALL(*decoder_, width()).WillRepeatedly(Return(kWidth));
-    EXPECT_CALL(*decoder_, height()).WillRepeatedly(Return(kHeight));
+    EXPECT_CALL(*decoder_, natural_size()).WillRepeatedly(Return(kNaturalSize));
 
     EXPECT_CALL(stats_callback_object_, OnStatistics(_))
         .Times(AnyNumber());
@@ -92,7 +91,7 @@ class VideoRendererBaseTest : public ::testing::Test {
     InSequence s;
 
     // We expect the video size to be set.
-    EXPECT_CALL(host_, SetVideoSize(kWidth, kHeight));
+    EXPECT_CALL(host_, SetNaturalVideoSize(kNaturalSize));
 
     // Then our subclass will be asked to initialize.
     EXPECT_CALL(*renderer_, OnInitialize(_))
@@ -148,7 +147,8 @@ class VideoRendererBaseTest : public ::testing::Test {
   void CreateFrame(int64 timestamp, int64 duration) {
     const base::TimeDelta kZero;
     scoped_refptr<VideoFrame> frame =
-        VideoFrame::CreateFrame(VideoFrame::RGB32, kWidth, kHeight,
+        VideoFrame::CreateFrame(VideoFrame::RGB32, kNaturalSize.width(),
+                                kNaturalSize.height(),
                                 base::TimeDelta::FromMicroseconds(timestamp),
                                 base::TimeDelta::FromMicroseconds(duration));
     decoder_->VideoFrameReadyForTest(frame);
@@ -162,8 +162,7 @@ class VideoRendererBaseTest : public ::testing::Test {
   }
 
  protected:
-  static const size_t kWidth;
-  static const size_t kHeight;
+  static const gfx::Size kNaturalSize;
   static const int64 kDuration;
 
   StatisticsCallback* NewStatisticsCallback() {
@@ -196,8 +195,7 @@ class VideoRendererBaseTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(VideoRendererBaseTest);
 };
 
-const size_t VideoRendererBaseTest::kWidth = 16u;
-const size_t VideoRendererBaseTest::kHeight = 16u;
+const gfx::Size VideoRendererBaseTest::kNaturalSize(16u, 16u);
 const int64 VideoRendererBaseTest::kDuration = 10;
 
 // Test initialization where the subclass failed for some reason.
@@ -205,7 +203,7 @@ TEST_F(VideoRendererBaseTest, Initialize_Failed) {
   InSequence s;
 
   // We expect the video size to be set.
-  EXPECT_CALL(host_, SetVideoSize(kWidth, kHeight));
+  EXPECT_CALL(host_, SetNaturalVideoSize(kNaturalSize));
 
   // Our subclass will fail when asked to initialize.
   EXPECT_CALL(*renderer_, OnInitialize(_))