Modify ScreenCaptureFrameQueue into a template

webrtc/modules/desktop_capture/screen_capturer_x11.cc

 /*
  *  Copyright (c) 2013 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/screen_capturer.h"
 
 #include <string.h>
 
 #include <memory>
 #include <set>
 
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/differ.h"
-#include "webrtc/modules/desktop_capture/screen_capture_frame_queue.h"
+#include "webrtc/modules/desktop_capture/screen_capture_queue.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_helper.h"
+#include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
 #include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 namespace {
 
 // A class to perform video frame capturing for Linux.
 class ScreenCapturerLinux : public ScreenCapturer,
                             public SharedXDisplay::XEventHandler {
@@ skipping 60 matching lines @@
   XserverRegion damage_region_;
 
   // 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.
   ScreenCapturerHelper helper_;
 
   // Queue of the frames buffers.
-  ScreenCaptureFrameQueue queue_;
+  ScreenCaptureQueue<SharedDesktopFrame> queue_;
 
   // Invalid region from the previous capture. This is used to synchronize the
   // current with the last buffer used.
   DesktopRegion last_invalid_region_;
 
   // |Differ| for use when polling for changes.
   std::unique_ptr<Differ> differ_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerLinux);
 };
@@ skipping 109 matching lines @@
 void ScreenCapturerLinux::Start(Callback* callback) {
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
 
   callback_ = callback;
 }
 
 void ScreenCapturerLinux::Capture(const DesktopRegion& region) {
   TickTime capture_start_time = TickTime::Now();
 
-  queue_.MoveToNextFrame();
+  queue_.MoveToNext();
+  RTC_DCHECK(!queue_.current() || !queue_.current()->IsShared());
 
   // Process XEvents for XDamage and cursor shape tracking.
   options_.x_display()->ProcessPendingXEvents();
 
   // ProcessPendingXEvents() may call ScreenConfigurationChanged() which
   // reinitializes |x_server_pixel_buffer_|. Check if the pixel buffer is still
   // in a good shape.
   if (!x_server_pixel_buffer_.is_initialized()) {
      // We failed to initialize pixel buffer.
      callback_->OnCaptureCompleted(NULL);
      return;
   }
 
   // If the current frame is from an older generation then allocate a new one.
   // Note that we can't reallocate other buffers at this point, since the caller
   // may still be reading from them.
-  if (!queue_.current_frame()) {
+  if (!queue_.current()) {
     std::unique_ptr<DesktopFrame> frame(
         new BasicDesktopFrame(x_server_pixel_buffer_.window_size()));
-    queue_.ReplaceCurrentFrame(frame.release());
+    queue_.ReplaceCurrent(SharedDesktopFrame::Wrap(std::move(frame)));
   }
 
   // Refresh the Differ helper used by CaptureFrame(), if needed.
-  DesktopFrame* frame = queue_.current_frame();
+  DesktopFrame* frame = queue_.current();
   if (!use_damage_ && (
       !differ_.get() ||
       (differ_->width() != frame->size().width()) ||
       (differ_->height() != frame->size().height()) ||
       (differ_->bytes_per_row() != frame->stride()))) {
     differ_.reset(new Differ(frame->size().width(), frame->size().height(),
                              DesktopFrame::kBytesPerPixel,
                              frame->stride()));
   }
 
@@ skipping 27 matching lines @@
     RTC_DCHECK(damage_event->level == XDamageReportNonEmpty);
     return true;
   } else if (event.type == ConfigureNotify) {
     ScreenConfigurationChanged();
     return true;
   }
   return false;
 }
 
 DesktopFrame* ScreenCapturerLinux::CaptureScreen() {
-  DesktopFrame* frame = queue_.current_frame()->Share();
+  DesktopFrame* frame = queue_.current()->Share();
   assert(x_server_pixel_buffer_.window_size().equals(frame->size()));
 
   // 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(frame->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_ && queue_.previous_frame())
+  if (use_damage_ && queue_.previous())
     SynchronizeFrame();
 
   DesktopRegion* updated_region = frame->mutable_updated_region();
 
   x_server_pixel_buffer_.Synchronize();
-  if (use_damage_ && queue_.previous_frame()) {
+  if (use_damage_ && queue_.previous()) {
     // Atomically fetch and clear the damage region.
     XDamageSubtract(display(), damage_handle_, None, damage_region_);
     int rects_num = 0;
     XRectangle bounds;
     XRectangle* rects = XFixesFetchRegionAndBounds(display(), damage_region_,
                                                    &rects_num, &bounds);
     for (int i = 0; i < rects_num; ++i) {
       updated_region->AddRect(DesktopRect::MakeXYWH(
           rects[i].x, rects[i].y, rects[i].width, rects[i].height));
     }
@@ skipping 12 matching lines @@
     for (DesktopRegion::Iterator it(*updated_region);
          !it.IsAtEnd(); it.Advance()) {
       x_server_pixel_buffer_.CaptureRect(it.rect(), frame);
     }
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
     DesktopRect screen_rect = DesktopRect::MakeSize(frame->size());
     x_server_pixel_buffer_.CaptureRect(screen_rect, frame);
 
-    if (queue_.previous_frame()) {
+    if (queue_.previous()) {
       // Full-screen polling, so calculate the invalid rects here, based on the
       // changed pixels between current and previous buffers.
       RTC_DCHECK(differ_.get() != NULL);
-      RTC_DCHECK(queue_.previous_frame()->data());
-      differ_->CalcDirtyRegion(queue_.previous_frame()->data(),
+      RTC_DCHECK(queue_.previous()->data());
+      differ_->CalcDirtyRegion(queue_.previous()->data(),
                                frame->data(), updated_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.
       updated_region->SetRect(screen_rect);
     }
   }
 
@@ skipping 13 matching lines @@
 
 void ScreenCapturerLinux::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
-  RTC_DCHECK(queue_.previous_frame());
+  RTC_DCHECK(queue_.previous());
 
-  DesktopFrame* current = queue_.current_frame();
-  DesktopFrame* last = queue_.previous_frame();
+  DesktopFrame* current = queue_.current();
+  DesktopFrame* last = queue_.previous();
   RTC_DCHECK(current != last);
   for (DesktopRegion::Iterator it(last_invalid_region_);
        !it.IsAtEnd(); it.Advance()) {
     current->CopyPixelsFrom(*last, it.rect().top_left(), it.rect());
   }
 }
 
 void ScreenCapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display(), gc_);
@@ skipping 22 matching lines @@
   if (!options.x_display())
     return NULL;
 
   std::unique_ptr<ScreenCapturerLinux> capturer(new ScreenCapturerLinux());
   if (!capturer->Init(options))
     capturer.reset();
   return capturer.release();
 }
 
 }  // namespace webrtc