Move MutableDataY{,U,V} methods to I420Buffer only.

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 435 matching lines @@
       }
       r1 += pitch1;
       r2 += pitch2;
     }
     return true;
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame,
                       int width,
                       int height,
-                      int64_t timestamp_us,
                       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.timestamp_us() == timestamp_us &&
            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.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.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,
+    return frame1.timestamp_us() == frame2.timestamp_us() &&
+           IsEqual(frame1,
                    frame2.width(), frame2.height(),
-                   frame2.timestamp_us(),
                    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(),
+                   frame2.video_frame_buffer()->StrideV(), max_error);
+  }
+
+  static bool IsEqual(
+      const cricket::VideoFrame& frame1,
+      const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer,
+      int max_error) {
+    return IsEqual(frame1, buffer->width(), buffer->height(),
+                   buffer->DataY(), buffer->StrideY(),
+                   buffer->DataU(), buffer->StrideU(),
+                   buffer->DataV(), 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() &&
+           frame1.timestamp_us() == frame2.timestamp_us() &&
            IsEqual(frame1,
                    frame2.width() - hcrop * 2,
                    frame2.height() - vcrop * 2,
-                   frame2.timestamp_us(),
                    frame2.video_frame_buffer()->DataY()
                        + vcrop * frame2.video_frame_buffer()->StrideY()
                        + hcrop,
                    frame2.video_frame_buffer()->StrideY(),
                    frame2.video_frame_buffer()->DataU()
                        + vcrop * frame2.video_frame_buffer()->StrideU() / 2
                        + hcrop / 2,
                    frame2.video_frame_buffer()->StrideU(),
                    frame2.video_frame_buffer()->DataV()
                        + vcrop * frame2.video_frame_buffer()->StrideV() / 2
@@ skipping 18 matching lines @@
     T frame;
     EXPECT_TRUE(IsNull(frame));
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* u = y + kWidth * kHeight;
     const uint8_t* v = u + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
-                        kWidth / 2, v, kWidth / 2, 0));
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, y, kWidth, u, kWidth / 2, v,
+                        kWidth / 2, 0));
   }
 
   // Test constructing an image from a YV12 buffer.
   void ConstructYV12() {
     T frame;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* v = y + kWidth * kHeight;
     const uint8_t* u = v + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
-                        kWidth / 2, v, kWidth / 2, 0));
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, y, kWidth, u, kWidth / 2, v,
+                        kWidth / 2, 0));
   }
 
   // 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;
@@ skipping 196 matching lines @@
     ASSERT_TRUE(frame1);
     T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_RAW,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
 // Macro to help test different rotations
 #define TEST_MIRROR(FOURCC, BPP)                                               \
   void Construct##FOURCC##Mirror() {                                           \
-    T frame1, frame2, frame3;                                                  \
+    T frame1, frame2;                                                          \
+    rtc::scoped_refptr<webrtc::I420Buffer> res_buffer;                         \
     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_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();                                       \
-    frame3.InitToEmptyBuffer(width_rotate, height_rotate);                     \
+    res_buffer = webrtc::I420Buffer::Create(width_rotate, height_rotate);      \
     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));                                   \
+                       res_buffer->MutableDataY(), res_buffer->StrideY(),      \
+                       res_buffer->MutableDataU(), res_buffer->StrideU(),      \
+                       res_buffer->MutableDataV(), res_buffer->StrideV(),      \
+                       kWidth, kHeight);                                       \
+    EXPECT_TRUE(IsEqual(frame1, res_buffer, 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;                                                  \
+    T frame1, frame2;                                                          \
+    rtc::scoped_refptr<webrtc::I420Buffer> res_buffer;                         \
     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();                                       \
-    frame3.InitToEmptyBuffer(width_rotate, height_rotate);                     \
+    res_buffer = webrtc::I420Buffer::Create(width_rotate, height_rotate);      \
     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));                                   \
+                       res_buffer->MutableDataY(), res_buffer->StrideY(),      \
+                       res_buffer->MutableDataU(), res_buffer->StrideU(),      \
+                       res_buffer->MutableDataV(), res_buffer->StrideV(),      \
+                       kWidth, kHeight, libyuv::kRotate##ROTATE);              \
+    EXPECT_TRUE(IsEqual(frame1, res_buffer, 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)
   TEST_ROTATE(YV12, 12, 180)
@@ skipping 83 matching lines @@
   void ConstructI4201Pixel() {
     T frame;
     uint8_t pixel[3] = {1, 2, 3};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, pixel,
                              sizeof(pixel), 0, webrtc::kVideoRotation_0));
     }
     const uint8_t* y = pixel;
     const uint8_t* u = y + 1;
     const uint8_t* v = u + 1;
-    EXPECT_TRUE(IsEqual(frame, 1, 1, 0, y, 1, u, 1, v, 1, 0));
+    EXPECT_TRUE(IsEqual(frame, 1, 1, y, 1, u, 1, v, 1, 0));
   }
 
   // Test 5 pixel edge case image.
   void ConstructI4205Pixel() {
     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,
@@ skipping 398 matching lines @@
     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));
   }
 
   int repeat_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_