[WebRTC] A real ScreenCapturer test

webrtc/modules/desktop_capture/color.cc

Index: webrtc/modules/desktop_capture/color.cc
diff --git a/webrtc/modules/desktop_capture/color.cc b/webrtc/modules/desktop_capture/color.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7cd5383fc43b3c6569902f80d6b86435c4c33505
--- /dev/null
+++ b/webrtc/modules/desktop_capture/color.cc
@@ -0,0 +1,99 @@
+/*
+ *  Copyright (c) 2016 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 "webrtc/modules/desktop_capture/color.h"
+
+namespace webrtc {
+
+namespace {
+
+bool AlphaEquals(uint8_t i, uint8_t j) {
+  // On Linux and Windows 8 or early version, '0' was returned for alpha channel
+  // from capturer APIs, on Windows 10, '255' was returned. So a workaround is
+  // to treat 0 as 255.
+  return i == j || ((i == 0 || i == 255) && (j == 0 || j == 255));
+}

[Jamie, 2016/08/26 22:29:09]

Do we have any capturers that return a meaningful alpha? I think they all return
a post-compositing pixel value, in which case alpha is meaningless. If so, then
it's better simply to ignore it when comparing (in principle, it still makes
sense when rendering, but I can't think of a useful test that would require it).

[Hzj_jie, 2016/08/29 21:57:27]

This class will also be used by FrameGenerator (in change 2202443002). The alpha
is useful in its scenario. (Though I do not think we can capture an alpha
channel for a screen, but a window may be partially transparent.)

[Jamie, 2016/08/31 17:39:39]

Assuming that this class will only be used by tests, that's my point; if the
capturer cannot capture alpha values, then what are we testing by specifying an
alpha != 255 when painting? Either we know what colour we're blending with (in
which case why not just render the resultant colour fully-opaque?) or we don't
(in which case the test will be flaky).

[Hzj_jie, 2016/08/31 21:22:39]

Oh, I should explain more about the scenario in change 2202443002. That change
uses a FrameGenerator and a FakeScreenCapturer / FakeDesktopCapturer, i.e. they
can generate frames with meaningful alpha channel. And we use the
FakeScreenCapturer / FakeDesktopCapturer to test wrapper layers, ex.
ScreenCapturerDifferWrapper. Though it's not likely to happen, we do not expect
the wrapper layers to change the alpha channel. In that case, the alpha channel
is useful.

I used to add a parameter for Color constructor, but it looks over-engineering.
We do not have to use 0 or 255 in FrameGenerator for alpha channel.

+
+}  // namespace
+
+// static
+Color Color::FromBGRA(uint32_t bgra) {
+  return FromBGRA((bgra & 0xff000000) >> 24, (bgra & 0xff0000) >> 16,
+                  (bgra & 0xff00) >> 8, (bgra & 0xff));
+}
+
+// static
+Color Color::FromBGR(uint32_t bgr) {
+  return FromBGRA((bgr << 8) + 0xff);
+}
+
+// static
+Color Color::FromBGRA(uint8_t blue, uint8_t green, uint8_t red, uint8_t alpha) {
+  Color c;
+  c.bgra[0] = blue;
+  c.bgra[1] = green;
+  c.bgra[2] = red;
+  c.bgra[3] = alpha;
+  return c;
+}
+
+// static
+Color Color::FromBGR(uint8_t blue, uint8_t green, uint8_t red) {
+  return FromBGRA(blue, green, red, 0xff);
+}
+
+bool Color::operator==(const uint8_t* const bgra) const {
+  for (int i = 0; i < DesktopFrame::kBytesPerPixel - 1; i++) {
+    if (this->bgra[i] != bgra[i]) {
+      return false;
+    }
+  }
+  return AlphaEquals(this->bgra[DesktopFrame::kBytesPerPixel - 1],
+                     bgra[DesktopFrame::kBytesPerPixel - 1]);
+}
+
+bool Color::operator!=(const uint8_t* const bgra) const {
+  return !(*this == bgra);
+}
+
+bool Color::operator==(const Color& right) const {
+  return *this == right.bgra;
+}
+
+bool Color::operator!=(const Color& right) const {
+  return !(*this == right);
+}
+
+uint32_t Color::ToUInt32() const {
+  uint32_t result = 0;
+  for (int i = 0; i < DesktopFrame::kBytesPerPixel; i++) {
+    result <<= 8;
+    result += bgra[i];
+  }
+  return result;
+}
+
+uint8_t Color::blue() const {
+  return bgra[0];
+}
+
+uint8_t Color::green() const {
+  return bgra[1];
+}
+
+uint8_t Color::red() const {
+  return bgra[2];
+}
+
+uint8_t Color::alpha() const {
+  return bgra[3];
+}
+
+}  // namespace webrtc