WindowCaptureBackend.hpp

#pragma once
#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace Gfx::WindowCapture
{
 
enum class CaptureMode : int
{
  Window = 0,
  AllScreens = 1,
  SingleScreen = 2,
  Region = 3
};
 
struct CapturedFrame
{
  enum Type
  {
    None,
    CPU_RGBA,
    CPU_BGRA,
    D3D11_Texture,
    IOSurface_Ref,
    DMA_BUF_FD
  };
  Type type{None};
 
  // CPU path
  const uint8_t* data{};
  int stride{};
 
  // GPU path: D3D11 ID3D11Texture2D*, or IOSurfaceRef
  void* nativeHandle{};
 
  // PipeWire DMA-BUF path. When ownsDmabufFd is set, dmabufFd is a dup
  // handed to the consumer, which must close it after import.
  int dmabufFd{-1};
  bool ownsDmabufFd{false};
  uint32_t drmFormat{};
  uint64_t drmModifier{};
  int dmabufStride{};
  int dmabufOffset{};
 
  int width{};
  int height{};
};
 
struct CapturableWindow
{
  std::string title;
  uint64_t id{};
};
 
struct CapturableScreen
{
  std::string name;
  uint64_t id{};
  int x{}, y{}, width{}, height{};
};
 
struct CaptureTarget
{
  CaptureMode mode{CaptureMode::Window};
  uint64_t windowId{};
  uint64_t screenId{};
  int regionX{}, regionY{}, regionW{}, regionH{};
};
 
inline uint64_t resolveWindowId(
    const std::vector<CapturableWindow>& windows, uint64_t id, std::string_view title)
{
  if(id != 0 && std::ranges::any_of(windows, [=](auto& w) { return w.id == id; }))
    return id;
  if(title.empty())
    return id;
  for(auto& w : windows)
    if(w.title == title)
      return w.id;
  for(auto& w : windows)
    if(w.title.find(title) != std::string::npos)
      return w.id;
  return id;
}
 
inline uint64_t resolveScreenId(
    const std::vector<CapturableScreen>& screens, uint64_t id, std::string_view name)
{
  if(id != 0 && std::ranges::any_of(screens, [=](auto& s) { return s.id == id; }))
    return id;
  if(name.empty())
    return id;
  for(auto& s : screens)
    if(s.name == name)
      return s.id;
  for(auto& s : screens)
    if(s.name.find(name) != std::string::npos)
      return s.id;
  return id;
}
 
struct WindowCaptureBackend
{
  virtual ~WindowCaptureBackend() = default;
  virtual bool available() const = 0;
  virtual bool supportsMode(CaptureMode mode) const = 0;
  virtual std::vector<CapturableWindow> enumerate() = 0;
  virtual std::vector<CapturableScreen> enumerateScreens() = 0;
  virtual bool start(const CaptureTarget& target) = 0;
  virtual void stop() = 0;
  virtual CapturedFrame grab() = 0;
};
 
// Returns the appropriate backend for the current platform and session type.
std::unique_ptr<WindowCaptureBackend> createWindowCaptureBackend();
 
}