Source repositorywayland.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <array>
#include <bitset>
#include <chrono>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#ifdef SUNSHINE_BUILD_WAYLAND
  #include <linux-dmabuf-unstable-v1.h>
  #include <wlr-screencopy-unstable-v1.h>
  #include <xdg-output-unstable-v1.h>
#endif
 
// local includes
#include "graphics.h"

#ifdef SUNSHINE_BUILD_WAYLAND
 
struct gbm_bo;
struct gbm_device;
 
namespace wl {
  bool use_vram_capture(platf::mem_type_e hwdevice_type);

  bool use_damage_capture(std::uint32_t screencopy_version, double stream_fps, std::int32_t refresh_mhz);

  std::chrono::steady_clock::time_point next_damage_request(
    std::chrono::steady_clock::time_point next_request,
    std::chrono::steady_clock::time_point frame_time,
    std::chrono::nanoseconds delay
  );

  std::chrono::steady_clock::time_point damage_frame_time(
    std::optional<std::chrono::steady_clock::time_point> compositor_time,
    std::chrono::steady_clock::time_point now,
    std::chrono::nanoseconds delay
  );

  enum class screencopy_request_e {
    keep,  
    copy,  
    copy_with_damage,  
  };

  screencopy_request_e next_screencopy_request(bool pending, bool requested_cursor, bool cursor, bool event_driven, bool have_frame);

  bool should_wait_for_damage_request(
    std::chrono::steady_clock::time_point next_request,
    std::chrono::steady_clock::time_point now,
    std::chrono::nanoseconds delay
  );

  std::map<std::uint32_t, std::vector<std::uint64_t>> intersect_modifiers(
    const std::map<std::uint32_t, std::vector<std::uint64_t>> &compositor_modifiers,
    const std::map<std::uint32_t, std::vector<std::uint64_t>> &encoder_modifiers
  );

  using display_internal_t = util::safe_ptr<wl_display, wl_display_disconnect>;

  struct gbm_bo_accessors_t {
    int (*get_plane_count)(gbm_bo *bo);  
    int (*get_fd_for_plane)(gbm_bo *bo, int plane);  
    std::uint32_t (*get_stride_for_plane)(gbm_bo *bo, int plane);  
    std::uint32_t (*get_offset)(gbm_bo *bo, int plane);  
    std::uint64_t (*get_modifier)(gbm_bo *bo);  
  };

  struct gbm_device_accessors_t {
    int (*open_render_node)(const char *path);  
    gbm_device *(*create_device)(int fd);  
    void (*destroy_device)(gbm_device *device);  
  };

  class gbm_device_t {
  public:
    gbm_device_t() = default;

    gbm_device_t(const gbm_device_t &) = delete;

    gbm_device_t &operator=(const gbm_device_t &) = delete;

    ~gbm_device_t();

    bool init(const std::string &render_path, const gbm_device_accessors_t &accessors);

    void reset();

    gbm_device *get() const {
      return device;
    }

    int fd() const {
      return drm_fd;
    }

    explicit operator bool() const {
      return device != nullptr;
    }
 
  private:
    gbm_device_accessors_t accessors {};  
    int drm_fd {-1};  
    gbm_device *device {nullptr};  
  };

  class frame_t {
  public:
    frame_t();
    void destroy();
 
    egl::surface_descriptor_t sd;  
    std::optional<std::chrono::steady_clock::time_point> frame_timestamp;  
  };

  std::optional<std::uint32_t> export_gbm_bo_planes(gbm_bo *bo, frame_t &frame, const gbm_bo_accessors_t &accessors);

  class dmabuf_t {
  public:
    enum status_e {
      WAITING,  
      READY,  
      REINIT,  
    };
 
    dmabuf_t();
    ~dmabuf_t();
 
    dmabuf_t(dmabuf_t &&) = delete;
    dmabuf_t(const dmabuf_t &) = delete;
    dmabuf_t &operator=(const dmabuf_t &) = delete;
    dmabuf_t &operator=(dmabuf_t &&) = delete;

    void listen(zwlr_screencopy_manager_v1 *screencopy_manager, zwp_linux_dmabuf_v1 *dmabuf_interface, const std::map<std::uint32_t, std::vector<std::uint64_t>> *supported_modifiers, wl_output *output, bool blend_cursor = false, const std::map<std::uint32_t, std::vector<std::uint64_t>> *encoder_modifiers = nullptr);
    static void buffer_params_created(void *data, struct zwp_linux_buffer_params_v1 *params, struct wl_buffer *wl_buffer);
    static void buffer_params_failed(void *data, struct zwp_linux_buffer_params_v1 *params);
    void buffer(zwlr_screencopy_frame_v1 *frame, std::uint32_t format, std::uint32_t width, std::uint32_t height, std::uint32_t stride);
    void linux_dmabuf(zwlr_screencopy_frame_v1 *frame, std::uint32_t format, std::uint32_t width, std::uint32_t height);
    void buffer_done(zwlr_screencopy_frame_v1 *frame);
    void flags(zwlr_screencopy_frame_v1 *frame, std::uint32_t flags);
    void damage(zwlr_screencopy_frame_v1 *frame, std::uint32_t x, std::uint32_t y, std::uint32_t width, std::uint32_t height);
    void ready(zwlr_screencopy_frame_v1 *frame, std::uint32_t tv_sec_hi, std::uint32_t tv_sec_lo, std::uint32_t tv_nsec);
    void failed(zwlr_screencopy_frame_v1 *frame);

    bool cancel();

    frame_t *get_next_frame() {
      return current_frame == &frames[0] ? &frames[1] : &frames[0];
    }
 
    status_e status {READY};  
    bool with_damage {false};  
    std::array<frame_t, 2> frames {};  
    frame_t *current_frame;  
    zwlr_screencopy_frame_v1_listener listener;  
 
  private:
    bool init_gbm();
    void cleanup_gbm();
    void create_and_copy_dmabuf(zwlr_screencopy_frame_v1 *frame);
 
    zwp_linux_dmabuf_v1 *dmabuf_interface {nullptr};
    const std::map<std::uint32_t, std::vector<std::uint64_t>> *supported_modifiers {nullptr};
    const std::map<std::uint32_t, std::vector<std::uint64_t>> *encoder_modifiers {nullptr};  
 
    struct {
      bool supported {false};
      std::uint32_t format;
      std::uint32_t width;
      std::uint32_t height;
      std::uint32_t stride;
    } shm_info;
 
    struct {
      bool supported {false};
      std::uint32_t format;
      std::uint32_t width;
      std::uint32_t height;
    } dmabuf_info;
 
    gbm_device_t gbm;  
    struct gbm_bo *current_bo {nullptr};
    struct wl_buffer *current_wl_buffer {nullptr};
    zwlr_screencopy_frame_v1 *pending_copy {nullptr};  
    bool y_invert {false};
  };

  class monitor_t {
  public:
    explicit monitor_t(wl_output *output);
 
    monitor_t(monitor_t &&) = delete;
    monitor_t(const monitor_t &) = delete;
    monitor_t &operator=(const monitor_t &) = delete;
    monitor_t &operator=(monitor_t &&) = delete;

    void listen(zxdg_output_manager_v1 *output_manager);
    void xdg_name(zxdg_output_v1 *, const char *name);
    void xdg_description(zxdg_output_v1 *, const char *description);
    void xdg_position(zxdg_output_v1 *, std::int32_t x, std::int32_t y);
    void xdg_size(zxdg_output_v1 *, std::int32_t width, std::int32_t height);

    void xdg_done(zxdg_output_v1 *) {}

    void wl_geometry(wl_output *, std::int32_t, std::int32_t, std::int32_t, std::int32_t, std::int32_t, const char *, const char *, std::int32_t) {
      // Logical placement comes from xdg-output, so physical geometry has nothing to update.
    }

    void wl_mode(wl_output *wl_output, std::uint32_t flags, std::int32_t width, std::int32_t height, std::int32_t refresh);

    void wl_done(wl_output *) {
      // Metadata is stored as each event arrives; completion requires no additional work.
    }

    void wl_scale(wl_output *, std::int32_t) {
      // Pixel mode and xdg-output logical size already describe the capture and input coordinate spaces.
    }
 
    wl_output *output;  
    std::string name;  
    std::string description;  
    platf::touch_port_t viewport;  
    std::int32_t refresh_mhz {0};  
    wl_output_listener wl_listener;  
    zxdg_output_v1_listener xdg_listener;  
  };

  class interface_t {
    struct bind_t {
      std::uint32_t id;
      std::uint32_t version;
    };
 
  public:
    enum interface_e {
      XDG_OUTPUT,  
      WLR_EXPORT_DMABUF,  
      LINUX_DMABUF,  
      MAX_INTERFACES,  
    };
 
    interface_t() noexcept;
 
    interface_t(interface_t &&) = delete;
    interface_t(const interface_t &) = delete;
    interface_t &operator=(const interface_t &) = delete;
    interface_t &operator=(interface_t &&) = delete;

    void listen(wl_registry *registry);

    bool operator[](interface_e bit) const {
      return interface[bit];
    }

    void dmabuf_format(zwp_linux_dmabuf_v1 *zwp_linux_dmabuf, uint32_t format);
    void dmabuf_modifier(zwp_linux_dmabuf_v1 *zwp_linux_dmabuf, uint32_t format, uint32_t modifier_hi, uint32_t modifier_lo);
 
    std::vector<std::unique_ptr<monitor_t>> monitors;  
    std::map<std::uint32_t, std::vector<std::uint64_t>> supported_modifiers;  
    zwlr_screencopy_manager_v1 *screencopy_manager {nullptr};  
    std::uint32_t screencopy_version {0};  
    zwp_linux_dmabuf_v1 *dmabuf_interface {nullptr};  
    zxdg_output_manager_v1 *output_manager {nullptr};  
 
  private:
    void add_interface(wl_registry *registry, std::uint32_t id, const char *interface, std::uint32_t version);
    void del_interface(wl_registry *registry, uint32_t id);
 
    std::bitset<MAX_INTERFACES> interface;
    wl_registry_listener listener;
    zwp_linux_dmabuf_v1_listener dmabuf_listener;
  };

  class display_t {
  public:
    int init(const char *display_name = nullptr);
 
    // Roundtrip with Wayland connection
    void roundtrip();
 
    // Wait up to the timeout to read and dispatch new events
    bool dispatch(std::chrono::milliseconds timeout);

    wl_registry *registry();

    inline display_internal_t::pointer get() {
      return display_internal.get();
    }
 
  private:
    display_internal_t display_internal;
  };

  std::vector<std::unique_ptr<monitor_t>> monitors(const char *display_name = nullptr);
  int init();
}  // namespace wl
#else
 
struct wl_output;
struct zxdg_output_manager_v1;
 
namespace wl {
  class monitor_t {
  public:
    monitor_t(wl_output *output);
 
    monitor_t(monitor_t &&) = delete;
    monitor_t(const monitor_t &) = delete;
    monitor_t &operator=(const monitor_t &) = delete;
    monitor_t &operator=(monitor_t &&) = delete;
 
    void listen(zxdg_output_manager_v1 *output_manager);
 
    wl_output *output;
    std::string name;
    std::string description;
    platf::touch_port_t viewport;
  };
 
  inline std::vector<std::unique_ptr<monitor_t>> monitors(const char *display_name = nullptr) {
    return {};
  }
 
  inline int init() {
    return -1;
  }
}  // namespace wl
#endif