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

media/video/ffmpeg_video_decode_engine_unittest.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 "base/scoped_ptr.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_task.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::SetArgumentPointee;
 using ::testing::StrictMock;
 
 namespace media {
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const AVRational kTimeBase = { 1, 100 };
 
+static void InitializeFrame(uint8_t* data, int width, AVFrame* frame) {
+  frame->data[0] = data;
+  frame->data[1] = data;
+  frame->data[2] = data;
+  frame->linesize[0] = width;
+  frame->linesize[1] = width / 2;
+  frame->linesize[2] = width / 2;
+}
+
+ACTION_P(DecodeComplete, decoder) {
+  decoder->video_frame_ = arg0;
+}
+
+ACTION_P2(DemuxComplete, engine, buffer) {
+  engine->ConsumeVideoSample(buffer);
+}
+
 ACTION_P(SaveInitializeResult, engine) {
   engine->info_ = arg0;
 }
 
 class FFmpegVideoDecodeEngineTest : public testing::Test,
                                     public VideoDecodeEngine::EventHandler {
  protected:
   FFmpegVideoDecodeEngineTest() {
     // Setup FFmpeg structures.
     frame_buffer_.reset(new uint8[kWidth * kHeight]);
     memset(&yuv_frame_, 0, sizeof(yuv_frame_));
-
-    // DecodeFrame will check these pointers as non-NULL value.
-    yuv_frame_.data[0] = yuv_frame_.data[1] = yuv_frame_.data[2]
-        = frame_buffer_.get();
-    yuv_frame_.linesize[0] = kWidth;
-    yuv_frame_.linesize[1] = yuv_frame_.linesize[2] = kWidth >> 1;
+    InitializeFrame(frame_buffer_.get(), kWidth, &yuv_frame_);
 
     memset(&codec_context_, 0, sizeof(codec_context_));
     codec_context_.width = kWidth;
     codec_context_.height = kHeight;
     codec_context_.time_base = kTimeBase;
 
     memset(&codec_, 0, sizeof(codec_));
     memset(&stream_, 0, sizeof(stream_));
     stream_.codec = &codec_context_;
     stream_.r_frame_rate.num = kTimeBase.den;
@@ skipping 35 matching lines @@
     config_.codec = kCodecH264;
     config_.opaque_context = &stream_;
     config_.width = kWidth;
     config_.height = kHeight;
     EXPECT_CALL(*this, OnInitializeComplete(_))
        .WillOnce(SaveInitializeResult(this));
     test_engine_->Initialize(MessageLoop::current(), this, NULL, config_);
     EXPECT_TRUE(info_.success);
   }
 
+  void Decode() {
+    EXPECT_CALL(mock_ffmpeg_, AVInitPacket(_));
+    EXPECT_CALL(mock_ffmpeg_,
+                AVCodecDecodeVideo2(&codec_context_, &yuv_frame_, _, _))
+        .WillOnce(DoAll(SetArgumentPointee<2>(1),  // Simulate 1 byte frame.
+                        Return(0)));
+
+    EXPECT_CALL(*this, ProduceVideoSample(_))
+        .WillOnce(DemuxComplete(test_engine_.get(), buffer_));
+    EXPECT_CALL(*this, ConsumeVideoFrame(_))
+        .WillOnce(DecodeComplete(this));
+    test_engine_->ProduceVideoFrame(video_frame_);
+  }
+
+  void ChangeDimensions(int width, int height) {
+    frame_buffer_.reset(new uint8[width * height]);
+    InitializeFrame(frame_buffer_.get(), width, &yuv_frame_);
+    codec_context_.width = width;
+    codec_context_.height = height;
+  }
+
  public:
   MOCK_METHOD1(ConsumeVideoFrame,
                void(scoped_refptr<VideoFrame> video_frame));
   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());
@@ skipping 77 matching lines @@
   config_.codec = kCodecH264;
   config_.opaque_context = &stream_;
   config_.width = kWidth;
   config_.height = kHeight;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveInitializeResult(this));
   test_engine_->Initialize(MessageLoop::current(), this, NULL, config_);
   EXPECT_FALSE(info_.success);
 }
 
-ACTION_P2(DemuxComplete, engine, buffer) {
-  engine->ConsumeVideoSample(buffer);
-}
-
-ACTION_P(DecodeComplete, decoder) {
-  decoder->video_frame_ = arg0;
-}
-
 TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_Normal) {
   Initialize();
 
   // We rely on FFmpeg for timestamp and duration reporting.  The one tricky
   // bit is calculating the duration when |repeat_pict| > 0.
   const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(123);
   const base::TimeDelta kDuration = base::TimeDelta::FromMicroseconds(15000);
   yuv_frame_.repeat_pict = 1;
   yuv_frame_.reordered_opaque = kTimestamp.InMicroseconds();
 
-  // Expect a bunch of avcodec calls.
-  EXPECT_CALL(mock_ffmpeg_, AVInitPacket(_));
-  EXPECT_CALL(mock_ffmpeg_,
-              AVCodecDecodeVideo2(&codec_context_, &yuv_frame_, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<2>(1),  // Simulate 1 byte frame.
-                      Return(0)));
-
-  EXPECT_CALL(*this, ProduceVideoSample(_))
-      .WillOnce(DemuxComplete(test_engine_.get(), buffer_));
-  EXPECT_CALL(*this, ConsumeVideoFrame(_))
-      .WillOnce(DecodeComplete(this));
-  test_engine_->ProduceVideoFrame(video_frame_);
+  // Simulate decoding a single frame.
+  Decode();
 
   // |video_frame_| timestamp is 0 because we set the timestamp based off
   // the buffer timestamp.
   EXPECT_EQ(0, video_frame_->GetTimestamp().ToInternalValue());
   EXPECT_EQ(kDuration.ToInternalValue(),
             video_frame_->GetDuration().ToInternalValue());
 }
 
 TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_0ByteFrame) {
   Initialize();
@@ skipping 29 matching lines @@
 
   EXPECT_CALL(*this, ProduceVideoSample(_))
       .WillOnce(DemuxComplete(test_engine_.get(), buffer_));
   EXPECT_CALL(*this, ConsumeVideoFrame(_))
       .WillOnce(DecodeComplete(this));
   test_engine_->ProduceVideoFrame(video_frame_);
 
   EXPECT_FALSE(video_frame_.get());
 }
 
+TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_LargerWidth) {
+  Initialize();
+  ChangeDimensions(kWidth * 2, kHeight);
+  Decode();
+}
+
+TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_SmallerWidth) {
+  Initialize();
+  ChangeDimensions(kWidth / 2, kHeight);
+  Decode();
+}
+
+TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_LargerHeight) {
+  Initialize();
+  ChangeDimensions(kWidth, kHeight * 2);
+  Decode();
+}
+
+TEST_F(FFmpegVideoDecodeEngineTest, DecodeFrame_SmallerHeight) {
+  Initialize();
+  ChangeDimensions(kWidth, kHeight / 2);
+  Decode();
+}
+
 TEST_F(FFmpegVideoDecodeEngineTest, GetSurfaceFormat) {
   // YV12 formats.
   codec_context_.pix_fmt = PIX_FMT_YUV420P;
   EXPECT_EQ(VideoFrame::YV12, test_engine_->GetSurfaceFormat());
   codec_context_.pix_fmt = PIX_FMT_YUVJ420P;
   EXPECT_EQ(VideoFrame::YV12, test_engine_->GetSurfaceFormat());
 
   // YV16 formats.
   codec_context_.pix_fmt = PIX_FMT_YUV422P;
   EXPECT_EQ(VideoFrame::YV16, test_engine_->GetSurfaceFormat());
   codec_context_.pix_fmt = PIX_FMT_YUVJ422P;
   EXPECT_EQ(VideoFrame::YV16, test_engine_->GetSurfaceFormat());
 
   // Invalid value.
   codec_context_.pix_fmt = PIX_FMT_NONE;
   EXPECT_EQ(VideoFrame::INVALID, test_engine_->GetSurfaceFormat());
 }
 
 }  // namespace media