Source repositorycommon.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <bitset>
#include <filesystem>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
 
// lib includes
#include <boost/core/noncopyable.hpp>
#ifndef _WIN32
  #include <boost/asio.hpp>
#endif
 
// local includes
#ifndef _WIN32
  #include "src/boost_process_compat.h"
#endif
#include "src/config.h"
#include "src/logging.h"
#include "src/thread_safe.h"
#include "src/utility.h"
#include "src/video_colorspace.h"
 
extern "C" {
#include <moonlight-common-c/src/Limelight.h>
}
 
using namespace std::literals;
 
struct sockaddr;
struct AVFrame;
struct AVBufferRef;
struct AVHWFramesContext;
struct AVCodecContext;
struct AVDictionary;
 
#ifdef _WIN32
struct ID3D11Device;
 
// Forward declarations of boost classes to avoid having to include boost headers
// here, which results in issues with Windows.h and WinSock2.h include order.
namespace boost {
  namespace asio {
    namespace ip {
      class address;
    }  // namespace ip
  }  // namespace asio
 
  namespace filesystem {
    class path;
  }
 
  namespace process::v1 {
    class child;
    class group;
    template<typename Char>
    class basic_environment;
    using environment = basic_environment<char>;
  }  // namespace process::v1
}  // namespace boost
#endif
namespace video {
  struct config_t;
}  // namespace video
 
namespace nvenc {
  class nvenc_encoder;
}
 
namespace platf {
  // Limited by bits in activeGamepadMask
  constexpr auto MAX_GAMEPADS = 16;  
 
  constexpr std::uint32_t DPAD_UP = 0x0001;  
  constexpr std::uint32_t DPAD_DOWN = 0x0002;  
  constexpr std::uint32_t DPAD_LEFT = 0x0004;  
  constexpr std::uint32_t DPAD_RIGHT = 0x0008;  
  constexpr std::uint32_t START = 0x0010;  
  constexpr std::uint32_t BACK = 0x0020;  
  constexpr std::uint32_t LEFT_STICK = 0x0040;  
  constexpr std::uint32_t RIGHT_STICK = 0x0080;  
  constexpr std::uint32_t LEFT_BUTTON = 0x0100;  
  constexpr std::uint32_t RIGHT_BUTTON = 0x0200;  
  constexpr std::uint32_t HOME = 0x0400;  
  constexpr std::uint32_t A = 0x1000;  
  constexpr std::uint32_t B = 0x2000;  
  constexpr std::uint32_t X = 0x4000;  
  constexpr std::uint32_t Y = 0x8000;  
  constexpr std::uint32_t PADDLE1 = 0x010000;  
  constexpr std::uint32_t PADDLE2 = 0x020000;  
  constexpr std::uint32_t PADDLE3 = 0x040000;  
  constexpr std::uint32_t PADDLE4 = 0x080000;  
  constexpr std::uint32_t TOUCHPAD_BUTTON = 0x100000;  
  constexpr std::uint32_t MISC_BUTTON = 0x200000;  

  struct supported_gamepad_t {
    std::string name;  
    bool is_enabled;  
    std::string reason_disabled;  
  };

  enum class gamepad_feedback_e {
    rumble,  
    rumble_triggers,  
    set_motion_event_state,  
    set_rgb_led,  
    set_player_leds,  
    set_adaptive_triggers,  
  };

  struct gamepad_feedback_msg_t {
    static gamepad_feedback_msg_t make_rumble(std::uint16_t id, std::uint16_t lowfreq, std::uint16_t highfreq) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::rumble;
      msg.id = id;
      msg.data.rumble = {lowfreq, highfreq};
      return msg;
    }

    static gamepad_feedback_msg_t make_rumble_triggers(std::uint16_t id, std::uint16_t left, std::uint16_t right) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::rumble_triggers;
      msg.id = id;
      msg.data.rumble_triggers = {left, right};
      return msg;
    }

    static gamepad_feedback_msg_t make_motion_event_state(std::uint16_t id, std::uint8_t motion_type, std::uint16_t report_rate) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::set_motion_event_state;
      msg.id = id;
      msg.data.motion_event_state.motion_type = motion_type;
      msg.data.motion_event_state.report_rate = report_rate;
      return msg;
    }

    static gamepad_feedback_msg_t make_rgb_led(std::uint16_t id, std::uint8_t r, std::uint8_t g, std::uint8_t b) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::set_rgb_led;
      msg.id = id;
      msg.data.rgb_led = {r, g, b};
      return msg;
    }

    static gamepad_feedback_msg_t make_player_leds(std::uint16_t id, std::uint8_t solid, std::uint8_t flashing) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::set_player_leds;
      msg.id = id;
      msg.data.player_leds = {solid, flashing};
      return msg;
    }

    static gamepad_feedback_msg_t make_adaptive_triggers(std::uint16_t id, uint8_t event_flags, uint8_t type_left, uint8_t type_right, const std::array<uint8_t, 10> &left, const std::array<uint8_t, 10> &right) {
      gamepad_feedback_msg_t msg;
      msg.type = gamepad_feedback_e::set_adaptive_triggers;
      msg.id = id;
      msg.data.adaptive_triggers = {.event_flags = event_flags, .type_left = type_left, .type_right = type_right, .left = left, .right = right};
      return msg;
    }
 
    gamepad_feedback_e type;  
    std::uint16_t id;  
 
    union {
      struct {
        std::uint16_t lowfreq;  
        std::uint16_t highfreq;  
      } rumble;  
 
      struct {
        std::uint16_t left_trigger;  
        std::uint16_t right_trigger;  
      } rumble_triggers;  
 
      struct {
        std::uint16_t report_rate;  
        std::uint8_t motion_type;  
      } motion_event_state;  
 
      struct {
        std::uint8_t r;  
        std::uint8_t g;  
        std::uint8_t b;  
      } rgb_led;  
 
      struct {
        std::uint8_t solid;  
        std::uint8_t flashing;  
      } player_leds;  
 
      struct {
        uint8_t event_flags;  
        uint8_t type_left;  
        uint8_t type_right;  
        std::array<uint8_t, 10> left;  
        std::array<uint8_t, 10> right;  
      } adaptive_triggers;  
    } data;  
  };

  using feedback_queue_t = safe::mail_raw_t::queue_t<gamepad_feedback_msg_t>;
 
  namespace speaker {
    enum speaker_e {
      FRONT_LEFT,  
      FRONT_RIGHT,  
      FRONT_CENTER,  
      LOW_FREQUENCY,  
      BACK_LEFT,  
      BACK_RIGHT,  
      SIDE_LEFT,  
      SIDE_RIGHT,  
      MAX_SPEAKERS,  
    };

    constexpr std::array<std::uint8_t, 2> map_stereo {
      FRONT_LEFT,
      FRONT_RIGHT
    };

    constexpr std::array<std::uint8_t, 6> map_surround51 {
      FRONT_LEFT,
      FRONT_RIGHT,
      FRONT_CENTER,
      LOW_FREQUENCY,
      BACK_LEFT,
      BACK_RIGHT,
    };

    constexpr std::array<std::uint8_t, 8> map_surround71 {
      FRONT_LEFT,
      FRONT_RIGHT,
      FRONT_CENTER,
      LOW_FREQUENCY,
      BACK_LEFT,
      BACK_RIGHT,
      SIDE_LEFT,
      SIDE_RIGHT,
    };
  }  // namespace speaker

  enum class mem_type_e {
    system,  
    vaapi,  
    dxgi,  
    cuda,  
    videotoolbox,  
    vulkan,  
    unknown  
  };

  enum class pix_fmt_e {
    yuv420p,  
    yuv420p10,  
    nv12,  
    p010,  
    ayuv,  
    yuv444p16,  
    yuv444p,  
    y410,  
    unknown  
  };

  inline std::string_view from_pix_fmt(pix_fmt_e pix_fmt) {
    using namespace std::literals;
#ifndef DOXYGEN
  #define _CONVERT(x) \
    case pix_fmt_e::x: \
      return #x##sv
#endif
    switch (pix_fmt) {
      _CONVERT(yuv420p);
      _CONVERT(yuv420p10);
      _CONVERT(nv12);
      _CONVERT(p010);
      _CONVERT(ayuv);
      _CONVERT(yuv444p16);
      _CONVERT(yuv444p);
      _CONVERT(y410);
      _CONVERT(unknown);
    }
#undef _CONVERT
 
    return "unknown"sv;
  }
 
  // Dimensions for touchscreen input
  struct touch_port_t {
    int offset_x;  
    int offset_y;  
    int width;  
    int height;  
    int logical_width;  
    int logical_height;  
    int env_offset_x {};  
    int env_offset_y {};  
  };
 
  // These values must match Limelight-internal.h's SS_FF_* constants!
  namespace platform_caps {
    using caps_t = uint32_t;

    constexpr caps_t pen_touch = 0x01;  // Pen and touch events
    constexpr caps_t controller_touch = 0x02;  // Controller touch and motion events
  };  // namespace platform_caps

  struct gamepad_state_t {
    std::uint32_t buttonFlags;  
    std::uint8_t lt;  
    std::uint8_t rt;  
    std::int16_t lsX;  
    std::int16_t lsY;  
    std::int16_t rsX;  
    std::int16_t rsY;  
  };

  struct gamepad_id_t {
    // The global index is used when looking up gamepads in the platform's
    // gamepad array. It identifies gamepads uniquely among all clients.
    int globalIndex;  
 
    // The client-relative index is the controller number as reported by the
    // client. It must be used when communicating back to the client via
    // the input feedback queue.
    std::uint8_t clientRelativeIndex;  
  };

  struct gamepad_arrival_t {
    std::uint8_t type;  
    std::uint16_t capabilities;  
    std::uint32_t supportedButtons;  
  };

  struct gamepad_touch_t {
    gamepad_id_t id;  
    std::uint8_t eventType;  
    std::uint32_t pointerId;  
    float x;  
    float y;  
    float pressure;  
  };

  struct gamepad_motion_t {
    gamepad_id_t id;  
    std::uint8_t motionType;  
 
    // Accel: m/s^2
    // Gyro: deg/s
    float x;  
    float y;  
    float z;  
  };

  struct gamepad_battery_t {
    gamepad_id_t id;  
    std::uint8_t state;  
    std::uint8_t percentage;  
  };

  struct touch_input_t {
    std::uint8_t eventType;  
    std::uint16_t rotation;  
    std::uint32_t pointerId;  
    float x;  
    float y;  
    float pressureOrDistance;  
    float contactAreaMajor;  
    float contactAreaMinor;  
  };

  struct pen_input_t {
    std::uint8_t eventType;  
    std::uint8_t toolType;  
    std::uint8_t penButtons;  
    std::uint8_t tilt;  
    std::uint16_t rotation;  
    float x;  
    float y;  
    float pressureOrDistance;  
    float contactAreaMajor;  
    float contactAreaMinor;  
  };

  class deinit_t {
  public:
    virtual ~deinit_t() = default;
  };

  struct img_t: std::enable_shared_from_this<img_t> {
  public:
    img_t() = default;
 
    img_t(img_t &&) = delete;
    img_t(const img_t &) = delete;
    img_t &operator=(img_t &&) = delete;
    img_t &operator=(const img_t &) = delete;
 
    std::uint8_t *data {};  
    std::int32_t width {};  
    std::int32_t height {};  
    std::int32_t pixel_pitch {};  
    std::int32_t row_pitch {};  
 
    std::optional<std::chrono::steady_clock::time_point> frame_timestamp;  

    virtual ~img_t() = default;
  };

  struct sink_t {
    // Play on host PC
    std::string host;  
 
    // On macOS and Windows, it is not possible to create a virtual sink
    // Therefore, it is optional
    struct null_t {
      std::string stereo;  
      std::string surround51;  
      std::string surround71;  
    };
 
    std::optional<null_t> null;  
  };

  struct encode_device_t {
    virtual ~encode_device_t() = default;

    virtual int convert(platf::img_t &img) = 0;
 
    video::sunshine_colorspace_t colorspace;  
  };

  struct avcodec_encode_device_t: encode_device_t {
    bool hardware = false;  
    using init_hw_device_fn_t = int (*)(avcodec_encode_device_t *encode_device, AVBufferRef **hw_device_buf);
    init_hw_device_fn_t init_hw_device = nullptr;  
#ifdef _WIN32
    ID3D11Device *d3d11_device = nullptr;  
#endif
    AVFrame *frame {};  

    int convert(platf::img_t &img) override {
      return -1;
    }

    virtual void apply_colorspace() {
    }

    virtual int set_frame(AVFrame *new_frame, AVBufferRef *hw_frames_ctx) {
      BOOST_LOG(error) << "Illegal call to hwdevice_t::set_frame(). Did you forget to override it?";
      return -1;
    };

    virtual void init_hwframes(AVHWFramesContext *frames) {};

    virtual void init_codec_options(AVCodecContext *ctx, AVDictionary **options) {};

    virtual int prepare_to_derive_context(int hw_device_type) {
      return 0;
    };
  };

  struct nvenc_encode_device_t: encode_device_t {
    virtual bool init_encoder(const video::config_t &client_config, const video::sunshine_colorspace_t &colorspace) = 0;
 
    nvenc::nvenc_encoder *nvenc = nullptr;  
  };

  enum class capture_e : int {
    ok,  
    reinit,  
    timeout,  
    interrupted,  
    capture_error  
  };

  class display_t {
  public:
    using push_captured_image_cb_t = std::function<bool(std::shared_ptr<img_t> &&img, bool frame_captured)>;

    using pull_free_image_cb_t = std::function<bool(std::shared_ptr<img_t> &img_out)>;
 
    display_t() noexcept = default;

    virtual capture_e capture(const push_captured_image_cb_t &push_captured_image_cb, const pull_free_image_cb_t &pull_free_image_cb, bool *cursor) = 0;

    virtual std::shared_ptr<img_t> alloc_img() = 0;

    virtual int dummy_img(img_t *img) = 0;

    virtual std::unique_ptr<avcodec_encode_device_t> make_avcodec_encode_device(pix_fmt_e pix_fmt) {
      return nullptr;
    }

    virtual std::unique_ptr<nvenc_encode_device_t> make_nvenc_encode_device(pix_fmt_e pix_fmt) {
      return nullptr;
    }

    virtual bool is_hdr() {
      return false;
    }

    virtual bool get_hdr_metadata(SS_HDR_METADATA &metadata) {
      std::memset(&metadata, 0, sizeof(metadata));
      return false;
    }

    virtual bool is_codec_supported(std::string_view name, const ::video::config_t &config) {
      return true;
    }
 
    virtual ~display_t() = default;
 
    // Offsets for when streaming a specific monitor. By default, they are 0.
    int offset_x {0};  
    int offset_y {0};  
    int env_offset_x {0};  
    int env_offset_y {0};  
    int env_width {0};  
    int env_height {0};  
    int env_logical_width {0};  
    int env_logical_height {0};  
    int width {0};  
    int height {0};  
    int logical_width {0};  
    int logical_height {0};  
 
  protected:
    // collect capture timing data (at loglevel debug)
    logging::time_delta_periodic_logger sleep_overshoot_logger = {debug, "Frame capture sleep overshoot"};  
  };

  class mic_t {
  public:
    virtual capture_e sample(std::vector<float> &frame_buffer) = 0;
 
    virtual ~mic_t() = default;
  };

  class audio_control_t {
  public:
    virtual int set_sink(const std::string &sink) = 0;

    virtual std::unique_ptr<mic_t> microphone(const std::uint8_t *mapping, int channels, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous, [[maybe_unused]] bool host_audio_enabled) = 0;

    virtual bool is_sink_available(const std::string &sink) = 0;

    virtual std::optional<sink_t> sink_info() = 0;

    virtual ~audio_control_t() = default;
  };

  struct input_raw_t;

  void freeInput(input_raw_t *input);

  using input_t = util::safe_ptr<input_raw_t, &freeInput>;
 
  std::filesystem::path appdata();
 
  std::filesystem::path get_xdg_restore_token_path();  

  std::string get_mac_address(const std::string_view &address);

  std::string from_sockaddr(const sockaddr *const);
  std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const);

  std::unique_ptr<audio_control_t> audio_control();

  std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);
 
  // A list of names of displays accepted as display_name with the mem_type_e
  std::vector<std::string> display_names(mem_type_e hwdevice_type);

  bool needs_encoder_reenumeration();

  boost::process::v1::child run_command(bool elevated, bool interactive, const std::string &cmd, boost::filesystem::path &working_dir, const boost::process::v1::environment &env, FILE *file, std::error_code &ec, boost::process::v1::group *group);

  enum class thread_priority_e : int {
    low,  
    normal,  
    high,  
    critical  
  };

  void adjust_thread_priority(thread_priority_e priority);

  void set_thread_name(std::string_view name);
 
  void enable_mouse_keys();
 
  // Allow OS-specific actions to be taken to prepare for streaming
  void streaming_will_start();
  void streaming_will_stop();
 
  void restart();

  struct buffer_descriptor_t {
    const char *buffer;  
    size_t size;  
 
    // Constructors required for emplace_back() prior to C++20
    buffer_descriptor_t(const char *buffer, size_t size):
        buffer(buffer),
        size(size) {
    }
 
    buffer_descriptor_t():
        buffer(nullptr),
        size(0) {
    }
  };

  struct batched_send_info_t {
    // Optional headers to be prepended to each packet
    const char *headers;  
    size_t header_size;  
 
    // One or more data buffers to use for the payloads
    //
    // NB: Data buffers must be aligned to payload size!
    std::vector<buffer_descriptor_t> &payload_buffers;  
    size_t payload_size;  
 
    // The offset (in header+payload message blocks) in the header and payload
    // buffers to begin sending messages from
    size_t block_offset;  
 
    // The number of header+payload message blocks to send
    size_t block_count;  
 
    std::uintptr_t native_socket;  
    boost::asio::ip::address &target_address;  
    uint16_t target_port;  
    boost::asio::ip::address &source_address;  

    buffer_descriptor_t buffer_for_payload_offset(ptrdiff_t offset) const {
      for (const auto &desc : payload_buffers) {
        if (offset < desc.size) {
          return {
            desc.buffer + offset,
            desc.size - offset,
          };
        } else {
          offset -= desc.size;
        }
      }
      return {};
    }
  };

  bool send_batch(const batched_send_info_t &send_info);

  struct send_info_t {
    const char *header;  
    size_t header_size;  
    const char *payload;  
    size_t payload_size;  
 
    std::uintptr_t native_socket;  
    boost::asio::ip::address &target_address;  
    uint16_t target_port;  
    boost::asio::ip::address &source_address;  
  };

  bool send(send_info_t &send_info);

  enum class qos_data_type_e : int {
    audio,  
    video  
  };

  std::unique_ptr<deinit_t> enable_socket_qos(uintptr_t native_socket, boost::asio::ip::address &address, uint16_t port, qos_data_type_e data_type, bool dscp_tagging);

  void open_url(const std::string &url);

  bool request_process_group_exit(std::uintptr_t native_handle);

  bool process_group_running(std::uintptr_t native_handle);

  input_t input();
  std::optional<util::point_t> get_mouse_loc(input_t &input);
  void move_mouse(input_t &input, int deltaX, int deltaY);
  void move_mouse(input_t &input, const touch_port_t &touch_port, int deltaX, int deltaY);
  void abs_mouse(input_t &input, const touch_port_t &touch_port, float x, float y);
  void button_mouse(input_t &input, int button, bool release);
  void scroll(input_t &input, int distance);
  void hscroll(input_t &input, int distance);
  void keyboard_update(input_t &input, uint16_t modcode, bool release, uint8_t flags, bool extended = false);
  void gamepad_update(input_t &input, int nr, const gamepad_state_t &gamepad_state);
  void unicode(input_t &input, const char *utf8, int size);

  using client_input_t = deinit_t;

  std::unique_ptr<client_input_t> allocate_client_input_context(input_t &input);

  void touch_update(client_input_t *input, const touch_port_t &touch_port, const touch_input_t &touch);

  void pen_update(client_input_t *input, const touch_port_t &touch_port, const pen_input_t &pen);

  void gamepad_touch(input_t &input, const gamepad_touch_t &touch);

  void gamepad_motion(input_t &input, const gamepad_motion_t &motion);

  void gamepad_battery(input_t &input, const gamepad_battery_t &battery);

  int alloc_gamepad(input_t &input, const gamepad_id_t &id, const gamepad_arrival_t &metadata, feedback_queue_t feedback_queue);
  int rebind_gamepad(input_t &input, const gamepad_id_t &id, feedback_queue_t feedback_queue);
  void free_gamepad(input_t &input, int nr);

  platform_caps::caps_t get_capabilities();
 
  constexpr auto SERVICE_NAME = "Sunshine";  
  constexpr auto SERVICE_TYPE = "_nvstream._tcp";  
 
  namespace publish {
    [[nodiscard]] std::unique_ptr<deinit_t> start();
  }

  [[nodiscard]] std::unique_ptr<deinit_t> init();

  std::string get_host_name();

  std::string resolve_render_device();

  std::vector<supported_gamepad_t> &supported_gamepads(input_t *input);

  struct high_precision_timer: private boost::noncopyable {
    virtual ~high_precision_timer() = default;

    virtual void sleep_for(const std::chrono::nanoseconds &duration) = 0;

    virtual explicit operator bool() = 0;
  };

  std::unique_ptr<high_precision_timer> create_high_precision_timer();

  bool has_elevated_privileges(bool all_caps);

  void drop_elevated_privileges(bool all_caps);
 
}  // namespace platf