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 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 &&
+    return IsSize(frame, width, height) &&
            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.GetTimeStamp() == frame2.GetTimeStamp() &&
+           IsEqual(frame1,
                    frame2.width(), frame2.height(),
-                   frame2.GetTimeStamp(),
                    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 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.GetTimeStamp() == frame2.GetTimeStamp() &&
            IsEqual(frame1,
                    frame2.width() - hcrop * 2,
                    frame2.height() - vcrop * 2,
-                   frame2.GetTimeStamp(),
                    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 244 matching lines @@
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_R444,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
 // 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 446 matching lines @@
                               int (*RGBToI420)(const uint8_t* src_frame,
                                                int src_stride_frame,
                                                uint8_t* dst_y,
                                                int dst_stride_y,
                                                uint8_t* dst_u,
                                                int dst_stride_u,
                                                uint8_t* dst_v,
                                                int dst_stride_v,
                                                int width,
                                                int height)) {
-    T frame1, frame2;
+    T frame1;
+    rtc::scoped_refptr<webrtc::I420Buffer> res_buffer;
     int repeat_to = (to_from == TO) ? repeat_ : 1;
     int repeat_from  = (to_from == FROM) ? repeat_ : 1;
 
     int astride = kWidth * bpp + rowpad;
     size_t out_size = astride * kHeight;
     std::unique_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment + 1]);
     memset(outbuf.get(), 0, out_size + kAlignment + 1);
     uint8_t* outtop = ALIGNP(outbuf.get(), kAlignment);
     uint8_t* out = outtop;
     int stride = astride;
     if (invert) {
       out += (kHeight - 1) * stride;  // Point to last row.
       stride = -stride;
     }
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
     for (int i = 0; i < repeat_to; ++i) {
       EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc,
                                                     out,
                                                     out_size, stride));
     }
-    frame2.InitToEmptyBuffer(kWidth, kHeight);
+    res_buffer = webrtc::I420Buffer::Create(kWidth, kHeight);
     for (int i = 0; i < repeat_from; ++i) {
       EXPECT_EQ(0, RGBToI420(out, stride,
-                             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(),
+                             res_buffer->MutableDataY(), res_buffer->StrideY(),
+                             res_buffer->MutableDataU(), res_buffer->StrideU(),
+                             res_buffer->MutableDataV(), res_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));
+    EXPECT_TRUE(IsEqual(frame1, res_buffer, error));
   }
 
   static const int kError = 20;
   static const int kErrorHigh = 40;
   static const int kOddStride = 23;
 
   // Tests ConvertToRGBBuffer formats.
   void ConvertToARGBBuffer() {
     ConvertToBuffer(4, 0, false, TO, kError,
                     cricket::FOURCC_ARGB, libyuv::ARGBToI420);
@@ skipping 318 matching lines @@
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     const T* const_source = source.get();
     EXPECT_EQ(const_source->video_frame_buffer(), target->video_frame_buffer());
   }
 
   int repeat_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_