[Chromoting] Add a unit test to verify that the VP8 codec doesn't change color values too much.

remoting/base/codec_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <deque>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 129 matching lines @@
 
     if (result == Decoder::DECODE_DONE) {
       decoder_->RenderFrame(SkISize::Make(kWidth, kHeight),
                             SkIRect::MakeXYWH(0, 0, kWidth, kHeight),
                             image_data_.get(),
                             kWidth * kBytesPerPixel,
                             &update_region_);
     }
   }
 
+  void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) {
+    ReceivedPacket(packet.get());
+  }
+
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void set_capture_data(scoped_refptr<CaptureData> data) {
     capture_data_ = data;
   }
 
   void AddRects(const SkIRect* rects, int count) {
     SkRegion new_rects;
     new_rects.setRects(rects, count);
-    expected_region_.op(new_rects, SkRegion::kUnion_Op);
+    AddRegion(new_rects);
+  }
+
+  void AddRegion(const SkRegion& region) {
+    expected_region_.op(region, SkRegion::kUnion_Op);
   }
 
   void VerifyResults() {
     if (!strict_)
       return;
 
     ASSERT_TRUE(capture_data_.get());
 
     // Test the content of the update region.
     EXPECT_EQ(expected_region_, update_region_);
     for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
       const int stride = kWidth * kBytesPerPixel;
       EXPECT_EQ(stride, capture_data_->data_planes().strides[0]);
       const int offset =  stride * i.rect().top() +
           kBytesPerPixel * i.rect().left();
       const uint8* original = capture_data_->data_planes().data[0] + offset;
       const uint8* decoded = image_data_.get() + offset;
       const int row_size = kBytesPerPixel * i.rect().width();
       for (int y = 0; y < i.rect().height(); ++y) {
         EXPECT_EQ(0, memcmp(original, decoded, row_size))
             << "Row " << y << " is different";
         original += stride;
         decoded += stride;
       }
     }
   }
 
+  void VerifyResultsApprox(double max_error_limit, double mean_error_limit) {

[Sergey Ulanov, 2012/07/27 02:55:01]

add short description of how the error is calculated (i.e. that it's average of
root mean square of 3 colors over all pixels in the image).

Also it might be worth separating error calculation from the tests - i.e. add
CalculateError() methods that would do all math separately from verification.

[simonmorris, 2012/07/27 16:42:24]

Done.

+    ASSERT_TRUE(capture_data_.get());
+
+    // Test the content of the update region.
+    EXPECT_EQ(expected_region_, update_region_);
+    double max_error = 0.0;
+    double sum_error = 0.0;
+    int error_num = 0;
+    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
+      const int stride = kWidth * kBytesPerPixel;
+      EXPECT_EQ(stride, capture_data_->data_planes().strides[0]);
+      const int offset =  stride * i.rect().top() +
+          kBytesPerPixel * i.rect().left();
+      const uint8* original = capture_data_->data_planes().data[0] + offset;
+      const uint8* decoded = image_data_.get() + offset;
+      for (int y = 0; y < i.rect().height(); ++y) {
+        for (int x = 0; x < i.rect().width(); ++x) {
+          double error_sum_squares = 0.0;
+          for (int i = 0; i < 3; i++) {
+            double error = static_cast<double>(*original++) -
+                           static_cast<double>(*decoded++);
+            error /= 255.0;
+            error_sum_squares += error * error;
+          }
+          original++;
+          decoded++;
+          double error = sqrt(error_sum_squares / 3.0);
+          max_error = std::max(max_error, error);
+          sum_error += error;
+          ++error_num;
+        }
+      }
+    }
+    EXPECT_LE(max_error, max_error_limit);
+    double mean_error = sum_error / error_num;
+    EXPECT_LE(mean_error, mean_error_limit);
+    LOG(INFO) << "Max error: " << max_error;
+    LOG(INFO) << "Mean error: " << mean_error;
+  }
+
  private:
   bool strict_;
   SkRegion expected_region_;
   SkRegion update_region_;
   Decoder* decoder_;
   scoped_array<uint8> image_data_;
   scoped_refptr<CaptureData> capture_data_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderTester);
 };
@@ skipping 142 matching lines @@
   TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
                         kTestRects, 1);
   TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
                         kTestRects + 1, 1);
   TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
                         kTestRects + 2, 1);
   TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
                         kTestRects + 3, 2);
 }
 
+static void FillWithGradient(uint8* memory, const SkISize& frame_size,
+                             const SkIRect& rect) {
+  for (int j = rect.top(); j < rect.bottom(); ++j) {
+    for (int i = rect.left(); i < rect.right(); ++i) {
+      uint8* p = memory + ((j * frame_size.width()) + i) * 4;

[Sergey Ulanov, 2012/07/27 02:55:01]

nit: move this outside of the inner loop. Or alternatively assign to p[0], p[1],
p[2] and p[3] instead of incrementing p for each channel.

[simonmorris, 2012/07/27 16:42:24]

Done.

+      *p++ = static_cast<uint8>((255.0 * i) / frame_size.width());
+      *p++ = static_cast<uint8>((164.0 * j) / frame_size.height());
+      *p++ = static_cast<uint8>((82.0 * (i + j)) /
+                                   (frame_size.width() + frame_size.height()));
+      *p++ = 0;
+    }
+  }
+}
+
+void TestEncoderDecoderGradient(Encoder* encoder, Decoder* decoder,

[Sergey Ulanov, 2012/07/27 02:55:01]

nit: move second parameter to a separate line

[simonmorris, 2012/07/27 16:42:24]

Done.

+                                double max_error_limit,
+                                double mean_error_limit) {
+  SkIRect full_frame = SkIRect::MakeWH(kWidth, kHeight);
+  scoped_array<uint8> frame_data(new uint8[kWidth * kHeight * kBytesPerPixel]);
+  FillWithGradient(frame_data.get(), SkISize::Make(kWidth, kHeight),
+                   full_frame);
+
+  DataPlanes planes;
+  memset(planes.data, 0, sizeof(planes.data));
+  memset(planes.strides, 0, sizeof(planes.strides));
+  planes.data[0] = frame_data.get();
+  planes.strides[0] = kWidth * kBytesPerPixel;
+
+  scoped_refptr<CaptureData> capture_data =
+      new CaptureData(planes, SkISize::Make(kWidth, kHeight),
+                      media::VideoFrame::RGB32);
+  capture_data->mutable_dirty_region().op(full_frame, SkRegion::kUnion_Op);
+
+  DecoderTester decoder_tester(decoder);
+  decoder_tester.set_capture_data(capture_data);
+  decoder_tester.AddRegion(capture_data->dirty_region());
+
+  encoder->Encode(capture_data, true,
+                  base::Bind(&DecoderTester::ReceivedScopedPacket,
+                             base::Unretained(&decoder_tester)));
+
+  decoder_tester.VerifyResultsApprox(max_error_limit, mean_error_limit);
+}
+
 }  // namespace remoting