Add unit test for stand-alone denoiser and fixed some bugs.

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.
  */
 
 #include <math.h>
 #include <string.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/test/fake_texture_frame.h"
 #include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 bool EqualPlane(const uint8_t* data1,
                 const uint8_t* data2,
                 int stride,
                 int width,
                 int height);
-bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2);
 int ExpectedSize(int plane_stride, int image_height, PlaneType type);
 
 TEST(TestVideoFrame, InitialValues) {
   VideoFrame frame;
   EXPECT_TRUE(frame.IsZeroSize());
   EXPECT_EQ(kVideoRotation_0, frame.rotation());
 }
 
 TEST(TestVideoFrame, CopiesInitialFrameWithoutCrashing) {
   VideoFrame frame;
@@ skipping 57 matching lines @@
   memset(buffer_y, 16, kSizeY);
   memset(buffer_u, 8, kSizeU);
   memset(buffer_v, 4, kSizeV);
   VideoFrame big_frame;
   EXPECT_EQ(0,
             big_frame.CreateFrame(buffer_y, buffer_u, buffer_v,
                                   width + 5, height + 5, stride_y + 5,
                                   stride_u, stride_v, kRotation));
   // Frame of smaller dimensions.
   EXPECT_EQ(0, small_frame.CopyFrame(big_frame));
-  EXPECT_TRUE(EqualFrames(small_frame, big_frame));
+  EXPECT_TRUE(small_frame.EqualsFrame(big_frame));
   EXPECT_EQ(kRotation, small_frame.rotation());
 
   // Frame of larger dimensions.
   EXPECT_EQ(0, small_frame.CreateEmptyFrame(width, height,
                                             stride_y, stride_u, stride_v));
   memset(small_frame.buffer(kYPlane), 1, small_frame.allocated_size(kYPlane));
   memset(small_frame.buffer(kUPlane), 2, small_frame.allocated_size(kUPlane));
   memset(small_frame.buffer(kVPlane), 3, small_frame.allocated_size(kVPlane));
   EXPECT_EQ(0, big_frame.CopyFrame(small_frame));
-  EXPECT_TRUE(EqualFrames(small_frame, big_frame));
+  EXPECT_TRUE(small_frame.EqualsFrame(big_frame));
 }
 
 TEST(TestVideoFrame, ShallowCopy) {
   uint32_t timestamp = 1;
   int64_t ntp_time_ms = 2;
   int64_t render_time_ms = 3;
   int stride_y = 15;
   int stride_u = 10;
   int stride_v = 10;
   int width = 15;
@@ skipping 124 matching lines @@
   EXPECT_EQ(100u, frame.timestamp());
   EXPECT_EQ(10, frame.render_time_ms());
   EXPECT_EQ(handle, frame.native_handle());
 
   frame.set_timestamp(200);
   EXPECT_EQ(200u, frame.timestamp());
   frame.set_render_time_ms(20);
   EXPECT_EQ(20, frame.render_time_ms());
 }
 
-bool EqualPlane(const uint8_t* data1,
-                const uint8_t* data2,
-                int stride,
-                int width,
-                int height) {
-  for (int y = 0; y < height; ++y) {
-    if (memcmp(data1, data2, width) != 0)
-      return false;
-    data1 += stride;
-    data2 += stride;
-  }
-  return true;
-}
-
-bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  if ((frame1.width() != frame2.width()) ||
-      (frame1.height() != frame2.height()) ||
-      (frame1.stride(kYPlane) != frame2.stride(kYPlane)) ||
-      (frame1.stride(kUPlane) != frame2.stride(kUPlane)) ||
-      (frame1.stride(kVPlane) != frame2.stride(kVPlane)) ||
-      (frame1.timestamp() != frame2.timestamp()) ||
-      (frame1.ntp_time_ms() != frame2.ntp_time_ms()) ||
-      (frame1.render_time_ms() != frame2.render_time_ms())) {
-    return false;
-  }
-  const int half_width = (frame1.width() + 1) / 2;
-  const int half_height = (frame1.height() + 1) / 2;
-  return EqualPlane(frame1.buffer(kYPlane), frame2.buffer(kYPlane),
-                    frame1.stride(kYPlane), frame1.width(), frame1.height()) &&
-         EqualPlane(frame1.buffer(kUPlane), frame2.buffer(kUPlane),
-                    frame1.stride(kUPlane), half_width, half_height) &&
-         EqualPlane(frame1.buffer(kVPlane), frame2.buffer(kVPlane),
-                    frame1.stride(kVPlane), half_width, half_height);
-}
-
-int ExpectedSize(int plane_stride, int image_height, PlaneType type) {
-  if (type == kYPlane) {
-    return (plane_stride * image_height);
-  } else {
-    int half_height = (image_height + 1) / 2;
-    return (plane_stride * half_height);
-  }
-}
-
 }  // namespace webrtc