Compare the sizes of current & previous frames before each capture.

remoting/host/video_frame_capturer_linux.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 "remoting/host/video_frame_capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
@@ skipping 45 matching lines @@
         ptr_.reset(new uint8[buffer_size]);
       }
     }
   }
 
   SkISize size() const { return size_; }
   int bytes_per_row() const { return bytes_per_row_; }
   uint8* ptr() const { return ptr_.get(); }
 
   void set_needs_update() { needs_update_ = true; }
+  bool needs_update() const { return needs_update_; }
 
  private:
   SkISize size_;
   int bytes_per_row_;
   scoped_array<uint8> ptr_;
   bool needs_update_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameBuffer);
 };
 
@@ skipping 91 matching lines @@
   int current_buffer_;
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
   // Invalid region from the previous capture. This is used to synchronize the
   // current with the last buffer used.
   SkRegion last_invalid_region_;
 
   // Last capture buffer used.
-  uint8* last_buffer_;
+  int last_buffer_;
 
   // |Differ| for use when polling for changes.
   scoped_ptr<Differ> differ_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerLinux);
 };
 
 VideoFrameCapturerLinux::VideoFrameCapturerLinux()
     : display_(NULL),
       gc_(NULL),
       root_window_(BadValue),
       has_xfixes_(false),
       xfixes_event_base_(-1),
       xfixes_error_base_(-1),
       use_damage_(false),
       damage_handle_(0),
       damage_event_base_(-1),
       damage_error_base_(-1),
       damage_region_(0),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32),
-      last_buffer_(NULL) {
+      last_buffer_(kNumBuffers - 1) {
   helper_.SetLogGridSize(4);
 }
 
 VideoFrameCapturerLinux::~VideoFrameCapturerLinux() {
   DeinitXlib();
 }
 
 bool VideoFrameCapturerLinux::Init() {
   // TODO(ajwong): We should specify the display string we are attaching to
   // in the constructor.
@@ skipping 100 matching lines @@
 
 void VideoFrameCapturerLinux::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
   // Process XEvents for XDamage and cursor shape tracking.
   ProcessPendingXEvents();
 
   // Resize the current buffer if there was a recent change of
   // screen-resolution.
   VideoFrameBuffer &current = buffers_[current_buffer_];
   current.Update(display_, root_window_);
-  // Also refresh the Differ helper used by CaptureFrame(), if needed.
-  if (!use_damage_ && !last_buffer_) {
-    differ_.reset(new Differ(current.size().width(), current.size().height(),
-                             kBytesPerPixel, current.bytes_per_row()));
+
+  // Mark the previous frame for update if its dimensions no longer match.
+  if (buffers_[last_buffer_].size() != current.size()) {
+    buffers_[last_buffer_].set_needs_update();
+
+    // Also refresh the Differ helper used by CaptureFrame(), if needed.
+    if (!use_damage_) {
+      differ_.reset(new Differ(current.size().width(), current.size().height(),
+                               kBytesPerPixel, current.bytes_per_row()));
+    }
   }
 
   scoped_refptr<CaptureData> capture_data(CaptureFrame());
 
+  // Swap the current & previous buffers ready for the next capture.
+  last_invalid_region_ = capture_data->dirty_region();
+  last_buffer_ = current_buffer_;
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
 
   callback.Run(capture_data);
 }
 
 void VideoFrameCapturerLinux::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;
@@ skipping 65 matching lines @@
                                               media::VideoFrame::RGB32);
 
   // Pass the screen size to the helper, so it can clip the invalid region if it
   // expands that region to a grid.
   helper_.set_size_most_recent(capture_data->size());
 
   // 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_)
+  if (use_damage_ && !buffers_[last_buffer_].needs_update())
     SynchronizeFrame();
 
   SkRegion invalid_region;
 
   x_server_pixel_buffer_.Synchronize();
-  if (use_damage_ && last_buffer_) {
+  if (use_damage_ && !buffers_[last_buffer_].needs_update()) {
     // Atomically fetch and clear the damage region.
     XDamageSubtract(display_, damage_handle_, None, damage_region_);
     int nRects = 0;
     XRectangle bounds;
     XRectangle* rects = XFixesFetchRegionAndBounds(display_, damage_region_,
                                                    &nRects, &bounds);
     for (int i=0; i<nRects; ++i) {
       invalid_region.op(SkIRect::MakeXYWH(rects[i].x, rects[i].y,
                                           rects[i].width, rects[i].height),
                         SkRegion::kUnion_Op);
     }
     XFree(rects);
     helper_.InvalidateRegion(invalid_region);
 
     // Capture the damaged portions of the desktop.
     helper_.SwapInvalidRegion(&invalid_region);
     for (SkRegion::Iterator it(invalid_region); !it.done(); it.next()) {
       CaptureRect(it.rect(), capture_data);
     }
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
     SkIRect screen_rect = SkIRect::MakeWH(buffer.size().width(),
                                           buffer.size().height());
     CaptureRect(screen_rect, capture_data);
 
-    if (last_buffer_) {
+    if (!buffers_[last_buffer_].needs_update()) {
       // Full-screen polling, so calculate the invalid rects here, based on the
       // changed pixels between current and previous buffers.
       DCHECK(differ_ != NULL);
-      differ_->CalcDirtyRegion(last_buffer_, buffer.ptr(), &invalid_region);
+      VideoFrameBuffer& last_buffer = buffers_[last_buffer_];
+      differ_->CalcDirtyRegion(
+          last_buffer.ptr(), 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_region.op(screen_rect, SkRegion::kUnion_Op);
     }
   }
 
   capture_data->mutable_dirty_region() = invalid_region;
-  last_invalid_region_ = invalid_region;
-  last_buffer_ = buffer.ptr();
   return capture_data;
 }
 
 void VideoFrameCapturerLinux::ScreenConfigurationChanged() {
-  last_buffer_ = NULL;
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
   helper_.ClearInvalidRegion();
   x_server_pixel_buffer_.Init(display_);
 }
 
 void VideoFrameCapturerLinux::SynchronizeFrame() {
   // Synchronize the current buffer with the previous 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
   // |capturer_helper_|s region from |last_invalid_region_|.
   // http://crbug.com/92354
-  DCHECK(last_buffer_);
+  DCHECK(!buffers_[last_buffer_].needs_update());
+  DCHECK_NE(last_buffer_, current_buffer_);
   VideoFrameBuffer& buffer = buffers_[current_buffer_];
+  VideoFrameBuffer& last_buffer = buffers_[last_buffer_];
   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,
+      memcpy(buffer.ptr() + offset, last_buffer.ptr() + offset,
              r.width() * kBytesPerPixel);
       offset += buffer.size().width() * kBytesPerPixel;
     }
   }
 }
 
 void VideoFrameCapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display_, gc_);
     gc_ = NULL;
@@ skipping 116 matching lines @@
   }
   return capturer;
 }
 
 // static
 void VideoFrameCapturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting