cricket::VideoFrame cleanup. New width() and height(). Deleted GetChroma* methods.

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 381 matching lines @@
     }
     return true;
   }
 
   // Comparison functions for testing.
   static bool IsNull(const cricket::VideoFrame& frame) {
     return !frame.GetYPlane();
   }
 
   static bool IsSize(const cricket::VideoFrame& frame,
-                     uint32_t width,
-                     uint32_t height) {
-    return !IsNull(frame) && frame.GetYPitch() >= static_cast<int32_t>(width) &&
-           frame.GetUPitch() >= static_cast<int32_t>(width) / 2 &&
-           frame.GetVPitch() >= static_cast<int32_t>(width) / 2 &&
-           frame.GetWidth() == width && frame.GetHeight() == height;
+                     int width,
+                     int height) {
+    return !IsNull(frame) && frame.GetYPitch() >= width &&
+           frame.GetUPitch() >= width / 2 &&
+           frame.GetVPitch() >= 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,
                            int max_error) {
     const uint8_t* r1 = plane1;
     const uint8_t* r2 = plane2;
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; ++x) {
         if (abs(static_cast<int>(r1[x] - r2[x])) > max_error) {
           LOG(LS_INFO) << "IsPlaneEqual(" << name << "): pixel["
                        << x << "," << y << "] differs: "
                        << static_cast<int>(r1[x]) << " vs "
                        << static_cast<int>(r2[x]);
           return false;
         }
       }
       r1 += pitch1;
       r2 += pitch2;
     }
     return true;
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame,
-                      size_t width,
-                      size_t height,
+                      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, static_cast<uint32_t>(width),
-                  static_cast<uint32_t>(height)) &&
+    return IsSize(frame, width, height) &&
            frame.GetTimeStamp() == time_stamp &&
            IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
                         static_cast<uint32_t>(width),
                         static_cast<uint32_t>(height), max_error) &&
            IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), 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,
                         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.GetWidth(), frame2.GetHeight(),
+                   frame2.width(), frame2.height(),
                    frame2.GetTimeStamp(),
                    frame2.GetYPlane(), frame2.GetYPitch(),
                    frame2.GetUPlane(), frame2.GetUPitch(),
                    frame2.GetVPlane(), frame2.GetVPitch(),
                    max_error);
   }
 
   static bool IsEqualWithCrop(const cricket::VideoFrame& frame1,
                               const cricket::VideoFrame& frame2,
                               int hcrop, int vcrop, int max_error) {
-    return frame1.GetWidth() <= frame2.GetWidth() &&
-           frame1.GetHeight() <= frame2.GetHeight() &&
+    return frame1.width() <= frame2.width() &&
+           frame1.height() <= frame2.height() &&
            IsEqual(frame1,
-                   frame2.GetWidth() - hcrop * 2,
-                   frame2.GetHeight() - vcrop * 2,
+                   frame2.width() - hcrop * 2,
+                   frame2.height() - vcrop * 2,
                    frame2.GetTimeStamp(),
                    frame2.GetYPlane() + vcrop * frame2.GetYPitch()
                        + hcrop,
                    frame2.GetYPitch(),
                    frame2.GetUPlane() + vcrop * frame2.GetUPitch() / 2
                        + hcrop / 2,
                    frame2.GetUPitch(),
                    frame2.GetVPlane() + vcrop * frame2.GetVPitch() / 2
                        + hcrop / 2,
                    frame2.GetVPitch(),
@@ skipping 296 matching lines @@
     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 = static_cast<int>(frame1.GetWidth());                    \
-    int height_rotate = static_cast<int>(frame1.GetHeight());                  \
+    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);                                                              \
     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 = static_cast<int>(frame1.GetWidth());                    \
-    int height_rotate = static_cast<int>(frame1.GetHeight());                  \
+    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);                                     \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
@@ skipping 104 matching lines @@
   // 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,
                              webrtc::kVideoRotation_0));
     }
-    EXPECT_EQ(5u, frame.GetWidth());
-    EXPECT_EQ(5u, frame.GetHeight());
+    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());
   }
 
   // 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) {
@@ skipping 423 matching lines @@
                              reinterpret_cast<uint8_t*>(ms->GetBuffer()),
                              data_size, 0, rotation, apply_rotation));
     if (apply_rotation)
       EXPECT_EQ(webrtc::kVideoRotation_0, frame1.GetVideoRotation());
     else
       EXPECT_EQ(rotation, frame1.GetVideoRotation());
 
     // Swapp width and height if the frame is rotated 90 or 270 degrees.
     if (apply_rotation && (rotation == webrtc::kVideoRotation_90
         || rotation == webrtc::kVideoRotation_270)) {
-      EXPECT_TRUE(kHeight == frame1.GetWidth());
-      EXPECT_TRUE(kWidth == frame1.GetHeight());
+      EXPECT_TRUE(kHeight == frame1.width());
+      EXPECT_TRUE(kWidth == frame1.height());
     } else {
-      EXPECT_TRUE(kWidth == frame1.GetWidth());
-      EXPECT_TRUE(kHeight == frame1.GetHeight());
+      EXPECT_TRUE(kWidth == frame1.width());
+      EXPECT_TRUE(kHeight == frame1.height());
     }
     EXPECT_FALSE(IsBlack(frame1));
     EXPECT_FALSE(IsEqual(frame1, frame2, 0));
   }
 
   void ResetAndApplyRotation() {
     Reset(webrtc::kVideoRotation_90, true);
   }
 
   void ResetAndDontApplyRotation() {
@@ skipping 444 matching lines @@
     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_