Update I420Buffer to new VideoFrameBuffer interface

webrtc/common_video/i420_video_frame_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 15 matching lines @@
 rtc::scoped_refptr<I420Buffer> CreateGradient(int width, int height) {
   rtc::scoped_refptr<I420Buffer> buffer(
       I420Buffer::Create(width, height));
   // Initialize with gradient, Y = 128(x/w + y/h), U = 256 x/w, V = 256 y/h
   for (int x = 0; x < width; x++) {
     for (int y = 0; y < height; y++) {
       buffer->MutableDataY()[x + y * width] =
           128 * (x * height + y * width) / (width * height);
     }
   }
-  int chroma_width = (width + 1) / 2;
-  int chroma_height = (height + 1) / 2;
+  int chroma_width = buffer->ChromaWidth();
+  int chroma_height = buffer->ChromaHeight();
   for (int x = 0; x < chroma_width; x++) {
     for (int y = 0; y < chroma_height; y++) {
       buffer->MutableDataU()[x + y * chroma_width] =
           255 * x / (chroma_width - 1);
       buffer->MutableDataV()[x + y * chroma_width] =
           255 * y / (chroma_height - 1);
     }
   }
   return buffer;
 }
 
 // The offsets and sizes describe the rectangle extracted from the
 // original (gradient) frame, in relative coordinates where the
 // original frame correspond to the unit square, 0.0 <= x, y < 1.0.
-void CheckCrop(const webrtc::VideoFrameBuffer& frame,
+void CheckCrop(const webrtc::I420BufferInterface& frame,
                double offset_x,
                double offset_y,
                double rel_width,
                double rel_height) {
   int width = frame.width();
   int height = frame.height();
   // Check that pixel values in the corners match the gradient used
   // for initialization.
   for (int i = 0; i < 2; i++) {
     for (int j = 0; j < 2; j++) {
       // Pixel coordinates of the corner.
       int x = i * (width - 1);
       int y = j * (height - 1);
       // Relative coordinates, range 0.0 - 1.0 correspond to the
       // size of the uncropped input frame.
       double orig_x = offset_x + i * rel_width;
       double orig_y = offset_y + j * rel_height;
 
       EXPECT_NEAR(frame.DataY()[x + y * frame.StrideY()] / 256.0,
                   (orig_x + orig_y) / 2, 0.02);
       EXPECT_NEAR(frame.DataU()[x / 2 + (y / 2) * frame.StrideU()] / 256.0,
                   orig_x, 0.02);
       EXPECT_NEAR(frame.DataV()[x / 2 + (y / 2) * frame.StrideV()] / 256.0,
                   orig_y, 0.02);
     }
   }
 }
 
-void CheckRotate(int width, int height, webrtc::VideoRotation rotation,
-                 const webrtc::VideoFrameBuffer& rotated) {
+void CheckRotate(int width,
+                 int height,
+                 webrtc::VideoRotation rotation,
+                 const webrtc::I420BufferInterface& rotated) {
   int rotated_width = width;
   int rotated_height = height;
 
   if (rotation == kVideoRotation_90 || rotation == kVideoRotation_270) {
     std::swap(rotated_width, rotated_height);
   }
   EXPECT_EQ(rotated_width, rotated.width());
   EXPECT_EQ(rotated_height, rotated.height());
 
   // Clock-wise order (with 0,0 at top-left)
@@ skipping 60 matching lines @@
                        buffer_y, stride_y,
                        buffer_u, stride_u,
                        buffer_v, stride_v),
       kRotation, 0);
   frame1.set_timestamp(timestamp);
   frame1.set_ntp_time_ms(ntp_time_ms);
   frame1.set_timestamp_us(timestamp_us);
   VideoFrame frame2(frame1);
 
   EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
-  EXPECT_EQ(frame1.video_frame_buffer()->DataY(),
-            frame2.video_frame_buffer()->DataY());
-  EXPECT_EQ(frame1.video_frame_buffer()->DataU(),
-            frame2.video_frame_buffer()->DataU());
-  EXPECT_EQ(frame1.video_frame_buffer()->DataV(),
-            frame2.video_frame_buffer()->DataV());
+  rtc::scoped_refptr<I420BufferInterface> yuv1 =
+      frame1.video_frame_buffer()->GetI420();
+  rtc::scoped_refptr<I420BufferInterface> yuv2 =
+      frame2.video_frame_buffer()->GetI420();
+  EXPECT_EQ(yuv1->DataY(), yuv2->DataY());
+  EXPECT_EQ(yuv1->DataU(), yuv2->DataU());
+  EXPECT_EQ(yuv1->DataV(), yuv2->DataV());
 
   EXPECT_EQ(frame2.timestamp(), frame1.timestamp());
   EXPECT_EQ(frame2.ntp_time_ms(), frame1.ntp_time_ms());
   EXPECT_EQ(frame2.timestamp_us(), frame1.timestamp_us());
   EXPECT_EQ(frame2.rotation(), frame1.rotation());
 
   frame2.set_timestamp(timestamp + 1);
   frame2.set_ntp_time_ms(ntp_time_ms + 1);
   frame2.set_timestamp_us(timestamp_us + 1);
   frame2.set_rotation(kVideoRotation_90);
@@ skipping 94 matching lines @@
       I420Buffer::Create(320, 180));
 
   scaled_buffer->CropAndScaleFrom(*buf);
   CheckCrop(*scaled_buffer, 0.0, 0.125, 1.0, 0.75);
 }
 
 class TestI420BufferRotate
     : public ::testing::TestWithParam<webrtc::VideoRotation> {};
 
 TEST_P(TestI420BufferRotate, Rotates) {
-  rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
-  rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
+  rtc::scoped_refptr<I420BufferInterface> buffer = CreateGradient(640, 480);
+  rtc::scoped_refptr<I420BufferInterface> rotated_buffer =
       I420Buffer::Rotate(*buffer, GetParam());
   CheckRotate(640, 480, GetParam(), *rotated_buffer);
 }
 
 INSTANTIATE_TEST_CASE_P(Rotate, TestI420BufferRotate,
                         ::testing::Values(kVideoRotation_0,
                                           kVideoRotation_90,
                                           kVideoRotation_180,
                                           kVideoRotation_270));
 
 }  // namespace webrtc