DirectX based screen capturer logic

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.h>
+
+#include <comdef.h>
+#include <wincodec.h>
+#include <DXGI.h>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/modules/desktop_capture/desktop_frame.h"
+#include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
+#include "webrtc/system_wrappers/include/atomic32.h"
+#include "webrtc/system_wrappers/include/logging.h"
+#include "webrtc/system_wrappers/include/tick_util.h"
+
+namespace webrtc {
+
+using Microsoft::WRL::ComPtr;
+using rtc::CriticalSection;
+using rtc::CritScope;
+using std::unique_ptr;
+
+namespace {
+
+// Timeout for AcquireNextFrame() call
+const int kAcquireTimeoutMs = 10;
+
+// Wait time between two DuplicateOutput operations, DuplicateOutput may fail if
+// display mode is changing.
+const int kDuplicateOutputWaitMs = 50;
+
+// How many times we attempt to DuplicateOutput before returning an error to
+// upstream components.
+const int kDuplicateOutputAttempts = 10;
+
+rtc::GlobalLockPod g_initialize_lock;
+
+// A container of all the objects we need to call Windows API. Note, one
+// application can only have one IDXGIOutputDuplication instance, that's the
+// reason the container is singleton.
+struct DxgiContainer {
+  CriticalSection duplication_lock;
+  CriticalSection acquire_lock;
+  bool initialize_result GUARDED_BY(g_initialize_lock) = false;
+  ID3D11Device* device GUARDED_BY(g_initialize_lock) = nullptr;
+  ID3D11DeviceContext* context GUARDED_BY(g_initialize_lock) = nullptr;
+  IDXGIOutput1* output1 GUARDED_BY(g_initialize_lock) = nullptr;
+  ComPtr<IDXGIOutputDuplication> duplication
+      GUARDED_BY(duplication_lock);
+  DXGI_OUTDUPL_DESC duplication_desc;
+  std::vector<uint8_t> metadata GUARDED_BY(acquire_lock);
+};
+
+DxgiContainer* g_container GUARDED_BY(g_initialize_lock);
+
+DesktopRect ExpandAndIntersect(const DesktopRect& input,
+                               const DesktopSize& size) {
+  // VideoEncoderVpx expects to use 8 pixels (for v9) or 3 pixels (for v8) more
+  // area to encode final video. So we need to copy a little bit more than the
+  // real changed area.
+  // In AlignRect function, 1 more pixel may be applied to right and bottom,

[Sergey Ulanov, 2016/05/13 19:38:11]

The VideoEncoderVpx and AlignRect() references are confusing here, because they
are in remoting. Just say that the edges need to be aligned 8 pixels for the VPX
encoder and 1 extra pixel for YUV conversion.

But I don't understand why we need any of this at all - see my comment below.

[Hzj_jie, 2016/05/16 18:17:28]

Done.

+  // so we add 9 pixels here.
+  DesktopRect output = input;
+  output.Expand(9);
+  output.IntersectWith(DesktopRect::MakeSize(size));
+  return output;
+}
+
+}  // namespace
+
+// A pair of an ID3D11Texture2D and an IDXGISurface. We need an
+// ID3D11Texture2D instance to copy GPU texture to RAM, but an IDXGISurface to
+// map the texture into a bitmap buffer. These two instances are always
+// pointing to a same object.
+//
+// This class is not thread safe.
+class ScreenCapturerWinDirectx::Texture {
+ public:
+  // Copy a frame represented by frame_info and resource. Returns false if
+  // anything wrong. If updated_region is provided, copy only updated regions,
+  // otherwise, copy entire resource.
+  bool CopyFrom(const DXGI_OUTDUPL_FRAME_INFO& frame_info,
+                IDXGIResource* resource,
+                const DesktopRegion* updated_region) {

[Sergey Ulanov, 2016/05/13 19:38:11]

pass this parameter by reference.

[Hzj_jie, 2016/05/16 18:17:28]

Changed to a normal pointer, since we need to intersect with frame size, which
is only valid after InitializeStage function.

+    if (!resource || frame_info.AccumulatedFrames == 0) {
+      // Nothing updated, but current data is still valid.
+      return false;
+    }
+
+    ComPtr<ID3D11Texture2D> texture;
+    _com_error error = resource->QueryInterface(
+        __uuidof(ID3D11Texture2D),
+        reinterpret_cast<void**>(texture.GetAddressOf()));
+    if (error.Error() != S_OK || !texture) {
+      LOG(LS_ERROR) << "Failed to convert IDXGIResource to ID3D11Texture2D, "
+                       "error "
+                    << error.ErrorMessage() << ", code " << error.Error();
+      return false;
+    }
+
+    // AcquireNextFrame returns a CPU inaccessible IDXGIResource, so we need to
+    // make a copy.
+    if (!InitializeStage(texture.Get())) {
+      return false;
+    }
+
+    if (updated_region) {
+      for (DesktopRegion::Iterator it(*updated_region);
+           !it.IsAtEnd();
+           it.Advance()) {
+        DesktopRect rect = ExpandAndIntersect(it.rect(), size());

[Sergey Ulanov, 2016/05/13 19:38:11]

I don't understand why you need to do this. The target surface to which we copy
data should already have up-to-date data outside the updated region, so it
shouldn't be necessary to copy data outside of it.

[Hzj_jie, 2016/05/16 18:17:28]

Not really, we have two surfaces, the one we are now writing in to is not the
one with latest updated region.

[Sergey Ulanov, 2016/05/16 19:18:52]

This is incorrect. For the frames generated by the capturer we want to have the
whole frame contain up-to-date data. Not only updated_region. DesktopCapturer
consumers should be allowed to ignore updated_region. It doesn't matter for
remoting, but some consumers will not work properly with this capturer. See
content/browser/media/capture/desktop_capture_device.cc for example.
So I think instead of expanding the update_region by 9 pixels you do it here we
need to expand it with updated_region from the previous frame. That will ensure
that the whole frame is up-to-date.

[Hzj_jie, 2016/05/17 03:11:46]

Thank you, I have updated the logic.

+        D3D11_BOX box;
+        box.left = rect.left();
+        box.top = rect.top();
+        box.right = rect.right();
+        box.bottom = rect.bottom();
+        box.front = 0;
+        box.back = 1;
+        g_container->context->CopySubresourceRegion(

[Sergey Ulanov, 2016/05/13 19:38:11]

You end up copying some data multiple times due to region rects expansion. It's
better to 
1. Expand each rect in the updated_region.
2. Intersect the region with the screen rect.
3. Copy all data covered by the region.

Just make ExpandAndIntersect() work on a whole region instead of a rect?

(but I'm not sure we need ExpandAndIntersect() at all)

[Hzj_jie, 2016/05/16 18:17:28]

Yes, I did not realize that DesktopRegion also has an IntersectWith(const
DesktopSize&) function. For the reason of ExpandAndIntersect, I have explained
around line 123. (Though I have entirely removed this function, the logic has
been moved to DetectUpdatedRegion and Texture::CopyFrom functions.)

+            static_cast<ID3D11Resource*>(stage_.Get()),
+            0, rect.left(), rect.top(), 0,
+            static_cast<ID3D11Resource*>(texture.Get()),
+            0, &box);
+      }
+    } else {
+      g_container->context->CopyResource(
+          static_cast<ID3D11Resource*>(stage_.Get()),
+          static_cast<ID3D11Resource*>(texture.Get()));
+    }
+
+    rect_ = {0};
+    error = _com_error(surface_->Map(&rect_, DXGI_MAP_READ));
+    if (error.Error() != S_OK) {
+      LOG(LS_ERROR) << "Failed to map the IDXGISurface to a bitmap, error "
+                    << error.ErrorMessage() << ", code " << error.Error();
+      return false;
+    }
+
+    // surface_->Unmap() will be called next time we capture an image to avoid
+    // memory copy without shared_memory.
+    return true;
+  }
+
+  uint8_t* bits() const { return static_cast<uint8_t*>(rect_.pBits); }
+  int pitch() const { return static_cast<int>(rect_.Pitch); }
+  const DesktopSize& size() const { return size_; }
+
+  int32_t AddRef() {
+    return ++ref_count_;
+  }
+
+  int32_t Release() {
+    int32_t ref_count;
+    ref_count = --ref_count_;
+    if (ref_count == 0) {
+      delete this;
+    }
+    return ref_count;
+  }
+
+ private:
+  // Texture should only be deleted by Release function.
+  ~Texture() = default;
+
+  // Initializes stage_ from a CPU inaccessible IDXGIResource. Returns false
+  // if it fails to execute windows api.
+  bool InitializeStage(ID3D11Texture2D* texture) {
+    RTC_DCHECK(texture);
+    D3D11_TEXTURE2D_DESC desc = {0};
+    texture->GetDesc(&desc);
+    desc.BindFlags = 0;
+    desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+    desc.MiscFlags = 0;
+    desc.Usage = D3D11_USAGE_STAGING;
+    if (stage_) {
+      // Make sure stage_ and surface_ are always pointing to a same object.
+      // We need an ID3D11Texture2D instance for
+      // ID3D11DeviceContext::CopySubresourceRegion, but an IDXGISurface for
+      // IDXGISurface::Map.
+      {
+        ComPtr<IUnknown> left;
+        ComPtr<IUnknown> right;
+        bool left_result = SUCCEEDED(stage_.As(&left));
+        bool right_result = SUCCEEDED(surface_.As(&right));
+        RTC_DCHECK(left_result);
+        RTC_DCHECK(right_result);
+        RTC_DCHECK(left.Get() == right.Get());
+      }
+
+      // This buffer should be used already.
+      _com_error error = _com_error(surface_->Unmap());
+      if (error.Error() == S_OK) {
+        D3D11_TEXTURE2D_DESC current_desc;
+        stage_->GetDesc(&current_desc);
+        if (memcmp(&desc, &current_desc, sizeof(D3D11_TEXTURE2D_DESC)) == 0) {
+          return true;
+        }
+      } else {
+        // Let's recreate stage_ and surface_ later.
+        LOG(LS_ERROR) << "Failed to unmap surface, error "
+                      << error.ErrorMessage() << ", code " << error.Error();
+      }
+
+      stage_.Reset();
+      surface_.Reset();
+    } else {
+      RTC_DCHECK(!surface_);
+    }
+
+    _com_error error = _com_error(g_container->device->CreateTexture2D(
+        &desc, nullptr, stage_.GetAddressOf()));
+    if (error.Error() != S_OK || !stage_) {
+      LOG(LS_ERROR) << "Failed to create a new ID3D11Texture2D as stage, "
+                       "error "
+                    << error.ErrorMessage() << ", code " << error.Error();
+      return false;
+    }
+
+    error = _com_error(stage_.As(&surface_));
+    if (error.Error() != S_OK || !surface_) {
+      LOG(LS_ERROR) << "Failed to convert ID3D11Texture2D to IDXGISurface, "
+                       "error "
+                    << error.ErrorMessage() << ", code " << error.Error();
+      return false;
+    }
+
+    size_.set(desc.Width, desc.Height);
+    return true;
+  }
+
+  Microsoft::WRL::ComPtr<ID3D11Texture2D> stage_;
+  Microsoft::WRL::ComPtr<IDXGISurface> surface_;
+  DXGI_MAPPED_RECT rect_;
+  DesktopSize size_;
+  Atomic32 ref_count_;
+};
+
+// A DesktopFrame which does not own the data buffer, and also does not have
+// shared memory. This uses in IT2ME scenario only.
+class ScreenCapturerWinDirectx::DxgiDesktopFrame : public DesktopFrame {
+ public:
+  DxgiDesktopFrame(
+      const rtc::scoped_refptr<ScreenCapturerWinDirectx::Texture>* texture)

[Sergey Ulanov, 2016/05/13 19:38:11]

use const reference to scoped_refptr<> instead of const pointer.

[Hzj_jie, 2016/05/16 18:17:28]

Done.

+      : DesktopFrame(texture->get()->size(),
+                     texture->get()->pitch(),
+                     texture->get()->bits(),
+                     nullptr),
+        texture_(texture->get()) {
+  }
+
+  virtual ~DxgiDesktopFrame() {}
+
+ private:
+  // Keep a reference to the Texture instance to make sure we can still access
+  // its bytes array.
+  rtc::scoped_refptr<ScreenCapturerWinDirectx::Texture> texture_;
+};
+
+bool ScreenCapturerWinDirectx::Initialize() {
+  if (!g_container) {
+    rtc::GlobalLockScope lock(&g_initialize_lock);
+    if (!g_container) {
+      g_container = new DxgiContainer();
+      g_container->initialize_result = DoInitialize();
+      if (g_container->initialize_result) {
+        return true;
+      }
+
+      // Clean up if DirectX cannot work on the system.
+      if (g_container->duplication) {
+        g_container->duplication.Reset();
+      }
+
+      if (g_container->output1) {
+        g_container->output1->Release();
+        g_container->output1 = nullptr;
+      }
+
+      if (g_container->context) {
+        g_container->context->Release();
+        g_container->context = nullptr;
+      }
+
+      if (g_container->device) {
+        g_container->device->Release();
+        g_container->device = nullptr;
+      }
+
+      return false;
+    }
+  }
+
+  return g_container->initialize_result;
+}
+
+bool ScreenCapturerWinDirectx::DoInitialize() {
+  D3D_FEATURE_LEVEL feature_level;
+  _com_error error = D3D11CreateDevice(
+      nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
+      D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_SINGLETHREADED,
+      nullptr, 0, D3D11_SDK_VERSION, &g_container->device, &feature_level,
+      &g_container->context);
+  if (error.Error() != S_OK || !g_container->device || !g_container->context) {
+    LOG(LS_WARNING) << "D3D11CreateDeivce returns error "
+                    << error.ErrorMessage() << " with code " << error.Error();
+    return false;
+  }
+
+  if (feature_level < D3D_FEATURE_LEVEL_11_0) {
+    LOG(LS_WARNING) << "D3D11CreateDevice returns an instance without DirectX "
+                       "11 support, level "
+                    << feature_level;
+    return false;
+  }
+
+  ComPtr<IDXGIDevice> device;
+  error = _com_error(g_container->device->QueryInterface(
+      __uuidof(IDXGIDevice), reinterpret_cast<void**>(device.GetAddressOf())));
+  if (error.Error() != S_OK || !device) {
+    LOG(LS_WARNING) << "ID3D11Device is not an implementation of IDXGIDevice, "
+                       "this usually means the system does not support DirectX "
+                       "11";
+    return false;
+  }
+
+  ComPtr<IDXGIAdapter> adapter;
+  error = _com_error(device->GetAdapter(adapter.GetAddressOf()));
+  if (error.Error() != S_OK || !adapter) {
+    LOG(LS_WARNING) << "Failed to get an IDXGIAdapter implementation from "
+                       "IDXGIDevice.";
+    return false;
+  }
+
+  ComPtr<IDXGIOutput> output;
+  for (int i = 0;; i++) {
+    error = _com_error(adapter->EnumOutputs(i, output.GetAddressOf()));
+    if (error.Error() == DXGI_ERROR_NOT_FOUND) {
+      LOG(LS_WARNING) << "No output detected.";
+      return false;
+    }
+    if (error.Error() == S_OK && output) {
+      DXGI_OUTPUT_DESC desc;
+      error = _com_error(output->GetDesc(&desc));
+      if (error.Error() == S_OK) {
+        if (desc.AttachedToDesktop) {
+          // Current output instance is the device attached to desktop.
+          break;
+        }
+      } else {
+        LOG(LS_WARNING) << "Failed to get output description of device " << i
+                        << ", ignore.";
+      }
+    }
+  }
+
+  RTC_DCHECK(output);
+  error = _com_error(output.CopyTo(
+      __uuidof(IDXGIOutput1), reinterpret_cast<void**>(&g_container->output1)));
+  if (error.Error() != S_OK || !g_container->output1) {
+    LOG(LS_WARNING) << "Failed to convert IDXGIOutput to IDXGIOutput1, this "
+                       "usually means the system does not support DirectX 11";
+    return false;
+  }
+
+  return DuplicateOutput();
+}
+
+bool ScreenCapturerWinDirectx::DuplicateOutput() {
+  // We are updating the instance.
+  CritScope lock(&g_container->duplication_lock);
+  // Make sure nobody is using current instance.
+  CritScope lock2(&g_container->acquire_lock);
+  if (g_container->duplication) {
+    g_container->duplication->ReleaseFrame();
+    g_container->duplication.Reset();
+  }
+
+  for (int i = 0; i < kDuplicateOutputAttempts; i++) {
+    _com_error error = g_container->output1->DuplicateOutput(
+        static_cast<IUnknown*>(g_container->device),
+        g_container->duplication.GetAddressOf());
+    if (error.Error() == S_OK && g_container->duplication) {
+      memset(&g_container->duplication_desc, 0, sizeof(DXGI_OUTDUPL_DESC));
+      g_container->duplication->GetDesc(&g_container->duplication_desc);
+      if (g_container->duplication_desc.ModeDesc.Format !=
+          DXGI_FORMAT_B8G8R8A8_UNORM) {
+        LOG(LS_ERROR) << "IDXGIDuplicateOutput does not use RGBA (8 bit) "
+                         "format, which is required by downstream components, "
+                         "format is "
+                      << g_container->duplication_desc.ModeDesc.Format;
+        return false;
+      }
+
+      return true;
+    } else {
+      // Make sure we have correct signal and duplicate the output next time.
+      g_container->duplication.Reset();
+      LOG(LS_WARNING) << "Failed to duplicate output from IDXGIOutput1, error "
+                      << error.ErrorMessage() << ", with code "
+                      << error.Error();
+      Sleep(kDuplicateOutputWaitMs);
+    }
+  }
+
+  return false;
+}
+
+ScreenCapturerWinDirectx::ScreenCapturerWinDirectx(
+    const DesktopCaptureOptions& options)
+    : callback_(nullptr), set_thread_execution_state_failed_(false) {
+  RTC_DCHECK(g_container && g_container->initialize_result);
+
+  // Texture instance won't change forever.
+  while (!surfaces_.current_frame()) {
+    surfaces_.ReplaceCurrentFrame(
+        new rtc::scoped_refptr<Texture>(new Texture()));
+    surfaces_.MoveToNextFrame();
+  }
+}
+
+ScreenCapturerWinDirectx::~ScreenCapturerWinDirectx() {}
+
+void ScreenCapturerWinDirectx::Start(Callback* callback) {
+  RTC_DCHECK(!callback_);
+  RTC_DCHECK(callback);
+
+  callback_ = callback;
+}
+
+void ScreenCapturerWinDirectx::SetSharedMemoryFactory(
+    rtc::scoped_ptr<SharedMemoryFactory> shared_memory_factory) {
+  shared_memory_factory_ =
+      rtc::ScopedToUnique(std::move(shared_memory_factory));
+}
+
+bool ScreenCapturerWinDirectx::HandleDetectUpdatedRegionError(
+    const _com_error& error,
+    const char* stage) {
+  if (error.Error() != S_OK) {
+    if (error.Error() == DXGI_ERROR_ACCESS_LOST) {
+      DuplicateOutput();
+    } else {
+      LOG(LS_ERROR) << "Failed to get " << stage << " rectangles, error "
+                    << error.ErrorMessage() << ", code " << error.Error();
+    }
+    // Send entire desktop as we cannot get dirty or move rectangles.
+    return false;
+  }
+
+  return true;
+}
+
+bool ScreenCapturerWinDirectx::DetectUpdatedRegion(
+    const DXGI_OUTDUPL_FRAME_INFO& frame_info,
+    DesktopRegion* updated_region) {
+  RTC_DCHECK(g_container->duplication);
+  RTC_DCHECK(updated_region);
+  updated_region->Clear();
+  if (frame_info.TotalMetadataBufferSize == 0) {
+    // This should not happen, since frame_info.AccumulatedFrames > 0.
+    LOG(LS_ERROR) << "frame_info.AccumulatedFrames > 0, "
+                     "but TotalMetadataBufferSize == 0";
+    return false;
+  }
+
+  if (g_container->metadata.capacity() < frame_info.TotalMetadataBufferSize) {
+    g_container->metadata.clear();  // Avoid data copy
+    g_container->metadata.reserve(frame_info.TotalMetadataBufferSize);
+  }
+
+  UINT buff_size = 0;
+  DXGI_OUTDUPL_MOVE_RECT* move_rects =
+      reinterpret_cast<DXGI_OUTDUPL_MOVE_RECT*>(g_container->metadata.data());
+  size_t move_rects_count = 0;
+  _com_error error = _com_error(g_container->duplication->GetFrameMoveRects(
+      static_cast<UINT>(g_container->metadata.capacity()),
+      move_rects, &buff_size));
+  if (!HandleDetectUpdatedRegionError(error, "move")) {
+    return false;
+  }
+  move_rects_count = buff_size / sizeof(DXGI_OUTDUPL_MOVE_RECT);
+
+  RECT* dirty_rects =
+      reinterpret_cast<RECT*>(g_container->metadata.data() + buff_size);
+  size_t dirty_rects_count = 0;
+  error = _com_error(g_container->duplication->GetFrameDirtyRects(
+      static_cast<UINT>(g_container->metadata.capacity()) - buff_size,
+      dirty_rects, &buff_size));
+  if (!HandleDetectUpdatedRegionError(error, "dirty")) {
+    return false;
+  }
+  dirty_rects_count = buff_size / sizeof(RECT);
+
+  while (move_rects_count > 0) {
+    updated_region->AddRect(DesktopRect::MakeXYWH(
+        move_rects->SourcePoint.x, move_rects->SourcePoint.y,
+        move_rects->DestinationRect.right - move_rects->DestinationRect.left,
+        move_rects->DestinationRect.bottom - move_rects->DestinationRect.top));
+    updated_region->AddRect(DesktopRect::MakeLTRB(
+        move_rects->DestinationRect.left, move_rects->DestinationRect.top,
+        move_rects->DestinationRect.right, move_rects->DestinationRect.bottom));
+    move_rects++;
+    move_rects_count--;
+  }
+
+  while (dirty_rects_count > 0) {
+    updated_region->AddRect(
+        DesktopRect::MakeLTRB(dirty_rects->left, dirty_rects->top,
+                              dirty_rects->right, dirty_rects->bottom));
+    dirty_rects++;
+    dirty_rects_count--;
+  }
+
+  return true;
+}
+
+DesktopFrame* ScreenCapturerWinDirectx::ProcessFrame(
+    const DXGI_OUTDUPL_FRAME_INFO& frame_info,
+    IDXGIResource* resource) {
+  RTC_DCHECK(resource);
+  RTC_DCHECK(frame_info.AccumulatedFrames > 0);
+  // We have something to update, so move to next surface.
+  surfaces_.MoveToNextFrame();
+  RTC_DCHECK(surfaces_.current_frame());
+  DesktopRegion updated_region;
+  if (DetectUpdatedRegion(frame_info, &updated_region)) {
+    if (!surfaces_.current_frame()->get()->CopyFrom(
+          frame_info, resource, &updated_region)) {
+      return nullptr;
+    }
+  } else {
+    if (!surfaces_.current_frame()->get()->CopyFrom(
+          frame_info, resource, nullptr)) {
+      return nullptr;
+    }
+    updated_region.Clear();
+    updated_region.AddRect(
+        DesktopRect::MakeSize(surfaces_.current_frame()->get()->size()));
+  }
+
+  DesktopFrame* result = nullptr;

[Sergey Ulanov, 2016/05/13 19:38:11]

Use std::unique_ptr<> for owned pointers please.

[Hzj_jie, 2016/05/16 18:17:28]

Done.

+  if (shared_memory_factory_) {
+    // When using shared memory, |frames_| is used to store a queue of
+    // SharedMemoryDesktopFrame's.
+    SharedMemoryDesktopFrame* shared_memory_frame = nullptr;
+    if (frames_.current_frame()) {
+      shared_memory_frame = static_cast<SharedMemoryDesktopFrame*>(

[Sergey Ulanov, 2016/05/13 19:38:11]

I don't think you need to upcast the pointer here. Also I don't think you even
need to call GetUnderlyingFrame() here. shared_memory_frame is used below only
to compare size, and the size doesn't change for shared frame.

[Hzj_jie, 2016/05/16 18:17:29]

Not really, the size of surfaces_.current_frame() may change. Refer to line 239,
for each time we acquire an IDXGIResource, the size may change (AFAIK, DirectX
mode change).

[Sergey Ulanov, 2016/05/18 00:50:31]

Yes, the size may change. My point is that you don't need to call
GetUnderlyingFrame() and downcast it to SharedDesktopFrame.
frames_.current_frame()->size() and
frames_.current_frame()->GetUnderlyingFrame()->size() are always the same. Just
remove shared_memory_frame and use frames_.current_frame() below.

[Hzj_jie, 2016/05/18 22:37:33]

I see, done.

+          frames_.current_frame()->GetUnderlyingFrame());
+    }
+    if (!shared_memory_frame ||
+        !shared_memory_frame->size().equals(
+            surfaces_.current_frame()->get()->size())) {
+      // Current frame does not have a same size as last captured surface.
+      unique_ptr<DesktopFrame> new_frame =
+          SharedMemoryDesktopFrame::Create(

[Sergey Ulanov, 2016/05/13 19:38:11]

This line doesn't need to be wrapped - it should fit on the previous line.
clang-format?

[Hzj_jie, 2016/05/16 18:17:28]

Sorry, yes.

+              surfaces_.current_frame()->get()->size(),
+              shared_memory_factory_.get());
+      if (!new_frame) {
+        LOG(LS_ERROR) << "Failed to allocate a new SharedMemoryDesktopFrame";
+        return nullptr;
+      }
+      frames_.ReplaceCurrentFrame(
+          SharedDesktopFrame::Wrap(new_frame.release()));
+    }
+    result = frames_.current_frame()->Share();
+
+    unique_ptr<DesktopFrame> frame(
+        new DxgiDesktopFrame(surfaces_.current_frame()));
+    // Copy data into SharedMemory.
+    for (DesktopRegion::Iterator it(updated_region);
+         !it.IsAtEnd();
+         it.Advance()) {
+      DesktopRect rect = ExpandAndIntersect(it.rect(), result->size());
+      result->CopyPixelsFrom(*frame, rect.top_left(), rect);

[Sergey Ulanov, 2016/05/13 19:38:11]

My comment about copying expanded rects applies here as well.

[Hzj_jie, 2016/05/16 18:17:28]

Updated, though I still expanded the size for 9 pixels.

+    }
+  } else {
+    result = new DxgiDesktopFrame(surfaces_.current_frame());
+  }
+  RTC_DCHECK(result);
+  result->mutable_updated_region()->Swap(&updated_region);
+  return result;
+}
+
+void ScreenCapturerWinDirectx::Capture(const DesktopRegion& region) {
+  RTC_DCHECK(g_container->duplication);
+  RTC_DCHECK(callback_);
+
+  if (!g_container->duplication && !DuplicateOutput()) {
+    // Receive a capture request when application is shutting down, or between
+    // mode change.
+    callback_->OnCaptureCompleted(nullptr);
+    return;
+  }
+
+  TickTime capture_start_time = TickTime::Now();
+
+  if (!SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED)) {
+    if (!set_thread_execution_state_failed_) {
+      set_thread_execution_state_failed_ = true;
+      LOG(LS_WARNING) << "Failed to make system & display power assertion: "
+                      << GetLastError();
+    }
+  }
+
+  DXGI_OUTDUPL_FRAME_INFO frame_info;
+  memset(&frame_info, 0, sizeof(DXGI_OUTDUPL_FRAME_INFO));
+  ComPtr<IDXGIResource> resource;
+  CritScope lock(&g_container->acquire_lock);
+  _com_error error = g_container->duplication->AcquireNextFrame(
+      kAcquireTimeoutMs, &frame_info, resource.GetAddressOf());
+  if (error.Error() == DXGI_ERROR_ACCESS_LOST) {
+    LOG(LS_ERROR) << "Access lost " << error.ErrorMessage();
+    if (DuplicateOutput()) {
+      EmitCurrentFrame();
+    } else {
+      callback_->OnCaptureCompleted(nullptr);
+    }
+    return;
+  }
+
+  if (error.Error() == DXGI_ERROR_WAIT_TIMEOUT) {
+    // Nothing changed.
+    EmitCurrentFrame();
+    return;
+  }
+
+  if (error.Error() != S_OK) {
+    LOG(LS_ERROR) << "Failed to capture frame, error " << error.ErrorMessage()
+                  << ", code " << error.Error();
+    callback_->OnCaptureCompleted(nullptr);
+    return;
+  }
+
+  if (frame_info.AccumulatedFrames == 0) {
+    g_container->duplication->ReleaseFrame();
+    EmitCurrentFrame();
+    return;
+  }
+
+  // Everything looks good so far, build next frame.
+  DesktopFrame* result = ProcessFrame(frame_info, resource.Get());
+  // DetectUpdatedRegion may release last g_container->duplication. But
+  // DuplicateOutput function will always release last frame, so there is no
+  // potential leak.
+  if (g_container->duplication) {
+    g_container->duplication->ReleaseFrame();
+  }
+  if (result) {
+    result->set_capture_time_ms(
+        (TickTime::Now() - capture_start_time).Milliseconds());
+    callback_->OnCaptureCompleted(result);
+  } else {
+    callback_->OnCaptureCompleted(nullptr);
+  }
+}
+
+bool ScreenCapturerWinDirectx::GetScreenList(ScreenList* screens) {
+  return true;
+}
+
+bool ScreenCapturerWinDirectx::SelectScreen(ScreenId id) {
+  // Only full desktop capture is supported.
+  return id == kFullDesktopScreenId;
+}
+
+void ScreenCapturerWinDirectx::EmitCurrentFrame() {
+  if (frames_.current_frame()) {
+    SharedDesktopFrame* frame = frames_.current_frame()->Share();
+    frame->mutable_updated_region()->Clear();
+    callback_->OnCaptureCompleted(frame);
+  } else if (shared_memory_factory_) {
+    // If shared memory is used, upstream components always expect a valid frame
+    // with shared memory are returned. Otherwise the service will crash.
+    static const unique_ptr<SharedDesktopFrame> dummy =
+        unique_ptr<SharedDesktopFrame>(SharedDesktopFrame::Wrap(
+            SharedMemoryDesktopFrame::Create(
+                DesktopSize(100, 100),
+                shared_memory_factory_.get()).release()));
+    RTC_DCHECK(dummy);
+    callback_->OnCaptureCompleted(dummy->Share());
+  } else {
+    callback_->OnCaptureCompleted(nullptr);
+  }
+}
+
+}  // namespace webrtc