Reland r101418: Fix aspect ratio and clarify video frame dimensions

media/video/ffmpeg_video_decode_engine_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_task.h"
 #include "media/base/pipeline.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::ReturnNull;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 
 namespace media {
 
-static const size_t kWidth = 320;
-static const size_t kHeight = 240;
-static const size_t kSurfaceWidth = 522;
-static const size_t kSurfaceHeight = 288;
+static const gfx::Size kCodedSize(320, 240);
+static const gfx::Rect kVisibleRect(320, 240);
+static const gfx::Size kNaturalSize(522, 288);
 static const AVRational kFrameRate = { 100, 1 };
 
 ACTION_P2(DemuxComplete, engine, buffer) {
   engine->ConsumeVideoSample(buffer);
 }
 
 class FFmpegVideoDecodeEngineTest
     : public testing::Test,
       public VideoDecodeEngine::EventHandler {
  public:
   FFmpegVideoDecodeEngineTest()
-      : config_(kCodecVP8, kWidth, kHeight, kSurfaceWidth, kSurfaceHeight,
+      : config_(kCodecVP8, kCodedSize, kVisibleRect, kNaturalSize,
                 kFrameRate.num, kFrameRate.den, NULL, 0) {
     CHECK(FFmpegGlue::GetInstance());
 
     // Setup FFmpeg structures.
-    frame_buffer_.reset(new uint8[kWidth * kHeight]);
+    frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);
 
     test_engine_.reset(new FFmpegVideoDecodeEngine());
 
     ReadTestDataFile("vp8-I-frame-320x240", &i_frame_buffer_);
     ReadTestDataFile("vp8-corrupt-I-frame", &corrupt_i_frame_buffer_);
 
     end_of_stream_buffer_ = new DataBuffer(0);
   }
 
   ~FFmpegVideoDecodeEngineTest() {
@@ skipping 41 matching lines @@
         .WillOnce(DemuxComplete(test_engine_.get(), buffer))
         .WillRepeatedly(DemuxComplete(test_engine_.get(),
                                       end_of_stream_buffer_));
 
     EXPECT_CALL(*this, ConsumeVideoFrame(_, _))
         .WillOnce(SaveArg<0>(&video_frame_a))
         .WillOnce(SaveArg<0>(&video_frame_b));
     CallProduceVideoFrame();
     CallProduceVideoFrame();
 
-    EXPECT_EQ(kSurfaceWidth, video_frame_a->width());
-    EXPECT_EQ(kSurfaceHeight, video_frame_a->height());
-    EXPECT_EQ(kSurfaceWidth, video_frame_b->width());
-    EXPECT_EQ(kSurfaceHeight, video_frame_b->height());
+    size_t expected_width = static_cast<size_t>(kVisibleRect.width());
+    size_t expected_height = static_cast<size_t>(kVisibleRect.height());
+
+    EXPECT_EQ(expected_width, video_frame_a->width());
+    EXPECT_EQ(expected_height, video_frame_a->height());
+    EXPECT_EQ(expected_width, video_frame_b->width());
+    EXPECT_EQ(expected_height, video_frame_b->height());
   }
 
   // VideoDecodeEngine::EventHandler implementation.
   MOCK_METHOD2(ConsumeVideoFrame,
                void(scoped_refptr<VideoFrame> video_frame,
                     const PipelineStatistics& statistics));
   MOCK_METHOD1(ProduceVideoSample,
                void(scoped_refptr<Buffer> buffer));
   MOCK_METHOD1(OnInitializeComplete,
                void(const VideoCodecInfo& info));
   MOCK_METHOD0(OnUninitializeComplete, void());
   MOCK_METHOD0(OnFlushComplete, void());
   MOCK_METHOD0(OnSeekComplete, void());
   MOCK_METHOD0(OnError, void());
 
   void CallProduceVideoFrame() {
-    test_engine_->ProduceVideoFrame(VideoFrame::CreateFrame(VideoFrame::YV12,
-                                                            kWidth,
-                                                            kHeight,
-                                                            kNoTimestamp,
-                                                            kNoTimestamp));
+    test_engine_->ProduceVideoFrame(VideoFrame::CreateFrame(
+        VideoFrame::YV12, kVisibleRect.width(), kVisibleRect.height(),
+        kNoTimestamp, kNoTimestamp));
   }
 
  protected:
   VideoDecoderConfig config_;
   scoped_ptr<FFmpegVideoDecodeEngine> test_engine_;
   scoped_array<uint8_t> frame_buffer_;
   scoped_refptr<Buffer> i_frame_buffer_;
   scoped_refptr<Buffer> corrupt_i_frame_buffer_;
   scoped_refptr<Buffer> end_of_stream_buffer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegVideoDecodeEngineTest);
 };
 
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_Normal) {
   Initialize();
 }
 
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_FindDecoderFails) {
-  VideoDecoderConfig config(kUnknown, kWidth, kHeight, kSurfaceWidth,
-                            kSurfaceHeight, kFrameRate.num, kFrameRate.den,
-                            NULL, 0);
+  VideoDecoderConfig config(kUnknown, kCodedSize, kVisibleRect, kNaturalSize,
+                            kFrameRate.num, kFrameRate.den, NULL, 0);
   // Test avcodec_find_decoder() returning NULL.
   VideoCodecInfo info;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveArg<0>(&info));
   test_engine_->Initialize(MessageLoop::current(), this, NULL, config);
   EXPECT_FALSE(info.success);
 }
 
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_OpenDecoderFails) {
   // Specify Theora w/o extra data so that avcodec_open() fails.
-  VideoDecoderConfig config(kCodecTheora, kWidth, kHeight, kSurfaceWidth,
-                            kSurfaceHeight, kFrameRate.num, kFrameRate.den,
+  VideoDecoderConfig config(kCodecTheora, kCodedSize, kVisibleRect,
+                            kNaturalSize, kFrameRate.num, kFrameRate.den,
                             NULL, 0);
   VideoCodecInfo info;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveArg<0>(&info));
   test_engine_->Initialize(MessageLoop::current(), this, NULL, config);
   EXPECT_FALSE(info.success);
 }
 
 TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_Normal) {
   Initialize();
@@ skipping 98 matching lines @@
 //  DecodeIFrameThenTestFile("vp8-I-frame-320x480");
 //}
 
 // Decode |i_frame_buffer_| and then a frame with a smaller height and verify
 // the output size didn't change.
 TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_SmallerHeight) {
   DecodeIFrameThenTestFile("vp8-I-frame-320x120");
 }
 
 }  // namespace media