Ensure Dxgi duplicator works correctly in session 0

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/logging.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 {
 
+namespace {
+
+// TODO(zijiehe): This function should be public as
+// static bool DxgiDuplicatorController::IsSessionUnsupported()
+bool IsRunningInSession0() {
+  DWORD session_id = 0;
+  if (!::ProcessIdToSessionId(::GetCurrentProcessId(), &session_id)) {
+    LOG(LS_WARNING) << "Failed to retrieve current session Id, current binary "
+                       "may not have required priviledge.";
+    return true;
+  }
+  return session_id == 0;
+}
+
+}  // namespace
+
 // static
 rtc::scoped_refptr<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 rtc::scoped_refptr<DxgiDuplicatorController>(instance);
 }
 
 DxgiDuplicatorController::DxgiDuplicatorController()
@@ skipping 13 matching lines @@
     Unload();
   }
 }
 
 bool DxgiDuplicatorController::IsSupported() {
   rtc::CritScope lock(&lock_);
   return Initialize();
 }
 
 bool DxgiDuplicatorController::RetrieveD3dInfo(D3dInfo* info) {
-  rtc::CritScope lock(&lock_);
-  if (!Initialize()) {
-    return false;
+  bool result = false;
+  {
+    rtc::CritScope lock(&lock_);
+    result = Initialize();
+    *info = d3d_info_;
   }
-  *info = d3d_info_;
-  return true;
+  if (!result) {
+    LOG(LS_WARNING) << "Failed to initialize DXGI components, the D3dInfo "
+                       "retrieved may not accurate or out of date.";
+  }
+  return result;
 }
 
 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);
@@ skipping 33 matching lines @@
   // 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()) {
+    if (succeeded_duplications_ == 0 && IsRunningInSession0()) {
+      LOG(LS_WARNING) << "Current binary is running in session 0. DXGI "
+                         "components cannot be initialized.";
+      return Result::UNSUPPORTED_SESSION;
+    }
+
     // 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())) {
+    succeeded_duplications_++;
     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().
@@ skipping 32 matching lines @@
 
 bool DxgiDuplicatorController::DoInitialize() {
   RTC_DCHECK(desktop_rect_.is_empty());
   RTC_DCHECK(duplicators_.empty());
 
   d3d_info_.min_feature_level = static_cast<D3D_FEATURE_LEVEL>(0);
   d3d_info_.max_feature_level = static_cast<D3D_FEATURE_LEVEL>(0);
 
   std::vector<D3dDevice> devices = D3dDevice::EnumDevices();
   if (devices.empty()) {
+    LOG(LS_WARNING) << "No D3dDevice found.";
     return false;
   }
 
   for (size_t i = 0; i < devices.size(); i++) {
-    duplicators_.emplace_back(devices[i]);
-    if (!duplicators_.back().Initialize()) {
-      return false;
-    }
-
     D3D_FEATURE_LEVEL feature_level =
         devices[i].d3d_device()->GetFeatureLevel();
     if (d3d_info_.max_feature_level == 0 ||
         feature_level > d3d_info_.max_feature_level) {
       d3d_info_.max_feature_level = feature_level;
     }
     if (d3d_info_.min_feature_level == 0 ||
         feature_level < d3d_info_.min_feature_level) {
       d3d_info_.min_feature_level = feature_level;
     }
 
+    DxgiAdapterDuplicator duplicator(devices[i]);
+    // There may be several video cards on the system, some of them may not
+    // support IDXGOutputDuplication. But they should not impact others from
+    // taking effect, so we should continually try other adapters. This usually
+    // happens when a non-official virtual adapter is installed on the system.
+    if (!duplicator.Initialize()) {
+      LOG(LS_WARNING) << "Failed to initialize DxgiAdapterDuplicator on "
+                         "adapter "
+                      << i;
+      continue;
+    }
+    RTC_DCHECK(!duplicator.desktop_rect().is_empty());
+    duplicators_.push_back(std::move(duplicator));
+
     desktop_rect_.UnionWith(duplicators_.back().desktop_rect());
   }
   TranslateRect();
 
   HDC hdc = GetDC(nullptr);
   // Use old DPI value if failed.
   if (hdc) {
     dpi_.set(GetDeviceCaps(hdc, LOGPIXELSX), GetDeviceCaps(hdc, LOGPIXELSY));
     ReleaseDC(nullptr, hdc);
   }
 
   identity_++;
-  return true;
+
+  if (duplicators_.empty()) {
+    LOG(LS_WARNING) << "Cannot initialize any DxgiAdapterDuplicator instance.";
+  }
+
+  return !duplicators_.empty();
 }
 
 void DxgiDuplicatorController::Deinitialize() {
   desktop_rect_ = DesktopRect();
   duplicators_.clear();
   resolution_change_detector_.Reset();
 }
 
 bool DxgiDuplicatorController::ContextExpired(
     const Context* const context) const {
@@ skipping 164 matching lines @@
 void DxgiDuplicatorController::TranslateRect() {
   const DesktopVector position =
       DesktopVector().subtract(desktop_rect_.top_left());
   desktop_rect_.Translate(position);
   for (auto& duplicator : duplicators_) {
     duplicator.TranslateRect(position);
   }
 }
 
 }  // namespace webrtc