Reland of Delete cricket::VideoFrame methods GetYPlane and GetYPitch.

webrtc/media/base/videoframe_unittest.h

 /*
  *  Copyright (c) 2004 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 249 matching lines @@
                      uint32_t height,
                      T* frame) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return false;
     }
 
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     int awidth = (width + 1) & ~1;
     frame->InitToBlack(width, height, 0);
-    int stride_y = frame->GetYPitch();
-    int stride_u = frame->GetUPitch();
-    int stride_v = frame->GetVPitch();
+    int stride_y = frame->video_frame_buffer()->StrideY();
+    int stride_u = frame->video_frame_buffer()->StrideU();
+    int stride_v = frame->video_frame_buffer()->StrideV();
+    uint8_t* plane_y = frame->video_frame_buffer()->MutableDataY();
+    uint8_t* plane_u = frame->video_frame_buffer()->MutableDataU();
+    uint8_t* plane_v = frame->video_frame_buffer()->MutableDataV();
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; x += 2) {
         const uint8_t* quad1 = start + (y * awidth + x) * 2;
-        frame->GetYPlane()[stride_y * y + x] = quad1[y1_pos];
+        plane_y[stride_y * y + x] = quad1[y1_pos];
         if ((x + 1) < width) {
-          frame->GetYPlane()[stride_y * y + x + 1] = quad1[y2_pos];
+          plane_y[stride_y * y + x + 1] = quad1[y2_pos];
         }
         if ((y & 1) == 0) {
           const uint8_t* quad2 = quad1 + awidth * 2;
           if ((y + 1) >= height) {
             quad2 = quad1;
           }
-          frame->GetUPlane()[stride_u * (y / 2) + x / 2] =
+          plane_u[stride_u * (y / 2) + x / 2] =
               (quad1[u_pos] + quad2[u_pos] + 1) / 2;
-          frame->GetVPlane()[stride_v * (y / 2) + x / 2] =
+          plane_v[stride_v * (y / 2) + x / 2] =
               (quad1[v_pos] + quad2[v_pos] + 1) / 2;
         }
       }
     }
     return true;
   }
 
   // Convert RGB to 420.
   // A negative height inverts the image.
   bool ConvertRgb(const rtc::MemoryStream* ms,
                   uint32_t fourcc,
                   int32_t width,
                   int32_t height,
                   T* frame) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return false;
     }
     int pitch = width * bytes;
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     if (height < 0) {
       height = -height;
       start = start + pitch * (height - 1);
       pitch = -pitch;
     }
     frame->InitToBlack(width, height, 0);
-    int stride_y = frame->GetYPitch();
-    int stride_u = frame->GetUPitch();
-    int stride_v = frame->GetVPitch();
+    int stride_y = frame->video_frame_buffer()->StrideY();
+    int stride_u = frame->video_frame_buffer()->StrideU();
+    int stride_v = frame->video_frame_buffer()->StrideV();
+    uint8_t* plane_y = frame->video_frame_buffer()->MutableDataY();
+    uint8_t* plane_u = frame->video_frame_buffer()->MutableDataU();
+    uint8_t* plane_v = frame->video_frame_buffer()->MutableDataV();
     for (int32_t y = 0; y < height; y += 2) {
       for (int32_t x = 0; x < width; x += 2) {
         const uint8_t* rgb[4];
         uint8_t yuv[4][3];
         rgb[0] = start + y * pitch + x * bytes;
         rgb[1] = rgb[0] + ((x + 1) < width ? bytes : 0);
         rgb[2] = rgb[0] + ((y + 1) < height ? pitch : 0);
         rgb[3] = rgb[2] + ((x + 1) < width ? bytes : 0);
         for (size_t i = 0; i < 4; ++i) {
           ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos],
                           &yuv[i][0], &yuv[i][1], &yuv[i][2]);
         }
-        frame->GetYPlane()[stride_y * y + x] = yuv[0][0];
+        plane_y[stride_y * y + x] = yuv[0][0];
         if ((x + 1) < width) {
-          frame->GetYPlane()[stride_y * y + x + 1] = yuv[1][0];
+          plane_y[stride_y * y + x + 1] = yuv[1][0];
         }
         if ((y + 1) < height) {
-          frame->GetYPlane()[stride_y * (y + 1) + x] = yuv[2][0];
+          plane_y[stride_y * (y + 1) + x] = yuv[2][0];
           if ((x + 1) < width) {
-            frame->GetYPlane()[stride_y * (y + 1) + x + 1] = yuv[3][0];
+            plane_y[stride_y * (y + 1) + x + 1] = yuv[3][0];
           }
         }
-        frame->GetUPlane()[stride_u * (y / 2) + x / 2] =
+        plane_u[stride_u * (y / 2) + x / 2] =
             (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4;
-        frame->GetVPlane()[stride_v * (y / 2) + x / 2] =
+        plane_v[stride_v * (y / 2) + x / 2] =
             (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4;
       }
     }
     return true;
   }
 
   // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia.
   void ConvertRgbPixel(uint8_t r,
                        uint8_t g,
                        uint8_t b,
@@ skipping 36 matching lines @@
     } else if (fourcc == cricket::FOURCC_ARGB) {
       *r_pos = 2; *g_pos = 1; *b_pos = 0; *bytes = 4;  // BGRA in memory.
     } else {
       return false;
     }
     return true;
   }
 
   // Comparison functions for testing.
   static bool IsNull(const cricket::VideoFrame& frame) {
-    return !frame.GetYPlane();
+    return !frame.video_frame_buffer();
   }
 
   static bool IsSize(const cricket::VideoFrame& frame,
                      int width,
                      int height) {
-    return !IsNull(frame) && frame.GetYPitch() >= width &&
-           frame.GetUPitch() >= width / 2 &&
-           frame.GetVPitch() >= width / 2 &&
+    return !IsNull(frame) && frame.video_frame_buffer()->StrideY() >= width &&
+           frame.video_frame_buffer()->StrideU() >= width / 2 &&
+           frame.video_frame_buffer()->StrideV() >= width / 2 &&
            frame.width() == width && frame.height() == height;
   }
 
   static bool IsPlaneEqual(const std::string& name,
                            const uint8_t* plane1,
                            uint32_t pitch1,
                            const uint8_t* plane2,
                            uint32_t pitch2,
                            uint32_t width,
                            uint32_t height,
@@ skipping 20 matching lines @@
                       int width,
                       int height,
                       int64_t time_stamp,
                       const uint8_t* y,
                       uint32_t ypitch,
                       const uint8_t* u,
                       uint32_t upitch,
                       const uint8_t* v,
                       uint32_t vpitch,
                       int max_error) {
-    return IsSize(frame, width, height) &&
-           frame.GetTimeStamp() == time_stamp &&
-           IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
+    return IsSize(frame, width, height) && frame.GetTimeStamp() == time_stamp &&
+           IsPlaneEqual("y", frame.video_frame_buffer()->DataY(),
+                        frame.video_frame_buffer()->StrideY(), y, ypitch,
                         static_cast<uint32_t>(width),
                         static_cast<uint32_t>(height), max_error) &&
-           IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
+           IsPlaneEqual("u", frame.video_frame_buffer()->DataU(),
+                        frame.video_frame_buffer()->StrideU(), u, upitch,
                         static_cast<uint32_t>((width + 1) / 2),
                         static_cast<uint32_t>((height + 1) / 2), max_error) &&
-           IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
+           IsPlaneEqual("v", frame.video_frame_buffer()->DataV(),
+                        frame.video_frame_buffer()->StrideV(), v, vpitch,
                         static_cast<uint32_t>((width + 1) / 2),
                         static_cast<uint32_t>((height + 1) / 2), max_error);
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame1,
                       const cricket::VideoFrame& frame2,
                       int max_error) {
     return IsEqual(frame1,
                    frame2.width(), frame2.height(),
                    frame2.GetTimeStamp(),
-                   frame2.GetYPlane(), frame2.GetYPitch(),
-                   frame2.GetUPlane(), frame2.GetUPitch(),
-                   frame2.GetVPlane(), frame2.GetVPitch(),
+                   frame2.video_frame_buffer()->DataY(),
+                   frame2.video_frame_buffer()->StrideY(),
+                   frame2.video_frame_buffer()->DataU(),
+                   frame2.video_frame_buffer()->StrideU(),
+                   frame2.video_frame_buffer()->DataV(),
+                   frame2.video_frame_buffer()->StrideV(),
                    max_error);
   }
 
   static bool IsEqualWithCrop(const cricket::VideoFrame& frame1,
                               const cricket::VideoFrame& frame2,
                               int hcrop, int vcrop, int max_error) {
     return frame1.width() <= frame2.width() &&
            frame1.height() <= frame2.height() &&
            IsEqual(frame1,
                    frame2.width() - hcrop * 2,
                    frame2.height() - vcrop * 2,
                    frame2.GetTimeStamp(),
-                   frame2.GetYPlane() + vcrop * frame2.GetYPitch()
+                   frame2.video_frame_buffer()->DataY()
+                       + vcrop * frame2.video_frame_buffer()->StrideY()
                        + hcrop,
-                   frame2.GetYPitch(),
-                   frame2.GetUPlane() + vcrop * frame2.GetUPitch() / 2
+                   frame2.video_frame_buffer()->StrideY(),
+                   frame2.video_frame_buffer()->DataU()
+                       + vcrop * frame2.video_frame_buffer()->StrideU() / 2
                        + hcrop / 2,
-                   frame2.GetUPitch(),
-                   frame2.GetVPlane() + vcrop * frame2.GetVPitch() / 2
+                   frame2.video_frame_buffer()->StrideU(),
+                   frame2.video_frame_buffer()->DataV()
+                       + vcrop * frame2.video_frame_buffer()->StrideV() / 2
                        + hcrop / 2,
-                   frame2.GetVPitch(),
+                   frame2.video_frame_buffer()->StrideV(),
                    max_error);
   }
 
   static bool IsBlack(const cricket::VideoFrame& frame) {
     return !IsNull(frame) &&
-        *frame.GetYPlane() == 16 &&
-        *frame.GetUPlane() == 128 &&
-        *frame.GetVPlane() == 128;
+           *frame.video_frame_buffer()->DataY() == 16 &&
+           *frame.video_frame_buffer()->DataU() == 128 &&
+           *frame.video_frame_buffer()->DataV() == 128;
   }
 
   ////////////////////////
   // Construction tests //
   ////////////////////////
 
   // Test constructing an image from a I420 buffer.
   void ConstructI420() {
     T frame;
     EXPECT_TRUE(IsNull(frame));
@@ skipping 26 matching lines @@
 
   // Test constructing an image from a I422 buffer.
   void ConstructI422() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
     std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
     uint8_t* y = ALIGNP(buf.get(), kAlignment);
     uint8_t* u = y + kWidth * kHeight;
     uint8_t* v = u + (kWidth / 2) * kHeight;
-    EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
-                                    frame1.GetUPlane(), frame1.GetUPitch(),
-                                    frame1.GetVPlane(), frame1.GetVPitch(),
+    EXPECT_EQ(0, libyuv::I420ToI422(frame1.video_frame_buffer()->DataY(),
+                                    frame1.video_frame_buffer()->StrideY(),
+                                    frame1.video_frame_buffer()->DataU(),
+                                    frame1.video_frame_buffer()->StrideU(),
+                                    frame1.video_frame_buffer()->DataV(),
+                                    frame1.video_frame_buffer()->StrideV(),
                                     y, kWidth,
                                     u, kWidth / 2,
                                     v, kWidth / 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(y, buf_size, cricket::FOURCC_I422,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 1));
   }
 
   // Test constructing an image from a YUY2 buffer.
   void ConstructYuy2() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
     std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
     uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment);
-    EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
-                                    frame1.GetUPlane(), frame1.GetUPitch(),
-                                    frame1.GetVPlane(), frame1.GetVPitch(),
+    EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.video_frame_buffer()->DataY(),
+                                    frame1.video_frame_buffer()->StrideY(),
+                                    frame1.video_frame_buffer()->DataU(),
+                                    frame1.video_frame_buffer()->StrideU(),
+                                    frame1.video_frame_buffer()->DataV(),
+                                    frame1.video_frame_buffer()->StrideV(),
                                     yuy2, kWidth * 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
   // Test constructing an image from a YUY2 buffer with buffer unaligned.
   void ConstructYuy2Unaligned() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
     std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment + 1]);
     uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment) + 1;
-    EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
-                                    frame1.GetUPlane(), frame1.GetUPitch(),
-                                    frame1.GetVPlane(), frame1.GetVPitch(),
+    EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.video_frame_buffer()->DataY(),
+                                    frame1.video_frame_buffer()->StrideY(),
+                                    frame1.video_frame_buffer()->DataU(),
+                                    frame1.video_frame_buffer()->StrideU(),
+                                    frame1.video_frame_buffer()->DataV(),
+                                    frame1.video_frame_buffer()->StrideV(),
                                     yuy2, kWidth * 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
   // Test constructing an image from a wide YUY2 buffer.
   // Normal is 1280x720.  Wide is 12800x72
   void ConstructYuy2Wide() {
@@ skipping 192 matching lines @@
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth,          \
                           -kHeight, kWidth, kHeight,                           \
                           webrtc::kVideoRotation_180, &frame1));               \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
-                            data_size, 0, webrtc::kVideoRotation_0));    \
-    int width_rotate = frame1.width();                                  \
-    int height_rotate = frame1.height();                                \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));     \
-    libyuv::I420Mirror(                                                        \
-        frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
-        frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
-        frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
-        frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
-        kHeight);                                                              \
+                            data_size, 0, webrtc::kVideoRotation_0));          \
+    int width_rotate = frame1.width();                                         \
+    int height_rotate = frame1.height();                                       \
+    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));           \
+    libyuv::I420Mirror(frame2.video_frame_buffer()->DataY(),                   \
+                       frame2.video_frame_buffer()->StrideY(),                 \
+                       frame2.video_frame_buffer()->DataU(),                   \
+                       frame2.video_frame_buffer()->StrideU(),                 \
+                       frame2.video_frame_buffer()->DataV(),                   \
+                       frame2.video_frame_buffer()->StrideV(),                 \
+                       frame3.video_frame_buffer()->MutableDataY(),            \
+                       frame3.video_frame_buffer()->StrideY(),                 \
+                       frame3.video_frame_buffer()->MutableDataU(),            \
+                       frame3.video_frame_buffer()->StrideU(),                 \
+                       frame3.video_frame_buffer()->MutableDataV(),            \
+                       frame3.video_frame_buffer()->StrideV(),                 \
+                       kWidth, kHeight);                                       \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
   TEST_MIRROR(I420, 420)
 
 // Macro to help test different rotations
 #define TEST_ROTATE(FOURCC, BPP, ROTATE)                                       \
   void Construct##FOURCC##Rotate##ROTATE() {                                   \
     T frame1, frame2, frame3;                                                  \
     std::unique_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth, kHeight, \
                           kWidth, kHeight, webrtc::kVideoRotation_##ROTATE,    \
                           &frame1));                                           \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
-                            data_size, 0, webrtc::kVideoRotation_0));    \
-    int width_rotate = frame1.width();                                  \
-    int height_rotate = frame1.height();                                \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));     \
-    libyuv::I420Rotate(                                                        \
-        frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
-        frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
-        frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
-        frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
-        kHeight, libyuv::kRotate##ROTATE);                                     \
+                            data_size, 0, webrtc::kVideoRotation_0));          \
+    int width_rotate = frame1.width();                                         \
+    int height_rotate = frame1.height();                                       \
+    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));           \
+    libyuv::I420Rotate(frame2.video_frame_buffer()->DataY(),                   \
+                       frame2.video_frame_buffer()->StrideY(),                 \
+                       frame2.video_frame_buffer()->DataU(),                   \
+                       frame2.video_frame_buffer()->StrideU(),                 \
+                       frame2.video_frame_buffer()->DataV(),                   \
+                       frame2.video_frame_buffer()->StrideV(),                 \
+                       frame3.video_frame_buffer()->MutableDataY(),            \
+                       frame3.video_frame_buffer()->StrideY(),                 \
+                       frame3.video_frame_buffer()->MutableDataU(),            \
+                       frame3.video_frame_buffer()->StrideU(),                 \
+                       frame3.video_frame_buffer()->MutableDataV(),            \
+                       frame3.video_frame_buffer()->StrideV(),                 \
+                       kWidth, kHeight, libyuv::kRotate##ROTATE);              \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
   // Test constructing an image with rotation.
   TEST_ROTATE(I420, 12, 0)
   TEST_ROTATE(I420, 12, 90)
   TEST_ROTATE(I420, 12, 180)
   TEST_ROTATE(I420, 12, 270)
   TEST_ROTATE(YV12, 12, 0)
   TEST_ROTATE(YV12, 12, 90)
@@ skipping 99 matching lines @@
     T frame;
     uint8_t pixels5x5[5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) * 2];
     memset(pixels5x5, 1, 5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) *  2);
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 5, 5, 5, 5, pixels5x5,
                              sizeof(pixels5x5), 0,
                              webrtc::kVideoRotation_0));
     }
     EXPECT_EQ(5, frame.width());
     EXPECT_EQ(5, frame.height());
-    EXPECT_EQ(5, frame.GetYPitch());
-    EXPECT_EQ(3, frame.GetUPitch());
-    EXPECT_EQ(3, frame.GetVPitch());
+    EXPECT_EQ(5, frame.video_frame_buffer()->StrideY());
+    EXPECT_EQ(3, frame.video_frame_buffer()->StrideU());
+    EXPECT_EQ(3, frame.video_frame_buffer()->StrideV());
   }
 
   // Test 1 pixel edge case image ARGB buffer.
   void ConstructARGB1Pixel() {
     T frame;
     uint8_t pixel[4] = {64, 128, 192, 255};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 1, 1, 1, 1, pixel,
                              sizeof(pixel), 0,
                              webrtc::kVideoRotation_0));
@@ skipping 146 matching lines @@
     EXPECT_TRUE(IsEqual(frame1, frame2, 32));
   }
 
   // Test constructing an image from an I400 MJPG buffer.
   // TODO(fbarchard): Stronger compare on chroma.  Compare agaisnt a grey image.
   void ConstructMjpgI400() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     ASSERT_TRUE(LoadFrame(kJpeg400Filename,
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsPlaneEqual("y", frame1.GetYPlane(), frame1.GetYPitch(),
-                             frame2.GetYPlane(), frame2.GetYPitch(),
+    EXPECT_TRUE(IsPlaneEqual("y", frame1.video_frame_buffer()->DataY(),
+                             frame1.video_frame_buffer()->StrideY(),
+                             frame2.video_frame_buffer()->DataY(),
+                             frame2.video_frame_buffer()->StrideY(),
                              kWidth, kHeight, 32));
     EXPECT_TRUE(IsEqual(frame1, frame2, 128));
   }
 
   // Test constructing an image from an I420 MJPG buffer.
   void ValidateFrame(const char* name,
                      uint32_t fourcc,
                      int data_adjust,
                      int size_adjust,
                      bool expected_result) {
@@ skipping 161 matching lines @@
   }
 
   // Test creating a copy and check that it just increments the refcount.
   void ConstructCopyIsRef() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame2.Init(frame1));
     }
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
-    EXPECT_EQ(frame1.GetYPlane(), frame2.GetYPlane());
-    EXPECT_EQ(frame1.GetUPlane(), frame2.GetUPlane());
-    EXPECT_EQ(frame1.GetVPlane(), frame2.GetVPlane());
+    EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
   }
 
   // Test creating an empty image and initing it to black.
   void ConstructBlack() {
     T frame;
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 0));
     }
     EXPECT_TRUE(IsSize(frame, kWidth, kHeight));
     EXPECT_TRUE(IsBlack(frame));
@@ skipping 92 matching lines @@
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
     for (int i = 0; i < repeat_to; ++i) {
       EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc,
                                                     out,
                                                     out_size, stride));
     }
     EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 0));
     for (int i = 0; i < repeat_from; ++i) {
       EXPECT_EQ(0, RGBToI420(out, stride,
-                             frame2.GetYPlane(), frame2.GetYPitch(),
-                             frame2.GetUPlane(), frame2.GetUPitch(),
-                             frame2.GetVPlane(), frame2.GetVPitch(),
+                             frame2.video_frame_buffer()->MutableDataY(),
+                             frame2.video_frame_buffer()->StrideY(),
+                             frame2.video_frame_buffer()->MutableDataU(),
+                             frame2.video_frame_buffer()->StrideU(),
+                             frame2.video_frame_buffer()->MutableDataV(),
+                             frame2.video_frame_buffer()->StrideV(),
                              kWidth, kHeight));
     }
     if (rowpad) {
       EXPECT_EQ(0, outtop[kWidth * bpp]);  // Ensure stride skipped end of row.
       EXPECT_NE(0, outtop[astride]);       // Ensure pixel at start of 2nd row.
     } else {
       EXPECT_NE(0, outtop[kWidth * bpp]);  // Expect something to be here.
     }
     EXPECT_EQ(0, outtop[out_size]);      // Ensure no overrun.
     EXPECT_TRUE(IsEqual(frame1, frame2, error));
@@ skipping 282 matching lines @@
   // Test converting from I420 to I422.
   void ConvertToI422Buffer() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
     std::unique_ptr<uint8_t[]> buf(new uint8_t[out_size + kAlignment]);
     uint8_t* y = ALIGNP(buf.get(), kAlignment);
     uint8_t* u = y + kWidth * kHeight;
     uint8_t* v = u + (kWidth / 2) * kHeight;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     for (int i = 0; i < repeat_; ++i) {
-      EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
-                                      frame1.GetUPlane(), frame1.GetUPitch(),
-                                      frame1.GetVPlane(), frame1.GetVPitch(),
+      EXPECT_EQ(0, libyuv::I420ToI422(frame1.video_frame_buffer()->DataY(),
+                                      frame1.video_frame_buffer()->StrideY(),
+                                      frame1.video_frame_buffer()->DataU(),
+                                      frame1.video_frame_buffer()->StrideU(),
+                                      frame1.video_frame_buffer()->DataV(),
+                                      frame1.video_frame_buffer()->StrideV(),
                                       y, kWidth,
                                       u, kWidth / 2,
                                       v, kWidth / 2,
                                       kWidth, kHeight));
     }
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_I422, kWidth, kHeight, kWidth,
                             kHeight, y, out_size, 1, 1, 0,
                             webrtc::kVideoRotation_0));
     EXPECT_TRUE(IsEqual(frame1, frame2, 1));
   }
 
   ///////////////////
   // General tests //
   ///////////////////
 
   void Copy() {
     std::unique_ptr<T> source(new T);
     std::unique_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     source.reset();
-    EXPECT_TRUE(target->GetYPlane() != NULL);
+    ASSERT_TRUE(target->video_frame_buffer() != NULL);
+    EXPECT_TRUE(target->video_frame_buffer()->DataY() != NULL);
   }
 
   void CopyIsRef() {
     std::unique_ptr<T> source(new T);
     std::unique_ptr<const cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     const T* const_source = source.get();
-    EXPECT_EQ(const_source->GetYPlane(), target->GetYPlane());
-    EXPECT_EQ(const_source->GetUPlane(), target->GetUPlane());
-    EXPECT_EQ(const_source->GetVPlane(), target->GetVPlane());
+    EXPECT_EQ(const_source->video_frame_buffer(), target->video_frame_buffer());
   }
 
   void StretchToFrame() {
     // Create the source frame as a black frame.
     T source;
     EXPECT_TRUE(source.InitToBlack(kWidth * 2, kHeight * 2, 0));
     EXPECT_TRUE(IsSize(source, kWidth * 2, kHeight * 2));
 
     // Create the target frame by loading from a file.
     T target1;
     ASSERT_TRUE(LoadFrameNoRepeat(&target1));
     EXPECT_FALSE(IsBlack(target1));
 
     // Stretch and check if the stretched target is black.
     source.StretchToFrame(&target1, true, false);
     EXPECT_TRUE(IsBlack(target1));
 
     // Crop and stretch and check if the stretched target is black.
     T target2;
     ASSERT_TRUE(LoadFrameNoRepeat(&target2));
     source.StretchToFrame(&target2, true, true);
     EXPECT_TRUE(IsBlack(target2));
     EXPECT_EQ(source.GetTimeStamp(), target2.GetTimeStamp());
   }
 
   int repeat_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_