Source repositoryconfig.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <bitset>
#include <chrono>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
// local includes
#include "nvenc/nvenc_config.h"
#include "string_hash.h"
 
namespace config {
  using config_map_t = std::unordered_map<std::string, std::string, util::transparent_string_hash, std::equal_to<>>;
 
  namespace nv {
    std::string ffmpeg_preset_from_quality(int quality_preset);
  }  // namespace nv
 
  // Valid range for the packetsize limit
  constexpr int PACKETSIZE_MIN = 200;  
  constexpr int PACKETSIZE_MAX = 65535;  
  constexpr int PACKETSIZE_SMALL = 500;  
  constexpr int PACKETSIZE_LARGE = 1456;  
 
  inline constexpr std::string_view GAMEPAD_DRIVER_ALL = "all";  
  inline constexpr std::string_view GAMEPAD_DRIVER_VIRTUALHID = "virtualhid";  
  inline constexpr std::string_view GAMEPAD_DRIVER_VIGEMBUS = "vigembus";  
  inline constexpr std::string_view GAMEPAD_DRIVER_NONE = "none";  
 
  // track modified config options
  inline config_map_t modified_config_settings;  
 
  // sensitive values that should be redacted from logging
  inline constexpr std::array redacted_config = {
    "csrf_allowed_origins"
  };

  void log_config_settings(const config_map_t &vars, bool save);

  struct video_t {
    // ffmpeg params
    int qp;  // higher == more compression and less quality
 
    int hevc_mode;  
    int av1_mode;  
 
    int min_threads;  
 
    struct {
      std::string sw_preset;  
      std::string sw_tune;  
      std::optional<int> svtav1_preset;  
    } sw;  
 
    nvenc::nvenc_config nv;  
    bool nv_realtime_hags;  
    bool nv_opengl_vulkan_on_dxgi;  
    bool nv_sunshine_high_power_mode;  
 
    struct {
      std::string preset;  
      int multipass;  
      int h264_coder;  
      int spatial_aq;  
      int vbv_percentage_increase;  
    } nv_legacy;  
 
    struct {
      std::optional<int> qsv_preset;  
      std::optional<int> qsv_cavlc;  
      bool qsv_slow_hevc;  
    } qsv;  
 
    struct {
      std::optional<int> amd_usage_h264;  
      std::optional<int> amd_usage_hevc;  
      std::optional<int> amd_usage_av1;  
      std::optional<int> amd_rc_h264;  
      std::optional<int> amd_rc_hevc;  
      std::optional<int> amd_rc_av1;  
      std::optional<int> amd_enforce_hrd;  
      std::optional<int> amd_quality_h264;  
      std::optional<int> amd_quality_hevc;  
      std::optional<int> amd_quality_av1;  
      std::optional<int> amd_preanalysis;  
      std::optional<int> amd_vbaq;  
      std::optional<int> amd_max_au_size;  
      int amd_coder;  
    } amd;  
 
    struct {
      int vt_allow_sw;  
      int vt_require_sw;  
      int vt_realtime;  
      int vt_coder;  
    } vt;  
 
    struct {
      std::optional<int> blbrc;  
      std::optional<int> vaapi_quality;  
      std::optional<int> vaapi_rc;  
      std::string vaapi_rc_str;  
      bool strict_rc_buffer;  
    } vaapi;  
 
    struct {
      int tune;  
      int rc_mode;  
      int quality;  
    } vk;  
 
    std::string capture;  
    bool fp16_sdr_gamma_encoded;  
    std::string encoder;  
    std::string adapter_name;  
    std::string output_name;  

    struct dd_t {
      struct workarounds_t {
        std::chrono::milliseconds hdr_toggle_delay;  
      };

      enum class config_option_e {
        disabled,  
        verify_only,  
        ensure_active,  
        ensure_primary,  
        ensure_only_display  
      };

      enum class resolution_option_e {
        disabled,  
        automatic,  
        manual  
      };

      enum class refresh_rate_option_e {
        disabled,  
        automatic,  
        manual  
      };

      enum class hdr_option_e {
        disabled,  
        automatic  
      };

      struct mode_remapping_entry_t {
        std::string requested_resolution;  
        std::string requested_fps;  
        std::string final_resolution;  
        std::string final_refresh_rate;  
      };

      struct mode_remapping_t {
        std::vector<mode_remapping_entry_t> mixed;  
        std::vector<mode_remapping_entry_t> resolution_only;  
        std::vector<mode_remapping_entry_t> refresh_rate_only;  
      };
 
      config_option_e configuration_option;  
      resolution_option_e resolution_option;  
      std::string manual_resolution;  
      refresh_rate_option_e refresh_rate_option;  
      std::string manual_refresh_rate;  
      hdr_option_e hdr_option;  
      std::chrono::milliseconds config_revert_delay;  
      bool config_revert_on_disconnect;  
      mode_remapping_t mode_remapping;  
      workarounds_t wa;  
    };
 
    dd_t dd;  
 
    int max_bitrate;  
    double minimum_fps_target;  
  };

  struct audio_t {
    std::string sink;  
    std::string virtual_sink;  
    bool stream;  
    bool install_steam_drivers;  
    bool external_audio;  
    std::string format {"opus"};  
    bool high_quality_audio {false};  
  };

  constexpr int ENCRYPTION_MODE_NEVER = 0;  // Never use video encryption, even if the client supports it
  constexpr int ENCRYPTION_MODE_OPPORTUNISTIC = 1;  // Use video encryption if available, but stream without it if not supported
  constexpr int ENCRYPTION_MODE_MANDATORY = 2;  // Always use video encryption and refuse clients that can't encrypt

  struct stream_t {
    std::chrono::milliseconds ping_timeout;  
 
    std::string file_apps;  
 
    int fec_percentage;  
 
    // Video encryption settings for LAN and WAN streams
    int lan_encryption_mode;  
    int wan_encryption_mode;  
 
    // Limit the packetsize to avoid fragmentation on a low MTU link
    int packetsize;  
  };

  struct nvhttp_t {
    // Could be any of the following values:
    // pc|lan|wan
    std::string origin_web_ui_allowed;  
 
    std::string pkey;  
    std::string cert;  
 
    std::string sunshine_name;  
 
    std::string file_state;  
 
    std::string external_ip;  
  };

  struct input_t {
    std::unordered_map<int, int> keybindings;  
 
    std::chrono::milliseconds back_button_timeout;  
    std::chrono::milliseconds key_repeat_delay;  
    std::chrono::duration<double> key_repeat_period;  
 
    std::string gamepad;  
    std::string gamepad_driver;  
    bool ds4_back_as_touchpad_click;  
    bool motion_as_ds4;  
    bool touchpad_as_ds4;  
    bool virtualhid_randomize_mac;  
 
    bool keyboard;  
    bool key_rightalt_to_key_win;  
    bool mouse;  
    bool controller;  
 
    bool always_send_scancodes;  
 
    bool high_resolution_scrolling;  
    bool native_pen_touch;  
  };
 
  namespace flag {
    enum flag_e : std::size_t {
      PIN_STDIN = 0,  
      FRESH_STATE,  
      FORCE_VIDEO_HEADER_REPLACE,  
      UPNP,  
      CONST_PIN,  
      FLAG_SIZE  
    };
  }  // namespace flag

  struct prep_cmd_t {
    prep_cmd_t(std::string &&do_cmd, std::string &&undo_cmd, bool &&elevated):
        do_cmd(std::move(do_cmd)),
        undo_cmd(std::move(undo_cmd)),
        elevated(std::move(elevated)) {
    }

    explicit prep_cmd_t(std::string &&do_cmd, bool &&elevated):
        do_cmd(std::move(do_cmd)),
        elevated(std::move(elevated)) {
    }
 
    std::string do_cmd;  
    std::string undo_cmd;  
    bool elevated;  
  };

  struct sunshine_t {
    std::string locale;  
    int min_log_level;  
    std::bitset<flag::FLAG_SIZE> flags;  
    std::string credentials_file;  
 
    std::string username;  
    std::string password;  
    std::string salt;  
 
    std::string config_file;  

    struct cmd_t {
      std::string name;  
      int argc;  
      char **argv;  
    };
 
    cmd_t cmd;  
 
    std::uint16_t port;  
    std::string address_family;  
    std::string bind_address;  
 
    std::string log_file;  
    bool notify_pre_releases;  
    bool system_tray;  
    std::vector<prep_cmd_t> prep_cmds;  
 
    // List of allowed origins for CSRF protection (e.g., "https://example.com,https://app.example.com")
    // Comma-separated list of additional origins. Default includes localhost variants and web UI port.
    std::vector<std::string> csrf_allowed_origins;  
  };
 
  extern video_t video;
  extern audio_t audio;
  extern stream_t stream;
  extern nvhttp_t nvhttp;
  extern input_t input;
  extern sunshine_t sunshine;
 
#ifdef SUNSHINE_TESTS
  void apply_config_for_test(std::string_view file_content);
#endif

  int parse(int argc, char *argv[]);
  config_map_t parse_config(const std::string_view &file_content);

  bool persist_config_option_if_missing(std::string_view name, std::string_view value);

  bool select_all_gamepad_drivers_if_licensed(bool virtualhid_licensed);
}  // namespace config