Switch over to using SkRegions to calculate dirty areas.

remoting/host/capturer_linux.cc

 // Copyright (c) 2011 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 "remoting/host/capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "remoting/base/types.h"
 #include "remoting/host/capturer_helper.h"
 #include "remoting/host/differ.h"
 #include "remoting/host/x_server_pixel_buffer.h"
 
 namespace remoting {
 
 namespace {
 
 static const int kBytesPerPixel = 4;
 
@@ skipping 41 matching lines @@
 // A class to perform capturing for Linux.
 class CapturerLinux : public Capturer {
  public:
   CapturerLinux();
   virtual ~CapturerLinux();
 
 
   // Capturer interface.
   virtual void ScreenConfigurationChanged() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
-  virtual void ClearInvalidRects() OVERRIDE;
-  virtual void InvalidateRects(const InvalidRects& inval_rects) OVERRIDE;
+  virtual void ClearInvalidRegion() OVERRIDE;
+  virtual void InvalidateRegion(const SkRegion& inval_region) OVERRIDE;
   virtual void InvalidateScreen(const gfx::Size& size) OVERRIDE;
   virtual void InvalidateFullScreen() OVERRIDE;
-  virtual void CaptureInvalidRects(CaptureCompletedCallback* callback) OVERRIDE;
+  virtual void CaptureInvalidRegion(CaptureCompletedCallback* callback)
+      OVERRIDE;
   virtual const gfx::Size& size_most_recent() const OVERRIDE;
 
  private:
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   void InitXDamage();
 
   // Read and handle all currently-pending XEvents.
   // In the DAMAGE case, process the XDamage events and store the resulting
   // damage rectangles in the CapturerHelper.
@@ skipping 14 matching lines @@
   // the area of |last_invalid_rects|.
   // Note this only works on the assumption that kNumBuffers == 2, as
   // |last_invalid_rects| holds the differences from the previous buffer and
   // the one prior to that (which will then be the current buffer).
   void SynchronizeFrame();
 
   void DeinitXlib();
 
   // Capture a rectangle from |x_server_pixel_buffer_|, and copy the data into
   // |capture_data|.
-  void CaptureRect(const gfx::Rect& rect, CaptureData* capture_data);
+  void CaptureRect(const SkIRect& rect, CaptureData* capture_data);
 
   // We expose two forms of blitting to handle variations in the pixel format.
   // In FastBlit, the operation is effectively a memcpy.
-  void FastBlit(uint8* image, const gfx::Rect& rect, CaptureData* capture_data);
-  void SlowBlit(uint8* image, const gfx::Rect& rect, CaptureData* capture_data);
+  void FastBlit(uint8* image, const SkIRect& rect, CaptureData* capture_data);
+  void SlowBlit(uint8* image, const SkIRect& rect, CaptureData* capture_data);
 
   // X11 graphics context.
   Display* display_;
   GC gc_;
   Window root_window_;
 
   // XDamage information.
   bool use_damage_;
   Damage damage_handle_;
   int damage_event_base_;
   int damage_error_base_;
 
   // Access to the X Server's pixel buffer.
   XServerPixelBuffer x_server_pixel_buffer_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   CapturerHelper helper_;
 
   // Capture state.
   static const int kNumBuffers = 2;
   VideoFrameBuffer buffers_[kNumBuffers];
   int current_buffer_;
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
-  // Invalid rects in the last capture. This is used to synchronize current with
-  // the previous buffer used.
-  InvalidRects last_invalid_rects_;
+  // Invalid region from the last capture. This is used to synchronize current
+  // with the previous buffer used.

[Wez, 2011/08/08 20:49:34]

nit: This comment doesn't parse.

[dmac, 2011/08/10 20:30:36]

Done.

+  SkRegion last_invalid_region_;
 
   // Last capture buffer used.
   uint8* last_buffer_;
 
   // |Differ| for use when polling for changes.
   scoped_ptr<Differ> differ_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturerLinux);
 };
 
@@ skipping 70 matching lines @@
   } else {
     LOG(INFO) << "Server does not support XDamage.";
   }
 }
 
 void CapturerLinux::ScreenConfigurationChanged() {
   last_buffer_ = NULL;
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
-  InvalidRects rects;
-  helper_.SwapInvalidRects(rects);
+  SkRegion region;
+  helper_.SwapInvalidRegion(region);

[Wez, 2011/08/08 20:49:34]

Since |region| isn't used after this call, isn't it just a clear operation?

[dmac, 2011/08/10 20:30:36]

Done.

   x_server_pixel_buffer_.Init(display_);
 }
 
 media::VideoFrame::Format CapturerLinux::pixel_format() const {
   return pixel_format_;
 }
 
-void CapturerLinux::ClearInvalidRects() {
-  helper_.ClearInvalidRects();
+void CapturerLinux::ClearInvalidRegion() {
+  helper_.ClearInvalidRegion();
 }
 
-void CapturerLinux::InvalidateRects(const InvalidRects& inval_rects) {
-  helper_.InvalidateRects(inval_rects);
+void CapturerLinux::InvalidateRegion(const SkRegion& inval_region) {
+  helper_.InvalidateRegion(inval_region);
 }
 
 void CapturerLinux::InvalidateScreen(const gfx::Size& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerLinux::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
   last_buffer_ = NULL;
 }
 
-void CapturerLinux::CaptureInvalidRects(
+void CapturerLinux::CaptureInvalidRegion(
     CaptureCompletedCallback* callback) {
   scoped_ptr<CaptureCompletedCallback> callback_deleter(callback);
 
   // TODO(lambroslambrou): In the non-DAMAGE case, there should be no need
   // for any X event processing in this class.
   ProcessPendingXEvents();
 
   // Resize the current buffer if there was a recent change of
   // screen-resolution.
   VideoFrameBuffer &current = buffers_[current_buffer_];
@@ skipping 10 matching lines @@
   helper_.set_size_most_recent(capture_data->size());
 
   callback->Run(capture_data);
 }
 
 void CapturerLinux::ProcessPendingXEvents() {
   // Find the number of events that are outstanding "now."  We don't just loop
   // on XPending because we want to guarantee this terminates.
   int events_to_process = XPending(display_);
   XEvent e;
-  InvalidRects invalid_rects;
+  SkRegion invalid_region;
 
   for (int i = 0; i < events_to_process; i++) {
     XNextEvent(display_, &e);
     if (use_damage_ && (e.type == damage_event_base_ + XDamageNotify)) {
       XDamageNotifyEvent *event = reinterpret_cast<XDamageNotifyEvent*>(&e);
 
       // TODO(hclam): Perform more checks on the rect.
       if (event->area.width <= 0 || event->area.height <= 0)
         continue;
 
-      gfx::Rect damage_rect(event->area.x, event->area.y, event->area.width,
-                            event->area.height);
-      invalid_rects.insert(damage_rect);
-      VLOG(3) << "Damage received for rect at ("
-              << damage_rect.x() << "," << damage_rect.y() << ") size ("
-              << damage_rect.width() << "," << damage_rect.height() << ")";
+      SkIRect damage_rect = SkIRect::MakeXYWH(event->area.x,
+                                              event->area.y,
+                                              event->area.width,
+                                              event->area.height);
+      invalid_region.op(damage_rect, SkRegion::kUnion_Op);
+      DVLOG(3) << "Damage received for rect at ("
+               << damage_rect.fLeft << "," << damage_rect.fTop << ") size ("
+               << damage_rect.width() << "," << damage_rect.height() << ")";
     } else if (e.type == ConfigureNotify) {
       ScreenConfigurationChanged();
-      invalid_rects.clear();
+      invalid_region.setEmpty();
     } else {
       LOG(WARNING) << "Got unknown event type: " << e.type;
     }
   }
 
-  helper_.InvalidateRects(invalid_rects);
+  helper_.InvalidateRegion(invalid_region);
 }
 
 CaptureData* CapturerLinux::CaptureFrame() {
   VideoFrameBuffer& buffer = buffers_[current_buffer_];
   DataPlanes planes;
   planes.data[0] = buffer.ptr();
   planes.strides[0] = buffer.bytes_per_row();
 
   CaptureData* capture_data = new CaptureData(planes, buffer.size(),
                                               media::VideoFrame::RGB32);
 
   // In the DAMAGE case, ensure the frame is up-to-date with the previous frame
   // if any.  If there isn't a previous frame, that means a screen-resolution
   // change occurred, and |invalid_rects| will be updated to include the whole
   // screen.
   if (use_damage_ && last_buffer_)
     SynchronizeFrame();
 
-  InvalidRects invalid_rects;
+  SkRegion invalid_region;
 
   x_server_pixel_buffer_.Synchronize();
   if (use_damage_ && last_buffer_) {
-    helper_.SwapInvalidRects(invalid_rects);
-    for (InvalidRects::const_iterator it = invalid_rects.begin();
-         it != invalid_rects.end();
-         ++it) {
-      CaptureRect(*it, capture_data);
+    helper_.SwapInvalidRegion(invalid_region);
+    for (SkRegion::Iterator it(invalid_region); !it.done(); it.next()) {
+      CaptureRect(it.rect(), capture_data);
     }
     // TODO(ajwong): We should only repair the rects that were copied!
     XDamageSubtract(display_, damage_handle_, None, None);
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
-    gfx::Rect screen_rect(buffer.size());
+    SkIRect screen_rect = SkIRect::MakeWH(buffer.size().width(),
+                                          buffer.size().height());
     CaptureRect(screen_rect, capture_data);
 
     if (last_buffer_) {
       // Full-screen polling, so calculate the invalid rects here, based on the
       // changed pixels between current and previous buffers.
       DCHECK(differ_ != NULL);
-      differ_->CalcDirtyRects(last_buffer_, buffer.ptr(), &invalid_rects);
+      differ_->CalcDirtyRegion(last_buffer_, buffer.ptr(), &invalid_region);
     } else {
       // No previous buffer, so always invalidate the whole screen, whether
       // or not DAMAGE is being used.  DAMAGE doesn't necessarily send a
       // full-screen notification after a screen-resolution change, so
       // this is done here.
-      invalid_rects.insert(screen_rect);
+      invalid_region.op(screen_rect, SkRegion::kUnion_Op);
     }
   }
 
-  capture_data->mutable_dirty_rects() = invalid_rects;
-  last_invalid_rects_ = invalid_rects;
+  capture_data->mutable_dirty_region() = invalid_region;
+  last_invalid_region_ = invalid_region;
   last_buffer_ = buffer.ptr();
   return capture_data;
 }
 
 void CapturerLinux::SynchronizeFrame() {
   // Synchronize the current buffer with the last one since we do not capture
   // the entire desktop. Note that encoder may be reading from the previous
   // buffer at this time so thread access complaints are false positives.
 
   // TODO(hclam): We can reduce the amount of copying here by subtracting
   // |rects| from |last_invalid_rects_|.

[Wez, 2011/08/08 20:49:34]

Now that we're using regions, perhaps implement that suggestion?

[dmac, 2011/08/10 20:30:36]

Added bug

   DCHECK(last_buffer_);
   VideoFrameBuffer& buffer = buffers_[current_buffer_];
-  for (InvalidRects::const_iterator it = last_invalid_rects_.begin();
-       it != last_invalid_rects_.end();
-       ++it) {
-    int offset = it->y() * buffer.bytes_per_row() + it->x() * kBytesPerPixel;
-    for (int i = 0; i < it->height(); ++i) {
+  for (SkRegion::Iterator it(last_invalid_region_); !it.done(); it.next()) {
+    const SkIRect& r = it.rect();
+    int offset = r.fTop * buffer.bytes_per_row() + r.fLeft * kBytesPerPixel;
+    for (int i = 0; i < r.height(); ++i) {
       memcpy(buffer.ptr() + offset, last_buffer_ + offset,
-             it->width() * kBytesPerPixel);
+             r.width() * kBytesPerPixel);
       offset += buffer.size().width() * kBytesPerPixel;
     }
   }
 }
 
 void CapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display_, gc_);
     gc_ = NULL;
   }
 
   if (display_) {
     XCloseDisplay(display_);
     display_ = NULL;
   }
 }
 
-void CapturerLinux::CaptureRect(const gfx::Rect& rect,
+void CapturerLinux::CaptureRect(const SkIRect& rect,
                                 CaptureData* capture_data) {
   uint8* image = x_server_pixel_buffer_.CaptureRect(rect);
   int depth = x_server_pixel_buffer_.GetDepth();
   int bpp = x_server_pixel_buffer_.GetBitsPerPixel();
   bool is_rgb = x_server_pixel_buffer_.IsRgb();
   if ((depth == 24 || depth == 32) && bpp == 32 && is_rgb) {
-    VLOG(3) << "Fast blitting";
+    DVLOG(3) << "Fast blitting";
     FastBlit(image, rect, capture_data);
   } else {
-    VLOG(3) << "Slow blitting";
+    DVLOG(3) << "Slow blitting";
     SlowBlit(image, rect, capture_data);
   }
 }
 
-void CapturerLinux::FastBlit(uint8* image, const gfx::Rect& rect,
+void CapturerLinux::FastBlit(uint8* image, const SkIRect& rect,
                              CaptureData* capture_data) {
   uint8* src_pos = image;
   int src_stride = x_server_pixel_buffer_.GetStride();
-  int dst_x = rect.x(), dst_y = rect.y();
+  int dst_x = rect.fLeft, dst_y = rect.fTop;
 
   DataPlanes planes = capture_data->data_planes();
   uint8* dst_buffer = planes.data[0];
 
   const int dst_stride = planes.strides[0];
 
   uint8* dst_pos = dst_buffer + dst_stride * dst_y;
   dst_pos += dst_x * kBytesPerPixel;
 
   int height = rect.height(), row_bytes = rect.width() * kBytesPerPixel;
   for (int y = 0; y < height; ++y) {
     memcpy(dst_pos, src_pos, row_bytes);
     src_pos += src_stride;
     dst_pos += dst_stride;
   }
 }
 
-void CapturerLinux::SlowBlit(uint8* image, const gfx::Rect& rect,
+void CapturerLinux::SlowBlit(uint8* image, const SkIRect& rect,
                              CaptureData* capture_data) {
   DataPlanes planes = capture_data->data_planes();
   uint8* dst_buffer = planes.data[0];
   const int dst_stride = planes.strides[0];
   int src_stride = x_server_pixel_buffer_.GetStride();
-  int dst_x = rect.x(), dst_y = rect.y();
+  int dst_x = rect.fLeft, dst_y = rect.fTop;
   int width = rect.width(), height = rect.height();
 
   unsigned int red_mask = x_server_pixel_buffer_.GetRedMask();
   unsigned int blue_mask = x_server_pixel_buffer_.GetBlueMask();
   unsigned int green_mask = x_server_pixel_buffer_.GetGreenMask();
   unsigned int red_shift = x_server_pixel_buffer_.GetRedShift();
   unsigned int blue_shift = x_server_pixel_buffer_.GetBlueShift();
   unsigned int green_shift = x_server_pixel_buffer_.GetGreenShift();
 
   unsigned int max_red = red_mask >> red_shift;
@@ skipping 36 matching lines @@
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerLinux();
 }
 
 }  // namespace remoting