[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) {
+    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) {
+          for (int i = 0; i < 3; i++) {
+            UpdateErrorMetrics(original, decoded, max_error, sum_error,

[Sergey Ulanov, 2012/07/26 04:00:17]

PSNR is a standard metric that is used to measure image quality. Would it be
better to reuse it here?
One problem with the current approach is that it doesn't account for how visible
the errors to the human eye. E.g. eye is more sensitive to green than blue, but
here you use the same math for all three channels. PSNR is not perfect in that
respect, but it's much better.
There are already several implementations of PSNR calculation in our codebase,
e.g. here is one in libyuv:
http://code.google.com/searchframe#OAMlx_jo-ck/src/third_party/libyuv/include...

One problem with reusing that code here is that you would have to convert the
image to YUV, but it should be easy as we already have libraries for that.

+                               error_num);
+            original++;
+            decoded++;
+          }
+          original++;
+          decoded++;
+        }
+      }
+    }
+    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_;
 
+  void UpdateErrorMetrics(const uint8* p1, const uint8* p2,
+                          double& max_error, double& sum_error,
+                          int& error_num) {
+    double error =
+        std::abs(static_cast<int>(*p1) - static_cast<int>(*p2)) / 255.0;
+    max_error = std::max(max_error, error);
+    sum_error += error;
+    error_num++;
+  }
+
   DISALLOW_COPY_AND_ASSIGN(DecoderTester);
 };
 
 // The EncoderTester provides a hook for retrieving the data, and passing the
 // message to other subprograms for validaton.
 class EncoderTester {
  public:
   EncoderTester(EncoderMessageTester* message_tester)
       : message_tester_(message_tester),
         decoder_tester_(NULL),
@@ skipping 134 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;
+      *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,
+                                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