Merge ScreenCapturerWinDirectx::frames_ and contexts_

webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.cc

 /*
  *  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/win/dxgi_duplicator_controller.h"
 
 #include <windows.h>
 
 #include <algorithm>
 #include <string>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_types.h"
+#include "webrtc/modules/desktop_capture/win/dxgi_frame.h"
 #include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 
 namespace webrtc {
 
-DxgiDuplicatorController::Context::Context() = default;
-
-DxgiDuplicatorController::Context::~Context() {
-  DxgiDuplicatorController::Instance()->Unregister(this);
-}
-
-void DxgiDuplicatorController::Context::Reset() {
-  identity_ = 0;
-}
-
 // static
 DxgiDuplicatorController* DxgiDuplicatorController::Instance() {
   // The static instance won't be deleted to ensure it can be used by other
   // threads even during program exiting.
   static DxgiDuplicatorController* instance = new DxgiDuplicatorController();
   return instance;
 }
 
 DxgiDuplicatorController::DxgiDuplicatorController() = default;
 
 DxgiDuplicatorController::~DxgiDuplicatorController() {
   rtc::CritScope lock(&lock_);
   Deinitialize();
 }
 
 bool DxgiDuplicatorController::IsSupported() {
   rtc::CritScope lock(&lock_);
   return Initialize();
 }
 
-void DxgiDuplicatorController::Reset() {
-  rtc::CritScope lock(&lock_);
-  Deinitialize();
-}
-
 bool DxgiDuplicatorController::RetrieveD3dInfo(D3dInfo* info) {
   rtc::CritScope lock(&lock_);
   if (!Initialize()) {
     return false;
   }
   *info = d3d_info_;
   return true;
 }
 
+DxgiDuplicatorController::Result
+DxgiDuplicatorController::Duplicate(DxgiFrame* frame) {
+  return DoDuplicate(frame, -1);
+}
+
+DxgiDuplicatorController::Result
+DxgiDuplicatorController::DuplicateMonitor(DxgiFrame* frame, int monitor_id) {
+  RTC_DCHECK_GE(monitor_id, 0);
+  return DoDuplicate(frame, monitor_id);
+}
+
 DesktopVector DxgiDuplicatorController::dpi() {
   rtc::CritScope lock(&lock_);
   if (Initialize()) {
     return dpi_;
   }
   return DesktopVector();
 }
 
-DesktopRect DxgiDuplicatorController::desktop_rect() {
-  rtc::CritScope lock(&lock_);
-  if (Initialize()) {
-    return desktop_rect_;
-  }
-  return DesktopRect();
-}
-
-DesktopSize DxgiDuplicatorController::desktop_size() {
-  DesktopRect rect = desktop_rect();
-  return DesktopSize(rect.right(), rect.bottom());
-}
-
-DesktopRect DxgiDuplicatorController::ScreenRect(int id) {
-  RTC_DCHECK(id >= 0);
-  rtc::CritScope lock(&lock_);
-  if (!Initialize()) {
-    return DesktopRect();
-  }
-  for (size_t i = 0; i < duplicators_.size(); i++) {
-    if (id >= duplicators_[i].screen_count()) {
-      id -= duplicators_[i].screen_count();
-    } else {
-      return duplicators_[i].ScreenRect(id);
-    }
-  }
-  return DesktopRect();
-}
-
 int DxgiDuplicatorController::ScreenCount() {
   rtc::CritScope lock(&lock_);
-  return ScreenCountUnlocked();
+  if (Initialize()) {
+    return ScreenCountUnlocked();
+  }
+  return 0;
+}
+
+DxgiDuplicatorController::Result
+DxgiDuplicatorController::DoDuplicate(DxgiFrame* frame, int monitor_id) {
+  RTC_DCHECK(frame);
+  rtc::CritScope lock(&lock_);
+
+  // The dxgi components and APIs do not update the screen resolution without
+  // a reinitialization. So we use the GetDC() function to retrieve the screen
+  // resolution to decide whether dxgi components need to be reinitialized.
+  // If the screen resolution changed, it's very likely the next Duplicate()
+  // function call will fail because of a missing monitor or the frame size is
+  // not enough to store the output. So we reinitialize dxgi components in-place
+  // to avoid a capture failure.
+  // But there is no guarantee GetDC() function returns the same resolution as
+  // dxgi APIs, we still rely on dxgi components to return the output frame
+  // size.
+  // TODO(zijiehe): Confirm whether IDXGIOutput::GetDesc() and
+  // IDXGIOutputDuplication::GetDesc() can detect the resolution change without
+  // reinitialization.
+  if (resolution_change_detector_.IsChanged(
+          GetScreenRect(kFullDesktopScreenId, std::wstring()).size())) {
+    Deinitialize();
+  }
+
+  if (!Initialize()) {
+    // Cannot initialize COM components now, display mode may be changing.
+    return Result::INITIALIZATION_FAILED;
+  }
+
+  if (!frame->Prepare(SelectedDesktopSize(monitor_id), monitor_id)) {
+    return Result::FRAME_PREPARE_FAILED;
+  }
+
+  frame->frame()->mutable_updated_region()->Clear();
+
+  if (DoDuplicateUnlocked(frame->context(), monitor_id, frame->frame())) {
+    return Result::SUCCEEDED;
+  }
+  if (monitor_id >= ScreenCountUnlocked()) {
+    // It's a user error to provide a |monitor_id| larger than screen count. We
+    // do not need to deinitialize.
+    return Result::INVALID_MONITOR_ID;
+  }
+
+  // If the |monitor_id| is valid, but DoDuplicateUnlocked() failed, something
+  // must be wrong from capturer APIs. We should Deinitialize().
+  Deinitialize();
+  return Result::DUPLICATION_FAILED;
 }
 
 void DxgiDuplicatorController::Unregister(const Context* const context) {
   rtc::CritScope lock(&lock_);
   if (ContextExpired(context)) {
     // The Context has not been setup after a recent initialization, so it
     // should not been registered in duplicators.
     return;
   }
   for (size_t i = 0; i < duplicators_.size(); i++) {
-    duplicators_[i].Unregister(&context->contexts_[i]);
+    duplicators_[i].Unregister(&context->contexts[i]);
   }
 }
 
 bool DxgiDuplicatorController::Initialize() {
   if (!duplicators_.empty()) {
     return true;
   }
 
   if (DoInitialize()) {
     return true;
@@ skipping 56 matching lines @@
 }
 
 void DxgiDuplicatorController::Deinitialize() {
   desktop_rect_ = DesktopRect();
   duplicators_.clear();
   resolution_change_detector_.Reset();
 }
 
 bool DxgiDuplicatorController::ContextExpired(
     const Context* const context) const {
-  return context->identity_ != identity_ ||
-         context->contexts_.size() != duplicators_.size();
+  RTC_DCHECK(context);
+  return context->controller_id != identity_ ||
+         context->contexts.size() != duplicators_.size();
 }
 
 void DxgiDuplicatorController::Setup(Context* context) {
   if (ContextExpired(context)) {
-    context->contexts_.clear();
-    context->contexts_.resize(duplicators_.size());
+    RTC_DCHECK(context);
+    context->contexts.clear();
+    context->contexts.resize(duplicators_.size());
     for (size_t i = 0; i < duplicators_.size(); i++) {
-      duplicators_[i].Setup(&context->contexts_[i]);
+      duplicators_[i].Setup(&context->contexts[i]);
     }
-    context->identity_ = identity_;
+    context->controller_id = identity_;
   }
 }
 
-bool DxgiDuplicatorController::Duplicate(Context* context,
-                                         SharedDesktopFrame* target) {
-  return DoDuplicate(context, -1, target);
-}
-
-bool DxgiDuplicatorController::DuplicateMonitor(Context* context,
-                                                int monitor_id,
-                                                SharedDesktopFrame* target) {
-  RTC_DCHECK_GE(monitor_id, 0);
-  return DoDuplicate(context, monitor_id, target);
-}
-
-bool DxgiDuplicatorController::DoDuplicate(Context* context,
-                                           int monitor_id,
-                                           SharedDesktopFrame* target) {
-  RTC_DCHECK(target);
-  target->mutable_updated_region()->Clear();
-  rtc::CritScope lock(&lock_);
-  if (DoDuplicateUnlocked(context, monitor_id, target)) {
-    return true;
-  }
-  if (monitor_id < ScreenCountUnlocked()) {
-    // It's a user error to provide a |monitor_id| larger than screen count. We
-    // do not need to deinitialize.
-    Deinitialize();
-  }
-  return false;
-}
-
 bool DxgiDuplicatorController::DoDuplicateUnlocked(Context* context,
                                                    int monitor_id,
                                                    SharedDesktopFrame* target) {
-  if (!Initialize()) {
-    // Cannot initialize COM components now, display mode may be changing.
-    return false;
-  }
-
-  if (resolution_change_detector_.IsChanged(
-          GetScreenRect(kFullDesktopScreenId, std::wstring()).size())) {
-    // Resolution of entire screen has been changed, which usually means a new
-    // monitor has been attached or one has been removed. The simplest way is to
-    // Deinitialize() and returns false to indicate downstream components.
-    return false;
-  }
-
   Setup(context);
 
   if (!EnsureFrameCaptured(context, target)) {
     return false;
   }
 
   bool result = false;
   if (monitor_id < 0) {
     // Capture entire screen.
     result = DoDuplicateAll(context, target);
   } else {
     result = DoDuplicateOne(context, monitor_id, target);
   }
 
   if (result) {
     target->set_dpi(dpi());
     return true;
   }
 
   return false;
 }
 
 bool DxgiDuplicatorController::DoDuplicateAll(Context* context,
                                               SharedDesktopFrame* target) {
   for (size_t i = 0; i < duplicators_.size(); i++) {
-    if (!duplicators_[i].Duplicate(&context->contexts_[i], target)) {
+    if (!duplicators_[i].Duplicate(&context->contexts[i], target)) {
       return false;
     }
   }
   return true;
 }
 
 bool DxgiDuplicatorController::DoDuplicateOne(Context* context,
                                               int monitor_id,
                                               SharedDesktopFrame* target) {
   RTC_DCHECK(monitor_id >= 0);
-  for (size_t i = 0; i < duplicators_.size() && i < context->contexts_.size();
+  for (size_t i = 0; i < duplicators_.size() && i < context->contexts.size();
        i++) {
     if (monitor_id >= duplicators_[i].screen_count()) {
       monitor_id -= duplicators_[i].screen_count();
     } else {
-      if (duplicators_[i].DuplicateMonitor(&context->contexts_[i], monitor_id,
+      if (duplicators_[i].DuplicateMonitor(&context->contexts[i], monitor_id,
                                            target)) {
         return true;
       }
       return false;
     }
   }
   return false;
 }
 
 int64_t DxgiDuplicatorController::GetNumFramesCaptured() const {
   int64_t min = INT64_MAX;
   for (const auto& duplicator : duplicators_) {
     min = std::min(min, duplicator.GetNumFramesCaptured());
   }
 
   return min;
 }
 
-int DxgiDuplicatorController::ScreenCountUnlocked() {
-  if (!Initialize()) {
-    return 0;
+DesktopSize DxgiDuplicatorController::desktop_size() const {
+  return DesktopSize(desktop_rect_.right(), desktop_rect_.bottom());
+}
+
+DesktopRect DxgiDuplicatorController::ScreenRect(int id) const {
+  RTC_DCHECK(id >= 0);
+  for (size_t i = 0; i < duplicators_.size(); i++) {
+    if (id >= duplicators_[i].screen_count()) {
+      id -= duplicators_[i].screen_count();
+    } else {
+      return duplicators_[i].ScreenRect(id);
+    }
   }
+  return DesktopRect();
+}
+
+int DxgiDuplicatorController::ScreenCountUnlocked() const {
   int result = 0;
   for (auto& duplicator : duplicators_) {
     result += duplicator.screen_count();
   }
   return result;
 }
 
+DesktopSize DxgiDuplicatorController::SelectedDesktopSize(
+    int monitor_id) const {
+  if (monitor_id < 0) {
+    return desktop_size();
+  }
+
+  return ScreenRect(monitor_id).size();
+}
+
 bool DxgiDuplicatorController::EnsureFrameCaptured(Context* context,
                                                    SharedDesktopFrame* target) {
   // On a modern system, the FPS / monitor refresh rate is usually larger than
   // or equal to 60. So 17 milliseconds is enough to capture at least one frame.
   const int64_t ms_per_frame = 17;
   // Skips the first frame to ensure a full frame refresh has happened before
   // this function returns.
   const int64_t frames_to_skip = 1;
   // The total time out milliseconds for this function. If we cannot get enough
   // frames during this time interval, this function returns false, and cause
@@ skipping 32 matching lines @@
       return false;
     }
     if (rtc::TimeMillis() - start_ms > timeout_ms) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace webrtc