Merge ScreenCapturerWinDirectx::frames_ and contexts_

webrtc/modules/desktop_capture/win/screen_capturer_win_directx.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/screen_capturer_win_directx.h"
 
 #include <string>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
-#include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
 
 namespace webrtc {
 
 using Microsoft::WRL::ComPtr;
 
 // static
 bool ScreenCapturerWinDirectx::IsSupported() {
   // Forwards IsSupported() function call to DxgiDuplicatorController.
   return DxgiDuplicatorController::Instance()->IsSupported();
 }
@@ skipping 16 matching lines @@
   RTC_DCHECK(callback);
 
   callback_ = callback;
 }
 
 void ScreenCapturerWinDirectx::SetSharedMemoryFactory(
     std::unique_ptr<SharedMemoryFactory> shared_memory_factory) {
   shared_memory_factory_ = std::move(shared_memory_factory);
 }
 
-DesktopSize ScreenCapturerWinDirectx::SelectedDesktopSize() const {
-  if (current_screen_id_ == kFullDesktopScreenId) {
-    return DxgiDuplicatorController::Instance()->desktop_size();
-  }
-  return DxgiDuplicatorController::Instance()
-      ->ScreenRect(current_screen_id_)
-      .size();
-}
-
 void ScreenCapturerWinDirectx::CaptureFrame() {
   RTC_DCHECK(callback_);
 
   int64_t capture_start_time_nanos = rtc::TimeNanos();
 
-  // 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())) {
-    frames_.Reset();
-    DxgiDuplicatorController::Instance()->Reset();
-    resolution_change_detector_.Reset();
+  frames_.MoveToNextFrame();
+  if (!frames_.current_frame()) {
+    frames_.ReplaceCurrentFrame(std::unique_ptr<DxgiFrame>(

[Sergey Ulanov, 2017/04/18 18:10:16]

Please use MakeUnique from base/ptr_util.h

[Hzj_jie, 2017/04/18 22:17:53]

Done.

+        new DxgiFrame(shared_memory_factory_.get())));
   }
 
-  frames_.MoveToNextFrame();
-  if (!frames_.current_frame()) {
-    std::unique_ptr<DesktopFrame> new_frame;
-    if (shared_memory_factory_) {
-      new_frame = SharedMemoryDesktopFrame::Create(
-          SelectedDesktopSize(), shared_memory_factory_.get());
-    } else {
-      new_frame.reset(new BasicDesktopFrame(SelectedDesktopSize()));
-    }
-    if (!new_frame) {
-      LOG(LS_ERROR) << "Failed to allocate a new DesktopFrame.";
-      // This usually means we do not have enough memory or SharedMemoryFactory
-      // cannot work correctly.
-      callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
-      return;
-    }
-    frames_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(std::move(new_frame)));
-  }
-  contexts_.MoveToNextFrame();
-  if (!contexts_.current_frame()) {
-    contexts_.ReplaceCurrentFrame(
-        rtc::MakeUnique<DxgiDuplicatorController::Context>());
+  DxgiDuplicatorController::Result result;
+  if (current_screen_id_ == kFullDesktopScreenId) {
+    result = DxgiDuplicatorController::Instance()->Duplicate(
+        frames_.current_frame());
+  } else {
+    result = DxgiDuplicatorController::Instance()->DuplicateMonitor(
+        frames_.current_frame(), current_screen_id_);
   }
 
-  if (current_screen_id_ == kFullDesktopScreenId) {
-    if (!DxgiDuplicatorController::Instance()->Duplicate(
-            contexts_.current_frame(), frames_.current_frame())) {
-      // Screen size may be changed, so we need to reset the frames.
-      frames_.Reset();
-      resolution_change_detector_.Reset();
-      callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
-      return;
-    }
-  } else {
-    if (!DxgiDuplicatorController::Instance()->DuplicateMonitor(
-            contexts_.current_frame(), current_screen_id_,
-            frames_.current_frame())) {
-      // Screen size may be changed, so we need to reset the frames.
-      frames_.Reset();
-      resolution_change_detector_.Reset();
-      if (current_screen_id_ >=
-          DxgiDuplicatorController::Instance()->ScreenCount()) {
-        // Current monitor has been removed from the system.
-        callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
-      } else {
-        callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
-      }
-      return;
-    }
+  if (result != DxgiDuplicatorController::Result::SUCCEEDED) {
+    ProcessDuplicateResult(result);
+    return;
   }
 
-  std::unique_ptr<DesktopFrame> result = frames_.current_frame()->Share();
-  result->set_capture_time_ms(
+  std::unique_ptr<DesktopFrame> frame =
+      frames_.current_frame()->frame()->Share();
+  frame->set_capture_time_ms(
       (rtc::TimeNanos() - capture_start_time_nanos) /
       rtc::kNumNanosecsPerMillisec);
-  result->set_capturer_id(DesktopCapturerId::kScreenCapturerWinDirectx);
-  callback_->OnCaptureResult(Result::SUCCESS, std::move(result));
+  frame->set_capturer_id(DesktopCapturerId::kScreenCapturerWinDirectx);
+  callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 }
 
 bool ScreenCapturerWinDirectx::GetSourceList(SourceList* sources) {
   int screen_count = DxgiDuplicatorController::Instance()->ScreenCount();
   for (int i = 0; i < screen_count; i++) {
     sources->push_back({i});
   }
   return true;
 }
 
 bool ScreenCapturerWinDirectx::SelectSource(SourceId id) {
   if (id == current_screen_id_) {
     return true;
   }
 
-  // Changing target screen may or may not impact frame size. So resetting
-  // frames only when a Duplicate() function call returns false.
   if (id == kFullDesktopScreenId) {
     current_screen_id_ = id;
-    contexts_.Reset();
     return true;
   }
 
   int screen_count = DxgiDuplicatorController::Instance()->ScreenCount();
   if (id >= 0 && id < screen_count) {
     current_screen_id_ = id;
-    contexts_.Reset();
     return true;
   }
   return false;
 }
 
+void ScreenCapturerWinDirectx::ProcessDuplicateResult(
+    DxgiDuplicatorController::Result result) {
+  using DuplicateResult = DxgiDuplicatorController::Result;
+  RTC_DCHECK(result != DuplicateResult::SUCCEEDED);
+
+  switch (result) {
+    case DuplicateResult::FRAME_PREPARE_FAILED: {
+      LOG(LS_ERROR) << "Failed to allocate a new DesktopFrame.";
+      // This usually means we do not have enough memory or SharedMemoryFactory
+      // cannot work correctly.
+      callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
+      break;
+    }
+    case DuplicateResult::INVALID_MONITOR_ID: {
+      callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
+      break;
+    }
+    case DuplicateResult::INITIALIZATION_FAILED:
+    case DuplicateResult::DUPLICATION_FAILED: {
+      callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
+      break;
+    }
+    default: {

[Sergey Ulanov, 2017/04/18 18:10:16]

It's best to avoid default case for switch statement on enum values. I'm not
sure why the success case is handled in CaptureFrame() and not here. I think it
would be cleaner to have one switch that handles all cases. Maybe move this
switch() to CaptureFrame()? If you keep this function then call it
ProcessErrorResult() or smthng like this. And then replace defailt case with
NOTREACHED() in Result::SUCCEEDED.

[Hzj_jie, 2017/04/18 22:17:54]

Done.

+      RTC_NOTREACHED();
+    }
+  }
+}
+
 }  // namespace webrtc