Switch over to using SkRegions to calculate dirty areas.

remoting/host/capturer_mac.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 <ApplicationServices/ApplicationServices.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "remoting/base/util.h"
 #include "remoting/host/capturer_helper.h"
+#include "skia/ext/skia_utils_mac.h"
 
 namespace remoting {
 
 namespace {
 
 class scoped_pixel_buffer_object {
  public:
   scoped_pixel_buffer_object();
   ~scoped_pixel_buffer_object();
 
@@ skipping 99 matching lines @@
   virtual ~CapturerMac();
 
   // Enable or disable capturing. Capturing should be disabled while a screen
   // reconfiguration is in progress, otherwise reading from the screen base
   // address is likely to segfault.
   void EnableCapture(bool enable);
 
   // 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:
-  void GlBlitFast(const VideoFrameBuffer& buffer, const InvalidRects& rects);
+  void GlBlitFast(const VideoFrameBuffer& buffer, const SkRegion& region);
   void GlBlitSlow(const VideoFrameBuffer& buffer);
-  void CgBlit(const VideoFrameBuffer& buffer, const InvalidRects& rects);
-  void CaptureRects(const InvalidRects& rects,
-                    CaptureCompletedCallback* callback);
+  void CgBlit(const VideoFrameBuffer& buffer, const SkRegion& region);
+  void CaptureRegion(const SkRegion& region,
+                     CaptureCompletedCallback* callback);
 
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
   void ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                                 size_t count,
                                 const CGRect *rect_array);
   static void ScreenRefreshCallback(CGRectCount count,
                                     const CGRect *rect_array,
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
                                        size_t count,
@@ skipping 13 matching lines @@
   // recently captured screen.
   CapturerHelper helper_;
 
   // The current buffer with valid data for reading.
   int current_buffer_;
 
   // The last buffer into which we captured, or NULL for the first capture for
   // a particular screen resolution.
   uint8* last_buffer_;
 
-  // Contains a list of invalid rectangles in the last capture.
-  InvalidRects last_invalid_rects_;
+  // Contains an invalid region from the last capture.
+  SkRegion last_invalid_region_;
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
   bool capturing_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturerMac);
 };
 
 CapturerMac::CapturerMac()
@@ skipping 38 matching lines @@
   // The buffers might be in use by the encoder, so don't delete them here.
   // Instead, mark them as "needs update"; next time the buffers are used by
   // the capturer, they will be recreated if necessary.
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
 }
 
 void CapturerMac::ScreenConfigurationChanged() {
   ReleaseBuffers();
-  InvalidRects rects;
-  helper_.SwapInvalidRects(rects);
+  SkRegion region;
+  helper_.SwapInvalidRegion(region);

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

Should be clear, not swap?

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

Done.

   last_buffer_ = NULL;
 
   CGDirectDisplayID mainDevice = CGMainDisplayID();
   int width = CGDisplayPixelsWide(mainDevice);
   int height = CGDisplayPixelsHigh(mainDevice);
   InvalidateScreen(gfx::Size(width, height));
 
   if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
     VLOG(3) << "OpenGL support not available.";
     return;
@@ skipping 18 matching lines @@
   CGLSetCurrentContext(cgl_context_);
 
   size_t buffer_size = width * height * sizeof(uint32_t);
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
 
 media::VideoFrame::Format CapturerMac::pixel_format() const {
   return pixel_format_;
 }
 
-void CapturerMac::ClearInvalidRects() {
-  helper_.ClearInvalidRects();
+void CapturerMac::ClearInvalidRegion() {
+  helper_.ClearInvalidRegion();
 }
 
-void CapturerMac::InvalidateRects(const InvalidRects& inval_rects) {
-  helper_.InvalidateRects(inval_rects);
+void CapturerMac::InvalidateRegion(const SkRegion& inval_region) {
+  helper_.InvalidateRegion(inval_region);
 }
 
 void CapturerMac::InvalidateScreen(const gfx::Size& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerMac::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
 }
 
-void CapturerMac::CaptureInvalidRects(CaptureCompletedCallback* callback) {
+void CapturerMac::CaptureInvalidRegion(CaptureCompletedCallback* callback) {
   scoped_refptr<CaptureData> data;
   if (capturing_) {
-    InvalidRects rects;
-    helper_.SwapInvalidRects(rects);
+    SkRegion region;
+    helper_.SwapInvalidRegion(region);
     VideoFrameBuffer& current_buffer = buffers_[current_buffer_];
     current_buffer.Update();
 
     bool flip = true;  // GL capturers need flipping.
     if (cgl_context_) {
       if (pixel_buffer_object_.get() != 0) {
-        GlBlitFast(current_buffer, rects);
+        GlBlitFast(current_buffer, region);
       } else {
         // See comment in scoped_pixel_buffer_object::Init about why the slow
         // path is always used on 10.5.
         GlBlitSlow(current_buffer);
       }
     } else {
-      CgBlit(current_buffer, rects);
+      CgBlit(current_buffer, region);
       flip = false;
     }
 
     DataPlanes planes;
     planes.data[0] = current_buffer.ptr();
     planes.strides[0] = current_buffer.bytes_per_row();
     if (flip) {
       planes.strides[0] = -planes.strides[0];
       planes.data[0] +=
           (current_buffer.size().height() - 1) * current_buffer.bytes_per_row();
     }
 
     data = new CaptureData(planes, gfx::Size(current_buffer.size()),
                            pixel_format());
-    data->mutable_dirty_rects() = rects;
+    data->mutable_dirty_region() = region;
 
     current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
     helper_.set_size_most_recent(data->size());
   }
 
   callback->Run(data);
   delete callback;
 }
 
 void CapturerMac::GlBlitFast(const VideoFrameBuffer& buffer,
-           const InvalidRects& rects) {
+           const SkRegion& region) {
   if (last_buffer_) {
     // We are doing double buffer for the capture data so we just need to copy
-    // invalid rects in the last capture in the current buffer.
-    // TODO(hclam): |last_invalid_rects_| and |rects| can overlap and this
-    // causes extra copies on the overlapped region. Subtract |rects| from
-    // |last_invalid_rects_| to do a minimal amount of copy when we have proper
-    // region algorithms implemented.
+    // the invalid region from the last capture in the current buffer.

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

Same optimization Alpha suggests for the Linux code applies here.

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

Added comment

 
     // Since the image obtained from OpenGL is upside-down, need to do some
     // magic here to copy the correct rectangle.
     const int y_offset = (buffer.size().height() - 1) * buffer.bytes_per_row();
-    for (InvalidRects::iterator i = last_invalid_rects_.begin();
-         i != last_invalid_rects_.end();
-         ++i) {
+    for(SkRegion::Iterator i(last_invalid_region_); !i.done(); i.next()) {
       CopyRect(last_buffer_ + y_offset,
                -buffer.bytes_per_row(),
                buffer.ptr() + y_offset,
                -buffer.bytes_per_row(),
                4,  // Bytes for pixel for RGBA.
-               *i);
+               i.rect());
     }
   }
   last_buffer_ = buffer.ptr();
-  last_invalid_rects_ = rects;
+  last_invalid_region_ = region;
 
   CGLContextObj CGL_MACRO_CONTEXT = cgl_context_;
   glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pixel_buffer_object_.get());
   glReadPixels(0, 0, buffer.size().width(), buffer.size().height(),
                GL_BGRA, GL_UNSIGNED_BYTE, 0);
   GLubyte* ptr = static_cast<GLubyte*>(
       glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB));
   if (ptr == NULL) {
     // If the buffer can't be mapped, assume that it's no longer valid and
     // release it.
     pixel_buffer_object_.Release();
   } else {
     // Copy only from the dirty rects. Since the image obtained from OpenGL is
     // upside-down we need to do some magic here to copy the correct rectangle.
     const int y_offset = (buffer.size().height() - 1) * buffer.bytes_per_row();
-    for (InvalidRects::iterator i = rects.begin(); i != rects.end(); ++i) {
+    for(SkRegion::Iterator i(region); !i.done(); i.next()) {
       CopyRect(ptr + y_offset,
          -buffer.bytes_per_row(),
          buffer.ptr() + y_offset,
          -buffer.bytes_per_row(),
          4,  // Bytes for pixel for RGBA.
-         *i);
+         i.rect());
     }
   }
   if (!glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB)) {
     // If glUnmapBuffer returns false, then the contents of the data store are
     // undefined. This might be because the screen mode has changed, in which
     // case it will be recreated in ScreenConfigurationChanged, but releasing
     // the object here is the best option. Capturing will fall back on
     // GlBlitSlow until such time as the pixel buffer object is recreated.
     pixel_buffer_object_.Release();
   }
   glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
 }
 
 void CapturerMac::GlBlitSlow(const VideoFrameBuffer& buffer) {
   CGLContextObj CGL_MACRO_CONTEXT = cgl_context_;
   glReadBuffer(GL_FRONT);
   glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
   glPixelStorei(GL_PACK_ALIGNMENT, 4);  // Force 4-byte alignment.
   glPixelStorei(GL_PACK_ROW_LENGTH, 0);
   glPixelStorei(GL_PACK_SKIP_ROWS, 0);
   glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
   // Read a block of pixels from the frame buffer.
   glReadPixels(0, 0, buffer.size().width(), buffer.size().height(),
                GL_BGRA, GL_UNSIGNED_BYTE, buffer.ptr());
   glPopClientAttrib();
 }
 
 void CapturerMac::CgBlit(const VideoFrameBuffer& buffer,
-                         const InvalidRects& rects) {
+                         const SkRegion& region) {
   if (last_buffer_)
     memcpy(buffer.ptr(), last_buffer_,
            buffer.bytes_per_row() * buffer.size().height());
   last_buffer_ = buffer.ptr();
   CGDirectDisplayID main_display = CGMainDisplayID();
   uint8* display_base_address =
       reinterpret_cast<uint8*>(CGDisplayBaseAddress(main_display));
   int src_bytes_per_row = CGDisplayBytesPerRow(main_display);
   int src_bytes_per_pixel = CGDisplayBitsPerPixel(main_display) / 8;
-  for (InvalidRects::iterator i = rects.begin(); i != rects.end(); ++i) {
+  for(SkRegion::Iterator i(region); !i.done(); i.next()) {
     CopyRect(display_base_address,
              src_bytes_per_row,
              buffer.ptr(),
              buffer.bytes_per_row(),
              src_bytes_per_pixel,
-             *i);
+             i.rect());
   }
 }
 
 const gfx::Size& CapturerMac::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
 void CapturerMac::ScreenRefresh(CGRectCount count, const CGRect *rect_array) {
-  InvalidRects rects;
+  SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
-    rects.insert(gfx::Rect(rect_array[i]));
+    skirect_array[i] = gfx::CGRectToSkIRect(rect_array[i]);
   }
-  InvalidateRects(rects);
+  SkRegion region;
+  region.setRects(skirect_array, count);
+  InvalidateRegion(region);
 }
 
 void CapturerMac::ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                                    size_t count,
                                    const CGRect *rect_array) {
-  InvalidRects rects;
+  SkIRect skirect_old_array[count];
+  SkIRect skirect_new_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
     CGRect rect = rect_array[i];
-    rects.insert(gfx::Rect(rect));
+    skirect_old_array[i] = gfx::CGRectToSkIRect(rect);
     rect = CGRectOffset(rect, delta.dX, delta.dY);
-    rects.insert(gfx::Rect(rect));
+    skirect_new_array[i] = gfx::CGRectToSkIRect(rect);
   }
-  InvalidateRects(rects);
+  SkRegion region;
+  region.setRects(skirect_old_array, count);
+  InvalidateRegion(region);
+  region.setRects(skirect_new_array, count);
+  InvalidateRegion(region);

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

Do we need to invalidate the source region for the copy here?  Surely only the
destination changes, and the source will be notified via a separate refresh
operation?

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

Good point. Done.

 }
 
 void CapturerMac::ScreenRefreshCallback(CGRectCount count,
                                         const CGRect *rect_array,
                                         void *user_parameter) {
   CapturerMac *capturer = reinterpret_cast<CapturerMac *>(user_parameter);
   capturer->ScreenRefresh(count, rect_array);
 }
 
 void CapturerMac::ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
@@ skipping 20 matching lines @@
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerMac();
 }
 
 }  // namespace remoting