138 lines
4.9 KiB
C++
138 lines
4.9 KiB
C++
/*
|
|
* Copyright (c) 2020 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.
|
|
*/
|
|
|
|
#ifndef MODULES_DESKTOP_CAPTURE_WIN_WGC_CAPTURE_SESSION_H_
|
|
#define MODULES_DESKTOP_CAPTURE_WIN_WGC_CAPTURE_SESSION_H_
|
|
|
|
#include <d3d11.h>
|
|
#include <windows.graphics.capture.h>
|
|
#include <windows.graphics.h>
|
|
#include <wrl/client.h>
|
|
|
|
#include <memory>
|
|
|
|
#include "api/sequence_checker.h"
|
|
#include "modules/desktop_capture/desktop_capture_options.h"
|
|
#include "modules/desktop_capture/win/wgc_capture_source.h"
|
|
#include "rtc_base/event.h"
|
|
|
|
namespace webrtc {
|
|
|
|
class WgcCaptureSession final {
|
|
public:
|
|
WgcCaptureSession(
|
|
Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device,
|
|
Microsoft::WRL::ComPtr<
|
|
ABI::Windows::Graphics::Capture::IGraphicsCaptureItem> item,
|
|
ABI::Windows::Graphics::SizeInt32 size);
|
|
|
|
// Disallow copy and assign.
|
|
WgcCaptureSession(const WgcCaptureSession&) = delete;
|
|
WgcCaptureSession& operator=(const WgcCaptureSession&) = delete;
|
|
|
|
~WgcCaptureSession();
|
|
|
|
HRESULT StartCapture(const DesktopCaptureOptions& options);
|
|
|
|
// Returns a frame from the frame pool, if any are present.
|
|
HRESULT GetFrame(std::unique_ptr<DesktopFrame>* output_frame);
|
|
|
|
bool IsCaptureStarted() const {
|
|
RTC_DCHECK_RUN_ON(&sequence_checker_);
|
|
return is_capture_started_;
|
|
}
|
|
|
|
// We keep 2 buffers in the frame pool to balance the staleness of the frame
|
|
// with having to wait for frames to arrive too frequently. Too many buffers
|
|
// will lead to a high latency, and too few will lead to poor performance.
|
|
// We make this public for tests.
|
|
static constexpr int kNumBuffers = 2;
|
|
|
|
private:
|
|
// Initializes `mapped_texture_` with the properties of the `src_texture`,
|
|
// overrides the values of some necessary properties like the
|
|
// D3D11_CPU_ACCESS_READ flag. Also has optional parameters for what size
|
|
// `mapped_texture_` should be, if they aren't provided we will use the size
|
|
// of `src_texture`.
|
|
HRESULT CreateMappedTexture(
|
|
Microsoft::WRL::ComPtr<ID3D11Texture2D> src_texture,
|
|
UINT width = 0,
|
|
UINT height = 0);
|
|
|
|
// Event handler for `item_`'s Closed event.
|
|
HRESULT OnItemClosed(
|
|
ABI::Windows::Graphics::Capture::IGraphicsCaptureItem* sender,
|
|
IInspectable* event_args);
|
|
|
|
// Event handler for `frame_pool_`'s FrameArrived event.
|
|
HRESULT OnFrameArrived(
|
|
ABI::Windows::Graphics::Capture::IDirect3D11CaptureFramePool* sender,
|
|
IInspectable* event_args);
|
|
|
|
void RemoveEventHandlers();
|
|
|
|
// We wait on this event in `GetFrame` if there are no frames in the pool.
|
|
// `OnFrameArrived` will set the event so we can proceed.
|
|
rtc::Event wait_for_frame_event_;
|
|
int frames_in_pool_;
|
|
|
|
// We're willing to wait for a frame a little longer if it's the first one.
|
|
bool first_frame_ = true;
|
|
|
|
std::unique_ptr<EventRegistrationToken> frame_arrived_token_;
|
|
std::unique_ptr<EventRegistrationToken> item_closed_token_;
|
|
|
|
// A Direct3D11 Device provided by the caller. We use this to create an
|
|
// IDirect3DDevice, and also to create textures that will hold the image data.
|
|
Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device_;
|
|
|
|
// This item represents what we are capturing, we use it to create the
|
|
// capture session, and also to listen for the Closed event.
|
|
Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Capture::IGraphicsCaptureItem>
|
|
item_;
|
|
|
|
// The IDirect3DDevice is necessary to instantiate the frame pool.
|
|
Microsoft::WRL::ComPtr<
|
|
ABI::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice>
|
|
direct3d_device_;
|
|
|
|
// The frame pool is where frames are deposited during capture, we retrieve
|
|
// them from here with TryGetNextFrame().
|
|
Microsoft::WRL::ComPtr<
|
|
ABI::Windows::Graphics::Capture::IDirect3D11CaptureFramePool>
|
|
frame_pool_;
|
|
|
|
// This texture holds the final image data. We made it a member so we can
|
|
// reuse it, instead of having to create a new texture every time we grab a
|
|
// frame.
|
|
Microsoft::WRL::ComPtr<ID3D11Texture2D> mapped_texture_;
|
|
|
|
// This is the size of `mapped_texture_` and the buffers in `frame_pool_`. We
|
|
// store this as a member so we can compare it to the size of incoming frames
|
|
// and resize if necessary.
|
|
ABI::Windows::Graphics::SizeInt32 size_;
|
|
|
|
// The capture session lets us set properties about the capture before it
|
|
// starts such as whether to capture the mouse cursor, and it lets us tell WGC
|
|
// to start capturing frames.
|
|
Microsoft::WRL::ComPtr<
|
|
ABI::Windows::Graphics::Capture::IGraphicsCaptureSession>
|
|
session_;
|
|
|
|
bool item_closed_ = false;
|
|
bool is_capture_started_ = false;
|
|
|
|
SequenceChecker sequence_checker_;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // MODULES_DESKTOP_CAPTURE_WIN_WGC_CAPTURE_SESSION_H_
|