Merge remote-tracking branch 'origin/master'

cmake/dependencies/common.cmake

@@ -30,7 +30,7 @@ if(NOT DEFINED FFMPEG_PREPARED_BINARIES)
         set(FFMPEG_PLATFORM_LIBRARIES numa va va-drm va-x11 X11)
     endif()
     set(FFMPEG_PREPARED_BINARIES
-            "${CMAKE_SOURCE_DIR}/third-party/build-deps/ffmpeg/${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+            "${CMAKE_SOURCE_DIR}/third-party/build-deps/dist/${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
 
     # check if the directory exists
     if(NOT EXISTS "${FFMPEG_PREPARED_BINARIES}")

cmake/targets/common.cmake

@@ -113,9 +113,15 @@ set_source_files_properties("${CMAKE_SOURCE_DIR}/third-party/ViGEmClient/src/ViG
 string(TOUPPER "x${CMAKE_BUILD_TYPE}" BUILD_TYPE)
 if("${BUILD_TYPE}" STREQUAL "XDEBUG")
     if(WIN32)
-        set_source_files_properties("${CMAKE_SOURCE_DIR}/src/nvhttp.cpp"
+        if (NOT BUILD_TESTS)
-                DIRECTORY "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests"
+            set_source_files_properties("${CMAKE_SOURCE_DIR}/src/nvhttp.cpp"
-                PROPERTIES COMPILE_FLAGS -O2)
+                    DIRECTORY "${CMAKE_SOURCE_DIR}"
+                    PROPERTIES COMPILE_FLAGS -O2)
+        else()
+            set_source_files_properties("${CMAKE_SOURCE_DIR}/src/nvhttp.cpp"
+                    DIRECTORY "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests"
+                    PROPERTIES COMPILE_FLAGS -O2)
+        endif()
     endif()
 else()
     add_definitions(-DNDEBUG)

docs/Doxyfile

@@ -32,7 +32,7 @@ PROJECT_NAME = Sunshine
 # project specific settings
 DOT_GRAPH_MAX_NODES = 60
 IMAGE_PATH = ../docs/images
-INCLUDE_PATH = ../third-party/build-deps/ffmpeg/Linux-x86_64/include/
+INCLUDE_PATH = ../third-party/build-deps/dist/Linux-x86_64/include/
 PREDEFINED += SUNSHINE_BUILD_WAYLAND
 PREDEFINED += SUNSHINE_TRAY=1
 
@@ -52,6 +52,7 @@ INPUT = ../README.md \
         app_examples.md \
         guides.md \
         performance_tuning.md \
+        api.md \
         troubleshooting.md \
         building.md \
         contributing.md \

docs/api.md

@@ -0,0 +1,64 @@
+# API
+
+Sunshine has a RESTful API which can be used to interact with the service.
+
+Unless otherwise specified, authentication is required for all API calls. You can authenticate using
+basic authentication with the admin username and password.
+
+## GET /api/apps
+@copydoc confighttp::getApps()
+
+## GET /api/logs
+@copydoc confighttp::getLogs()
+
+## POST /api/apps
+@copydoc confighttp::saveApp()
+
+## DELETE /api/apps{index}
+@copydoc confighttp::deleteApp()
+
+## POST /api/covers/upload
+@copydoc confighttp::uploadCover()
+
+## GET /api/config
+@copydoc confighttp::getConfig()
+
+## GET /api/configLocale
+@copydoc confighttp::getLocale()
+
+## POST /api/config
+@copydoc confighttp::saveConfig()
+
+## POST /api/restart
+@copydoc confighttp::restart()
+
+## POST /api/password
+@copydoc confighttp::savePassword()
+
+## POST /api/pin
+@copydoc confighttp::savePin()
+
+## POST /api/clients/unpair-all
+@copydoc confighttp::unpairAll()
+
+## POST /api/clients/unpair
+@copydoc confighttp::unpair()
+
+## GET /api/clients/list
+@copydoc confighttp::listClients()
+
+## GET /api/apps/close
+@copydoc confighttp::closeApp()
+
+<div class="section_buttons">
+
+| Previous                                    |                                  Next |
+|:--------------------------------------------|--------------------------------------:|
+| [Performance Tuning](performance_tuning.md) | [Troubleshooting](troubleshooting.md) |
+
+</div>
+
+<details style="display: none;">
+  <summary></summary>
+  [TOC]
+</details>

docs/configuration.md

@@ -2303,6 +2303,33 @@ editing the `conf` file in a text editor. Use the examples as reference.
     </tr>
 </table>
 
+## VA-API Encoder
+
+### vaapi_strict_rc_buffer
+
+<table>
+    <tr>
+        <td>Description</td>
+        <td colspan="2">
+            Enabling this option can avoid dropped frames over the network during scene changes, but video quality may
+            be reduced during motion.
+            @note{This option only applies for H.264 and HEVC when using VA-API [encoder](#encoder) on AMD GPUs.}
+        </td>
+    </tr>
+    <tr>
+        <td>Default</td>
+        <td colspan="2">@code{}
+            disabled
+            @endcode</td>
+    </tr>
+    <tr>
+        <td>Example</td>
+        <td colspan="2">@code{}
+            vaapi_strict_rc_buffer = enabled
+            @endcode</td>
+    </tr>
+</table>
+
 ## Software Encoder
 
 ### sw_preset

docs/getting_started.md

@@ -20,7 +20,7 @@ No support will be provided for third party packages!}
 ### Docker
 @warning{The Docker images are not recommended for most users.}
 
-Docker images are available on [Dockerhub.io](https://hub.docker.com/repository/docker/lizardbyte/sunshin)
+Docker images are available on [Dockerhub.io](https://hub.docker.com/repository/docker/lizardbyte/sunshine)
 and [ghcr.io](https://github.com/orgs/LizardByte/packages?repo_name=sunshine).
 
 See [Docker](../DOCKER_README.md) for more information.
@@ -240,6 +240,8 @@ This package requires that you have [Homebrew](https://docs.brew.sh/Installation
 
 ##### Install
 ```bash
+brew update
+brew upgrade
 brew tap LizardByte/homebrew
 brew install sunshine
 ```

docs/performance_tuning.md

@@ -13,9 +13,9 @@ Enabling *Fast Sync* in Nvidia settings may help reduce latency.
 
 <div class="section_buttons">
 
-| Previous            |                                  Next |
+| Previous            |          Next |
-|:--------------------|--------------------------------------:|
+|:--------------------|--------------:|
-| [Guides](guides.md) | [Troubleshooting](troubleshooting.md) |
+| [Guides](guides.md) | [API](api.md) |
 
 </div>
 

docs/troubleshooting.md

@@ -165,14 +165,6 @@ high as long as the encoder is used.
 ### Gamescope compatibility
 Some users have reported stuttering issues when streaming games running within Gamescope.
 
-### Occasional flickering in KDE
-
-The `blur` plugin causes flickering during streaming for some people. Disable it from the
-KDE System Settings or from the commandline:
-```bash
-qdbus org.kde.KWin /Effects unloadEffect blur
-```
-
 ## macOS
 
 ### Dynamic session lookup failed
@@ -200,9 +192,9 @@ permissions on the disk.
 
 <div class="section_buttons">
 
-| Previous                                    |                    Next |
+| Previous      |                    Next |
-|:--------------------------------------------|------------------------:|
+|:--------------|------------------------:|
-| [Performance Tuning](performance_tuning.md) | [Building](building.md) |
+| [API](api.md) | [Building](building.md) |
 
 </div>
 

packaging/sunshine.rb

@@ -115,6 +115,9 @@ class @PROJECT_NAME@ < Formula
       bin.install "tests/test_sunshine"
     end
 
+    # codesign the binary on intel macs
+    system "codesign", "-s", "-", "--force", "--deep", bin/"sunshine" if OS.mac? && Hardware::CPU.intel?
+
     bin.install "src_assets/linux/misc/postinst" if OS.linux?
   end
 

src/cbs.cpp

@@ -3,10 +3,10 @@
  * @brief Definitions for FFmpeg Coded Bitstream API.
  */
 extern "C" {
-#include <cbs/cbs_h264.h>
-#include <cbs/cbs_h265.h>
-#include <cbs/h264_levels.h>
 #include <libavcodec/avcodec.h>
+#include <libavcodec/cbs_h264.h>
+#include <libavcodec/cbs_h265.h>
+#include <libavcodec/h264_levels.h>
 #include <libavutil/pixdesc.h>
 }
 

src/config.cpp

@@ -381,6 +381,10 @@ namespace config {
       -1,
     },  // vt
 
+    {
+      false,  // strict_rc_buffer
+    },  // vaapi
+
     {},  // capture
     {},  // encoder
     {},  // adapter_name
@@ -414,7 +418,7 @@ namespace config {
     PRIVATE_KEY_FILE,
     CERTIFICATE_FILE,
 
-    boost::asio::ip::host_name(),  // sunshine_name,
+    platf::get_host_name(),  // sunshine_name,
     "sunshine_state.json"s,  // file_state
     {},  // external_ip
   };
@@ -1060,6 +1064,8 @@ namespace config {
     int_f(vars, "vt_software", video.vt.vt_require_sw, vt::force_software_from_view);
     int_f(vars, "vt_realtime", video.vt.vt_realtime, vt::rt_from_view);
 
+    bool_f(vars, "vaapi_strict_rc_buffer", video.vaapi.strict_rc_buffer);
+
     string_f(vars, "capture", video.capture);
     string_f(vars, "encoder", video.encoder);
     string_f(vars, "adapter_name", video.adapter_name);

src/config.h

@@ -74,6 +74,10 @@ namespace config {
       int vt_coder;
     } vt;
 
+    struct {
+      bool strict_rc_buffer;
+    } vaapi;
+
     std::string capture;
     std::string encoder;
     std::string adapter_name;

src/confighttp.cpp

@@ -341,6 +341,11 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Get the list of available applications.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   getApps(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -354,6 +359,11 @@ namespace confighttp {
     response->write(content, headers);
   }
 
+  /**
+   * @brief Get the logs from the log file.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   getLogs(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -367,6 +377,37 @@ namespace confighttp {
     response->write(SimpleWeb::StatusCode::success_ok, content, headers);
   }
 
+  /**
+   * @brief Save an application. If the application already exists, it will be updated, otherwise it will be added.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *   "name": "<Application Name>",
+   *   "output": "<Log Output Path>",
+   *   "cmd": "<Command to run the application>",
+   *   "index": -1,
+   *   "exclude-global-prep-cmd": false,
+   *   "elevated": false,
+   *   "auto-detach": true,
+   *   "wait-all": true,
+   *   "exit-timeout": 5,
+   *   "prep-cmd": [
+   *     {
+   *       "do": "<Command to prepare>",
+   *       "undo": "<Command to undo preparation>",
+   *       "elevated": false
+   *     }
+   *   ],
+   *   "detached": [
+   *     "<Detached commands>"
+   *   ],
+   *   "image-path": "<Full path to the application image. Must be a png file.>",
+   *   "uuid": "C3445C24-871A-FD23-0708-615C121B5B78"
+   * }
+   * @endcode
+   */
   void
   saveApp(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -408,6 +449,11 @@ namespace confighttp {
     proc::refresh(config::stream.file_apps);
   }
 
+  /**
+   * @brief Delete an application.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   deleteApp(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -462,6 +508,18 @@ namespace confighttp {
     proc::refresh(config::stream.file_apps);
   }
 
+  /**
+   * @brief Upload a cover image.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *   "key": "igdb_<game_id>",
+   *   "url": "https://images.igdb.com/igdb/image/upload/t_cover_big_2x/<slug>.png",
+   * }
+   * @endcode
+   */
   void
   uploadCover(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -522,6 +580,11 @@ namespace confighttp {
     outputTree.put("path", path);
   }
 
+  /**
+   * @brief Get the configuration settings.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   getConfig(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -550,6 +613,11 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Get the locale setting. This endpoint does not require authentication.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   getLocale(resp_https_t response, req_https_t request) {
     // we need to return the locale whether authenticated or not
@@ -568,6 +636,19 @@ namespace confighttp {
     outputTree.put("locale", config::sunshine.locale);
   }
 
+  /**
+   * @brief Save the configuration settings.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *   "key": "value"
+   * }
+   * @endcode
+   *
+   * @attention{It is recommended to ONLY save the config settings that differ from the default behavior.}
+   */
   void
   saveConfig(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -604,6 +685,11 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Restart Sunshine.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   restart(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -643,6 +729,21 @@ namespace confighttp {
     write_resp.detach();
   }
 
+  /**
+   * @brief Update existing credentials.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *   "currentUsername": "Current Username",
+   *   "currentPassword": "Current Password",
+   *   "newUsername": "New Username",
+   *   "newPassword": "New Password",
+   *   "confirmNewPassword": "Confirm New Password"
+   * }
+   * @endcode
+   */
   void
   savePassword(resp_https_t response, req_https_t request) {
     if (!config::sunshine.username.empty() && !authenticate(response, request)) return;
@@ -748,6 +849,18 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Send a pin code to the host. The pin is generated from the Moonlight client during the pairing process.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *   "pin": "<pin>",
+   *   "name": "Friendly Client Name"
+   * }
+   * @endcode
+   */
   void
   savePin(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -827,24 +940,6 @@ namespace confighttp {
     }
   }
 
-  void
-  unpairAll(resp_https_t response, req_https_t request) {
-    if (!authenticate(response, request)) return;
-
-    print_req(request);
-
-    pt::ptree outputTree;
-
-    auto g = util::fail_guard([&]() {
-      std::ostringstream data;
-      pt::write_json(data, outputTree);
-      response->write(data.str());
-    });
-    nvhttp::erase_all_clients();
-    proc::proc.terminate();
-    outputTree.put("status", true);
-  }
-
   void
   updateClient(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -877,6 +972,40 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Unpair all clients.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
+  void
+  unpairAll(resp_https_t response, req_https_t request) {
+    if (!authenticate(response, request)) return;
+
+    print_req(request);
+
+    pt::ptree outputTree;
+
+    auto g = util::fail_guard([&]() {
+      std::ostringstream data;
+      pt::write_json(data, outputTree);
+      response->write(data.str());
+    });
+    nvhttp::erase_all_clients();
+    proc::proc.terminate();
+    outputTree.put("status", true);
+  }
+
+  /**
+   * @brief Unpair a client.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   * The body for the post request should be JSON serialized in the following format:
+   * @code{.json}
+   * {
+   *  "uuid": "<uuid>"
+   * }
+   * @endcode
+   */
   void
   unpair(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -998,6 +1127,11 @@ namespace confighttp {
     }
   }
 
+  /**
+   * @brief Get the list of paired clients.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   listClients(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;
@@ -1020,6 +1154,11 @@ namespace confighttp {
     outputTree.put("status", true);
   }
 
+  /**
+   * @brief Close the currently running application.
+   * @param response The HTTP response object.
+   * @param request The HTTP request object.
+   */
   void
   closeApp(resp_https_t response, req_https_t request) {
     if (!authenticate(response, request)) return;

src/platform/common.h

@@ -418,7 +418,7 @@ namespace platf {
      * @note Implementations may set or modify codec options prior to codec initialization.
      */
     virtual void
-    init_codec_options(AVCodecContext *ctx, AVDictionary *options) {};
+    init_codec_options(AVCodecContext *ctx, AVDictionary **options) {};
 
     /**
      * @brief Prepare to derive a context.
@@ -861,6 +861,13 @@ namespace platf {
   [[nodiscard]] std::unique_ptr<deinit_t>
   init();
 
+  /**
+   * @brief Returns the current computer name in UTF-8.
+   * @return Computer name or a placeholder upon failure.
+   */
+  std::string
+  get_host_name();
+
   /**
    * @brief Gets the supported gamepads for this platform backend.
    * @details This may be called prior to `platf::input()`!

src/platform/linux/misc.cpp

@@ -15,6 +15,7 @@
 // lib includes
 #include <arpa/inet.h>
 #include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/host_name.hpp>
 #include <boost/process/v1.hpp>
 #include <dlfcn.h>
 #include <fcntl.h>
@@ -324,22 +325,24 @@ get_local_ip_for_gateway() {
 
   bp::child
   run_command(bool elevated, bool interactive, const std::string &cmd, boost::filesystem::path &working_dir, const bp::environment &env, FILE *file, std::error_code &ec, bp::group *group) {
+    // clang-format off
     if (!group) {
       if (!file) {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > bp::null, bp::std_err > bp::null, ec);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > bp::null, bp::std_err > bp::null, bp::limit_handles, ec);
       }
       else {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > file, bp::std_err > file, ec);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > file, bp::std_err > file, bp::limit_handles, ec);
       }
     }
     else {
       if (!file) {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > bp::null, bp::std_err > bp::null, ec, *group);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > bp::null, bp::std_err > bp::null, bp::limit_handles, ec, *group);
       }
       else {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > file, bp::std_err > file, ec, *group);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > file, bp::std_err > file, bp::limit_handles, ec, *group);
       }
     }
+    // clang-format on
   }
 
   /**
@@ -878,6 +881,17 @@ get_local_ip_for_gateway() {
     return std::make_unique<qos_t>(sockfd, reset_options);
   }
 
+  std::string
+  get_host_name() {
+    try {
+      return boost::asio::ip::host_name();
+    }
+    catch (boost::system::system_error &err) {
+      BOOST_LOG(error) << "Failed to get hostname: "sv << err.what();
+      return "Sunshine"s;
+    }
+  }
+
   namespace source {
     enum source_e : std::size_t {
 #ifdef SUNSHINE_BUILD_CUDA

src/platform/linux/publish.cpp

@@ -426,7 +426,7 @@ namespace platf::publish {
       return nullptr;
     }
 
-    auto instance_name = net::mdns_instance_name(boost::asio::ip::host_name());
+    auto instance_name = net::mdns_instance_name(platf::get_host_name());
     name.reset(avahi::strdup(instance_name.c_str()));
 
     client.reset(

src/platform/linux/vaapi.cpp

@@ -9,6 +9,7 @@
 
 extern "C" {
 #include <libavcodec/avcodec.h>
+#include <libavutil/pixdesc.h>
 #include <va/va.h>
 #include <va/va_drm.h>
 #if !VA_CHECK_VERSION(1, 9, 0)
@@ -129,13 +130,173 @@ namespace va {
       return 0;
     }
 
+    /**
+     * @brief Finds a supported VA entrypoint for the given VA profile.
+     * @param profile The profile to match.
+     * @return A valid encoding entrypoint or 0 on failure.
+     */
+    VAEntrypoint
+    select_va_entrypoint(VAProfile profile) {
+      std::vector<VAEntrypoint> entrypoints(vaMaxNumEntrypoints(va_display));
+      int num_eps;
+      auto status = vaQueryConfigEntrypoints(va_display, profile, entrypoints.data(), &num_eps);
+      if (status != VA_STATUS_SUCCESS) {
+        BOOST_LOG(error) << "Failed to query VA entrypoints: "sv << vaErrorStr(status);
+        return (VAEntrypoint) 0;
+      }
+      entrypoints.resize(num_eps);
+
+      // Sorted in order of descending preference
+      VAEntrypoint ep_preferences[] = {
+        VAEntrypointEncSliceLP,
+        VAEntrypointEncSlice,
+        VAEntrypointEncPicture
+      };
+      for (auto ep_pref : ep_preferences) {
+        if (std::find(entrypoints.begin(), entrypoints.end(), ep_pref) != entrypoints.end()) {
+          return ep_pref;
+        }
+      }
+
+      return (VAEntrypoint) 0;
+    }
+
+    /**
+     * @brief Determines if a given VA profile is supported.
+     * @param profile The profile to match.
+     * @return Boolean value indicating if the profile is supported.
+     */
+    bool
+    is_va_profile_supported(VAProfile profile) {
+      std::vector<VAProfile> profiles(vaMaxNumProfiles(va_display));
+      int num_profs;
+      auto status = vaQueryConfigProfiles(va_display, profiles.data(), &num_profs);
+      if (status != VA_STATUS_SUCCESS) {
+        BOOST_LOG(error) << "Failed to query VA profiles: "sv << vaErrorStr(status);
+        return false;
+      }
+      profiles.resize(num_profs);
+
+      return std::find(profiles.begin(), profiles.end(), profile) != profiles.end();
+    }
+
+    /**
+     * @brief Determines the matching VA profile for the codec configuration.
+     * @param ctx The FFmpeg codec context.
+     * @return The matching VA profile or `VAProfileNone` on failure.
+     */
+    VAProfile
+    get_va_profile(AVCodecContext *ctx) {
+      if (ctx->codec_id == AV_CODEC_ID_H264) {
+        // There's no VAAPI profile for H.264 4:4:4
+        return VAProfileH264High;
+      }
+      else if (ctx->codec_id == AV_CODEC_ID_HEVC) {
+        switch (ctx->profile) {
+          case FF_PROFILE_HEVC_REXT:
+            switch (av_pix_fmt_desc_get(ctx->sw_pix_fmt)->comp[0].depth) {
+              case 10:
+                return VAProfileHEVCMain444_10;
+              case 8:
+                return VAProfileHEVCMain444;
+            }
+            break;
+          case FF_PROFILE_HEVC_MAIN_10:
+            return VAProfileHEVCMain10;
+          case FF_PROFILE_HEVC_MAIN:
+            return VAProfileHEVCMain;
+        }
+      }
+      else if (ctx->codec_id == AV_CODEC_ID_AV1) {
+        switch (ctx->profile) {
+          case FF_PROFILE_AV1_HIGH:
+            return VAProfileAV1Profile1;
+          case FF_PROFILE_AV1_MAIN:
+            return VAProfileAV1Profile0;
+        }
+      }
+
+      BOOST_LOG(error) << "Unknown encoder profile: "sv << ctx->profile;
+      return VAProfileNone;
+    }
+
     void
-    init_codec_options(AVCodecContext *ctx, AVDictionary *options) override {
+    init_codec_options(AVCodecContext *ctx, AVDictionary **options) override {
-      // Don't set the RC buffer size when using H.264 on Intel GPUs. It causes
+      auto va_profile = get_va_profile(ctx);
-      // major encoding quality degradation.
+      if (va_profile == VAProfileNone || !is_va_profile_supported(va_profile)) {
+        // Don't bother doing anything if the profile isn't supported
+        return;
+      }
+
+      auto va_entrypoint = select_va_entrypoint(va_profile);
+      if (va_entrypoint == 0) {
+        // It's possible that only decoding is supported for this profile
+        return;
+      }
+
       auto vendor = vaQueryVendorString(va_display);
-      if (ctx->codec_id != AV_CODEC_ID_H264 || (vendor && !strstr(vendor, "Intel"))) {
+
+      if (va_entrypoint == VAEntrypointEncSliceLP) {
+        BOOST_LOG(info) << "Using LP encoding mode"sv;
+        av_dict_set_int(options, "low_power", 1, 0);
+      }
+      else {
+        BOOST_LOG(info) << "Using normal encoding mode"sv;
+      }
+
+      VAConfigAttrib rc_attr = { VAConfigAttribRateControl };
+      auto status = vaGetConfigAttributes(va_display, va_profile, va_entrypoint, &rc_attr, 1);
+      if (status != VA_STATUS_SUCCESS) {
+        // Stick to the default rate control (CQP)
+        rc_attr.value = 0;
+      }
+
+      VAConfigAttrib slice_attr = { VAConfigAttribEncMaxSlices };
+      status = vaGetConfigAttributes(va_display, va_profile, va_entrypoint, &slice_attr, 1);
+      if (status != VA_STATUS_SUCCESS) {
+        // Assume only a single slice is supported
+        slice_attr.value = 1;
+      }
+      if (ctx->slices > slice_attr.value) {
+        BOOST_LOG(info) << "Limiting slice count to encoder maximum: "sv << slice_attr.value;
+        ctx->slices = slice_attr.value;
+      }
+
+      // Use VBR with a single frame VBV when the user forces it and for known good cases:
+      // - Intel GPUs
+      // - AV1
+      //
+      // VBR ensures the bitstream isn't full of filler data for bitrate undershoots and
+      // single frame VBV ensures that we don't have large bitrate overshoots (at least
+      // as much as they can be avoided without pre-analysis).
+      //
+      // When we have to resort to the default 1 second VBV for encoding quality reasons,
+      // we stick to CBR in order to avoid encoding huge frames after bitrate undershoots
+      // leave headroom available in the RC window.
+      if (config::video.vaapi.strict_rc_buffer ||
+          (vendor && strstr(vendor, "Intel")) ||
+          ctx->codec_id == AV_CODEC_ID_AV1) {
         ctx->rc_buffer_size = ctx->bit_rate * ctx->framerate.den / ctx->framerate.num;
+
+        if (rc_attr.value & VA_RC_VBR) {
+          BOOST_LOG(info) << "Using VBR with single frame VBV size"sv;
+          av_dict_set(options, "rc_mode", "VBR", 0);
+        }
+        else if (rc_attr.value & VA_RC_CBR) {
+          BOOST_LOG(info) << "Using CBR with single frame VBV size"sv;
+          av_dict_set(options, "rc_mode", "CBR", 0);
+        }
+        else {
+          BOOST_LOG(warning) << "Using CQP with single frame VBV size"sv;
+          av_dict_set_int(options, "qp", config::video.qp, 0);
+        }
+      }
+      else if (!(rc_attr.value & (VA_RC_CBR | VA_RC_VBR))) {
+        BOOST_LOG(warning) << "Using CQP rate control"sv;
+        av_dict_set_int(options, "qp", config::video.qp, 0);
+      }
+      else {
+        BOOST_LOG(info) << "Using default rate control"sv;
       }
     }
 

src/platform/macos/display.mm

@@ -5,6 +5,7 @@
 #include "src/platform/common.h"
 #include "src/platform/macos/av_img_t.h"
 #include "src/platform/macos/av_video.h"
+#include "src/platform/macos/misc.h"
 #include "src/platform/macos/nv12_zero_device.h"
 
 #include "src/config.h"
@@ -100,6 +101,13 @@ namespace platf {
 
     int
     dummy_img(img_t *img) override {
+      if (!platf::is_screen_capture_allowed()) {
+        // If we don't have the screen capture permission, this function will hang
+        // indefinitely without doing anything useful. Exit instead to avoid this.
+        // A non-zero return value indicates failure to the calling function.
+        return 1;
+      }
+
       auto signal = [av_capture capture:^(CMSampleBufferRef sampleBuffer) {
         auto new_sample_buffer = std::make_shared<av_sample_buf_t>(sampleBuffer);
         auto new_pixel_buffer = std::make_shared<av_pixel_buf_t>(new_sample_buffer->buf);

src/platform/macos/misc.h

@@ -8,6 +8,11 @@
 
 #include <CoreGraphics/CoreGraphics.h>
 
+namespace platf {
+  bool
+  is_screen_capture_allowed();
+}
+
 namespace dyn {
   typedef void (*apiproc)();
 

src/platform/macos/misc.mm

@@ -23,6 +23,7 @@
 #include "src/platform/common.h"
 
 #include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/host_name.hpp>
 #include <boost/process/v1.hpp>
 
 using namespace std::literals;
@@ -42,6 +43,16 @@ namespace platf {
   CGRequestScreenCaptureAccess(void) __attribute__((weak_import));
 #endif
 
+  namespace {
+    auto screen_capture_allowed = std::atomic<bool> { false };
+  }  // namespace
+
+  // Return whether screen capture is allowed for this process.
+  bool
+  is_screen_capture_allowed() {
+    return screen_capture_allowed;
+  }
+
   std::unique_ptr<deinit_t>
   init() {
     // This will generate a warning about CGPreflightScreenCaptureAccess and
@@ -68,6 +79,8 @@ namespace platf {
       return nullptr;
     }
 #pragma clang diagnostic pop
+    // Record that we determined that we have the screen capture permission.
+    screen_capture_allowed = true;
     return std::make_unique<deinit_t>();
   }
 
@@ -176,22 +189,24 @@ namespace platf {
 
   bp::child
   run_command(bool elevated, bool interactive, const std::string &cmd, boost::filesystem::path &working_dir, const bp::environment &env, FILE *file, std::error_code &ec, bp::group *group) {
+    // clang-format off
     if (!group) {
       if (!file) {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > bp::null, bp::std_err > bp::null, ec);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > bp::null, bp::std_err > bp::null, bp::limit_handles, ec);
       }
       else {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > file, bp::std_err > file, ec);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > file, bp::std_err > file, bp::limit_handles, ec);
       }
     }
     else {
       if (!file) {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > bp::null, bp::std_err > bp::null, ec, *group);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > bp::null, bp::std_err > bp::null, bp::limit_handles, ec, *group);
       }
       else {
-        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_out > file, bp::std_err > file, ec, *group);
+        return bp::child(cmd, env, bp::start_dir(working_dir), bp::std_in < bp::null, bp::std_out > file, bp::std_err > file, bp::limit_handles, ec, *group);
       }
     }
+    // clang-format on
   }
 
   /**
@@ -530,6 +545,17 @@ namespace platf {
     return std::make_unique<qos_t>(sockfd, reset_options);
   }
 
+  std::string
+  get_host_name() {
+    try {
+      return boost::asio::ip::host_name();
+    }
+    catch (boost::system::system_error &err) {
+      BOOST_LOG(error) << "Failed to get hostname: "sv << err.what();
+      return "Sunshine"s;
+    }
+  }
+
   class macos_high_precision_timer: public high_precision_timer {
   public:
     void

src/platform/windows/misc.cpp

@@ -1896,6 +1896,16 @@ namespace platf {
     return output;
   }
 
+  std::string
+  get_host_name() {
+    WCHAR hostname[256];
+    if (GetHostNameW(hostname, ARRAYSIZE(hostname)) == SOCKET_ERROR) {
+      BOOST_LOG(error) << "GetHostNameW() failed: "sv << WSAGetLastError();
+      return "Sunshine"s;
+    }
+    return to_utf8(hostname);
+  }
+
   class win32_high_precision_timer: public high_precision_timer {
   public:
     win32_high_precision_timer() {

src/platform/windows/publish.cpp

@@ -9,8 +9,6 @@
 #include <windns.h>
 #include <winerror.h>
 
-#include <boost/asio/ip/host_name.hpp>
-
 #include "misc.h"
 #include "src/config.h"
 #include "src/logging.h"
@@ -108,7 +106,7 @@ namespace platf::publish {
 
     std::wstring domain { SERVICE_TYPE_DOMAIN.data(), SERVICE_TYPE_DOMAIN.size() };
 
-    auto hostname = boost::asio::ip::host_name();
+    auto hostname = platf::get_host_name();
     auto name = from_utf8(net::mdns_instance_name(hostname) + '.') + domain;
     auto host = from_utf8(hostname + ".local");
 

src/process.cpp

@@ -110,7 +110,8 @@ namespace proc {
 
       // We always call terminate() even if we waited successfully for all processes above.
       // This ensures the process group state is consistent with the OS in boost.
-      group.terminate();
+      std::error_code ec;
+      group.terminate(ec);
       group.detach();
     }
 
@@ -462,6 +463,16 @@ namespace proc {
 
   int
   proc_t::running() {
+#ifndef _WIN32
+    // On POSIX OSes, we must periodically wait for our children to avoid
+    // them becoming zombies. This must be synchronized carefully with
+    // calls to bp::wait() and platf::process_group_running() which both
+    // invoke waitpid() under the hood.
+    auto reaper = util::fail_guard([]() {
+      while (waitpid(-1, nullptr, WNOHANG) > 0);
+    });
+#endif
+
     if (placebo) {
       return _app_id;
     }

src/rtsp.cpp

@@ -588,10 +588,6 @@ namespace rtsp_stream {
           i++;
         }
       }
-
-      if (all && !ios.stopped()) {
-        ios.stop();
-      }
     }
 
     /**

src/video.cpp

@@ -463,7 +463,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "av1_nvenc"s,
     },
     {
@@ -473,7 +472,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "hevc_nvenc"s,
     },
     {
@@ -483,7 +481,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "h264_nvenc"s,
     },
     PARALLEL_ENCODING | REF_FRAMES_INVALIDATION | YUV444_SUPPORT  // flags
@@ -526,7 +523,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "av1_nvenc"s,
     },
     {
@@ -553,7 +549,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "hevc_nvenc"s,
     },
     {
@@ -577,7 +572,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "h264_nvenc"s,
     },
     PARALLEL_ENCODING
@@ -619,7 +613,6 @@ namespace video {
         { "profile"s, (int) qsv::profile_av1_e::high },
       },
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "av1_qsv"s,
     },
     {
@@ -653,7 +646,6 @@ namespace video {
         // Fallback options
         { "low_power"s, []() { return config::video.qsv.qsv_slow_hevc ? 0 : 1; } },
       },
-      std::nullopt,  // QP rate control fallback
       "hevc_qsv"s,
     },
     {
@@ -684,7 +676,6 @@ namespace video {
         // Fallback options
         { "low_power"s, 0 },  // Some old/low-end Intel GPUs don't support low power encoding
       },
-      std::nullopt,  // QP rate control fallback
       "h264_qsv"s,
     },
     PARALLEL_ENCODING | CBR_WITH_VBR | RELAXED_COMPLIANCE | NO_RC_BUF_LIMIT | YUV444_SUPPORT
@@ -717,7 +708,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "av1_amf"s,
     },
     {
@@ -742,7 +732,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "hevc_amf"s,
     },
     {
@@ -768,7 +757,6 @@ namespace video {
         // Fallback options
         { "usage"s, 2 /* AMF_VIDEO_ENCODER_USAGE_LOW_LATENCY */ },  // Workaround for https://github.com/GPUOpen-LibrariesAndSDKs/AMF/issues/410
       },
-      std::nullopt,  // QP rate control fallback
       "h264_amf"s,
     },
     PARALLEL_ENCODING
@@ -798,13 +786,10 @@ namespace video {
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
 
-      // QP rate control fallback
-      std::nullopt,
-
 #ifdef ENABLE_BROKEN_AV1_ENCODER
-      // Due to bugs preventing on-demand IDR frames from working and very poor
+           // Due to bugs preventing on-demand IDR frames from working and very poor
-      // real-time encoding performance, we do not enable libsvtav1 by default.
+           // real-time encoding performance, we do not enable libsvtav1 by default.
-      // It is only suitable for testing AV1 until the IDR frame issue is fixed.
+           // It is only suitable for testing AV1 until the IDR frame issue is fixed.
       "libsvtav1"s,
 #else
       {},
@@ -826,7 +811,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "libx265"s,
     },
     {
@@ -840,7 +824,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,  // QP rate control fallback
       "libx264"s,
     },
     H264_ONLY | PARALLEL_ENCODING | ALWAYS_REPROBE | YUV444_SUPPORT
@@ -858,7 +841,6 @@ namespace video {
     {
       // Common options
       {
-        { "low_power"s, 1 },
         { "async_depth"s, 1 },
         { "idr_interval"s, std::numeric_limits<int>::max() },
       },
@@ -866,17 +848,12 @@ namespace video {
       {},  // HDR-specific options
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
-      {
+      {},  // Fallback options
-        // Fallback options
-        { "low_power"s, 0 },  // Not all VAAPI drivers expose LP entrypoints
-      },
-      std::make_optional<encoder_t::option_t>("qp"s, &config::video.qp),
       "av1_vaapi"s,
     },
     {
       // Common options
       {
-        { "low_power"s, 1 },
         { "async_depth"s, 1 },
         { "sei"s, 0 },
         { "idr_interval"s, std::numeric_limits<int>::max() },
@@ -885,17 +862,12 @@ namespace video {
       {},  // HDR-specific options
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
-      {
+      {},  // Fallback options
-        // Fallback options
-        { "low_power"s, 0 },  // Not all VAAPI drivers expose LP entrypoints
-      },
-      std::make_optional<encoder_t::option_t>("qp"s, &config::video.qp),
       "hevc_vaapi"s,
     },
     {
       // Common options
       {
-        { "low_power"s, 1 },
         { "async_depth"s, 1 },
         { "sei"s, 0 },
         { "idr_interval"s, std::numeric_limits<int>::max() },
@@ -904,15 +876,11 @@ namespace video {
       {},  // HDR-specific options
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
-      {
+      {},  // Fallback options
-        // Fallback options
-        { "low_power"s, 0 },  // Not all VAAPI drivers expose LP entrypoints
-      },
-      std::make_optional<encoder_t::option_t>("qp"s, &config::video.qp),
       "h264_vaapi"s,
     },
     // RC buffer size will be set in platform code if supported
-    LIMITED_GOP_SIZE | PARALLEL_ENCODING | SINGLE_SLICE_ONLY | NO_RC_BUF_LIMIT
+    LIMITED_GOP_SIZE | PARALLEL_ENCODING | NO_RC_BUF_LIMIT
   };
 #endif
 
@@ -939,7 +907,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,
       "av1_videotoolbox"s,
     },
     {
@@ -956,7 +923,6 @@ namespace video {
       {},  // YUV444 SDR-specific options
       {},  // YUV444 HDR-specific options
       {},  // Fallback options
-      std::nullopt,
       "hevc_videotoolbox"s,
     },
     {
@@ -976,7 +942,6 @@ namespace video {
         // Fallback options
         { "flags"s, "-low_delay" },
       },
-      std::nullopt,
       "h264_videotoolbox"s,
     },
     DEFAULT
@@ -1664,52 +1629,43 @@ namespace video {
         }
       }
 
-      if (video_format[encoder_t::CBR]) {
+      auto bitrate = config.bitrate * 1000;
-        auto bitrate = config.bitrate * 1000;
+      ctx->rc_max_rate = bitrate;
-        ctx->rc_max_rate = bitrate;
+      ctx->bit_rate = bitrate;
-        ctx->bit_rate = bitrate;
 
-        if (encoder.flags & CBR_WITH_VBR) {
+      if (encoder.flags & CBR_WITH_VBR) {
-          // Ensure rc_max_bitrate != bit_rate to force VBR mode
+        // Ensure rc_max_bitrate != bit_rate to force VBR mode
-          ctx->bit_rate--;
+        ctx->bit_rate--;
-        }
-        else {
-          ctx->rc_min_rate = bitrate;
-        }
-
-        if (encoder.flags & RELAXED_COMPLIANCE) {
-          ctx->strict_std_compliance = FF_COMPLIANCE_UNOFFICIAL;
-        }
-
-        if (!(encoder.flags & NO_RC_BUF_LIMIT)) {
-          if (!hardware && (ctx->slices > 1 || config.videoFormat == 1)) {
-            // Use a larger rc_buffer_size for software encoding when slices are enabled,
-            // because libx264 can severely degrade quality if the buffer is too small.
-            // libx265 encounters this issue more frequently, so always scale the
-            // buffer by 1.5x for software HEVC encoding.
-            ctx->rc_buffer_size = bitrate / ((config.framerate * 10) / 15);
-          }
-          else {
-            ctx->rc_buffer_size = bitrate / config.framerate;
-
-#ifndef __APPLE__
-            if (encoder.name == "nvenc" && config::video.nv_legacy.vbv_percentage_increase > 0) {
-              ctx->rc_buffer_size += ctx->rc_buffer_size * config::video.nv_legacy.vbv_percentage_increase / 100;
-            }
-#endif
-          }
-        }
-      }
-      else if (video_format.qp) {
-        handle_option(*video_format.qp);
       }
       else {
-        BOOST_LOG(error) << "Couldn't set video quality: encoder "sv << encoder.name << " doesn't support qp"sv;
+        ctx->rc_min_rate = bitrate;
-        return nullptr;
+      }
+
+      if (encoder.flags & RELAXED_COMPLIANCE) {
+        ctx->strict_std_compliance = FF_COMPLIANCE_UNOFFICIAL;
+      }
+
+      if (!(encoder.flags & NO_RC_BUF_LIMIT)) {
+        if (!hardware && (ctx->slices > 1 || config.videoFormat == 1)) {
+          // Use a larger rc_buffer_size for software encoding when slices are enabled,
+          // because libx264 can severely degrade quality if the buffer is too small.
+          // libx265 encounters this issue more frequently, so always scale the
+          // buffer by 1.5x for software HEVC encoding.
+          ctx->rc_buffer_size = bitrate / ((config.framerate * 10) / 15);
+        }
+        else {
+          ctx->rc_buffer_size = bitrate / config.framerate;
+
+#ifndef __APPLE__
+          if (encoder.name == "nvenc" && config::video.nv_legacy.vbv_percentage_increase > 0) {
+            ctx->rc_buffer_size += ctx->rc_buffer_size * config::video.nv_legacy.vbv_percentage_increase / 100;
+          }
+#endif
+        }
       }
 
       // Allow the encoding device a final opportunity to set/unset or override any options
-      encode_device->init_codec_options(ctx.get(), options);
+      encode_device->init_codec_options(ctx.get(), &options);
 
       if (auto status = avcodec_open2(ctx.get(), codec, &options)) {
         char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
@@ -2432,18 +2388,11 @@ namespace video {
       return false;
     }
 
-  retry:
     // If we're expecting failure, use the autoselect ref config first since that will always succeed
     // if the encoder is available.
     auto max_ref_frames_h264 = expect_failure ? -1 : validate_config(disp, encoder, config_max_ref_frames);
     auto autoselect_h264 = max_ref_frames_h264 >= 0 ? max_ref_frames_h264 : validate_config(disp, encoder, config_autoselect);
     if (autoselect_h264 < 0) {
-      if (encoder.h264.qp && encoder.h264[encoder_t::CBR]) {
-        // It's possible the encoder isn't accepting Constant Bit Rate. Turn off CBR and make another attempt
-        encoder.h264.capabilities.set();
-        encoder.h264[encoder_t::CBR] = false;
-        goto retry;
-      }
       return false;
     }
     else if (expect_failure) {
@@ -2467,7 +2416,6 @@ namespace video {
       config_autoselect.videoFormat = 1;
 
       if (disp->is_codec_supported(encoder.hevc.name, config_autoselect)) {
-      retry_hevc:
         auto max_ref_frames_hevc = validate_config(disp, encoder, config_max_ref_frames);
 
         // If H.264 succeeded with max ref frames specified, assume that we can count on
@@ -2476,13 +2424,6 @@ namespace video {
                                  max_ref_frames_hevc :
                                  validate_config(disp, encoder, config_autoselect);
 
-        if (autoselect_hevc < 0 && encoder.hevc.qp && encoder.hevc[encoder_t::CBR]) {
-          // It's possible the encoder isn't accepting Constant Bit Rate. Turn off CBR and make another attempt
-          encoder.hevc.capabilities.set();
-          encoder.hevc[encoder_t::CBR] = false;
-          goto retry_hevc;
-        }
-
         for (auto [validate_flag, encoder_flag] : packet_deficiencies) {
           encoder.hevc[encoder_flag] = (max_ref_frames_hevc & validate_flag && autoselect_hevc & validate_flag);
         }
@@ -2505,7 +2446,6 @@ namespace video {
       config_autoselect.videoFormat = 2;
 
       if (disp->is_codec_supported(encoder.av1.name, config_autoselect)) {
-      retry_av1:
         auto max_ref_frames_av1 = validate_config(disp, encoder, config_max_ref_frames);
 
         // If H.264 succeeded with max ref frames specified, assume that we can count on
@@ -2514,13 +2454,6 @@ namespace video {
                                 max_ref_frames_av1 :
                                 validate_config(disp, encoder, config_autoselect);
 
-        if (autoselect_av1 < 0 && encoder.av1.qp && encoder.av1[encoder_t::CBR]) {
-          // It's possible the encoder isn't accepting Constant Bit Rate. Turn off CBR and make another attempt
-          encoder.av1.capabilities.set();
-          encoder.av1[encoder_t::CBR] = false;
-          goto retry_av1;
-        }
-
         for (auto [validate_flag, encoder_flag] : packet_deficiencies) {
           encoder.av1[encoder_flag] = (max_ref_frames_av1 & validate_flag && autoselect_av1 & validate_flag);
         }

src/video.h

@@ -120,7 +120,6 @@ namespace video {
     enum flag_e {
       PASSED,  ///< Indicates the encoder is supported.
       REF_FRAMES_RESTRICT,  ///< Set maximum reference frames.
-      CBR,  ///< Some encoders don't support CBR, if not supported attempt constant quantization parameter instead.
       DYNAMIC_RANGE,  ///< HDR support.
       YUV444,  ///< YUV 4:4:4 support.
       VUI_PARAMETERS,  ///< AMD encoder with VAAPI doesn't add VUI parameters to SPS.
@@ -135,7 +134,6 @@ namespace video {
       switch (flag) {
         _CONVERT(PASSED);
         _CONVERT(REF_FRAMES_RESTRICT);
-        _CONVERT(CBR);
         _CONVERT(DYNAMIC_RANGE);
         _CONVERT(YUV444);
         _CONVERT(VUI_PARAMETERS);
@@ -167,11 +165,6 @@ namespace video {
       std::vector<option_t> hdr444_options;
       std::vector<option_t> fallback_options;
 
-      // QP option to set in the case that CBR/VBR is not supported
-      // by the encoder. If CBR/VBR is guaranteed to be supported,
-      // don't specify this option to avoid wasteful encoder probing.
-      std::optional<option_t> qp;
-
       std::string name;
       std::bitset<MAX_FLAGS> capabilities;
 

src_assets/common/assets/web/apps.html

@@ -557,12 +557,12 @@
                 if (dotIndex < 0 || slashIndex < 0) {
                   return null;
                 }
-                const hash = thumb.substring(slashIndex + 1, dotIndex);
+                const slug = thumb.substring(slashIndex + 1, dotIndex);
                 return {
                   name: game.name,
-                  key: "igdb_" + game.id,
+                  key: `igdb_${game.id}`,
-                  url: "https://images.igdb.com/igdb/image/upload/t_cover_big/" + hash + ".jpg",
+                  url: `https://images.igdb.com/igdb/image/upload/t_cover_big/${slug}.jpg`,
-                  saveUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big_2x/" + hash + ".png",
+                  saveUrl: `https://images.igdb.com/igdb/image/upload/t_cover_big_2x/${slug}.png`,
                 }
               }).filter(item => item));
         }

src_assets/common/assets/web/config.html

@@ -274,6 +274,13 @@
               "vt_realtime": "enabled",
             },
           },
+          {
+            id: "vaapi",
+            name: "VA-API Encoder",
+            options: {
+              "vaapi_strict_rc_buffer": "disabled",
+            },
+          },
           {
             id: "sw",
             name: "Software Encoder",
@@ -302,7 +309,7 @@
           var app = document.getElementById("app");
           if (this.platform === "windows") {
             this.tabs = this.tabs.filter((el) => {
-              return el.id !== "vt";
+              return el.id !== "vt" && el.id !== "vaapi";
             });
           }
           if (this.platform === "linux") {
@@ -312,7 +319,7 @@
           }
           if (this.platform === "macos") {
             this.tabs = this.tabs.filter((el) => {
-              return el.id !== "amd" && el.id !== "nv" && el.id !== "qsv";
+              return el.id !== "amd" && el.id !== "nv" && el.id !== "qsv" && el.id !== "vaapi";
             });
           }
 

src_assets/common/assets/web/configs/tabs/ContainerEncoders.vue

@@ -5,6 +5,7 @@ import IntelQuickSyncEncoder from './encoders/IntelQuickSyncEncoder.vue'
 import AmdAmfEncoder from './encoders/AmdAmfEncoder.vue'
 import VideotoolboxEncoder from './encoders/VideotoolboxEncoder.vue'
 import SoftwareEncoder from './encoders/SoftwareEncoder.vue'
+import VAAPIEncoder from './encoders/VAAPIEncoder.vue'
 
 const props = defineProps([
   'platform',
@@ -45,6 +46,13 @@ const config = ref(props.config)
       :config="config"
   />
 
+  <!-- VAAPI Encoder Tab -->
+  <VAAPIEncoder
+      v-if="currentTab === 'vaapi'"
+      :platform="platform"
+      :config="config"
+  />
+
   <!-- Software Encoder Tab -->
   <SoftwareEncoder
       v-if="currentTab === 'sw'"

src_assets/common/assets/web/configs/tabs/encoders/VAAPIEncoder.vue

@@ -0,0 +1,28 @@
+<script setup>
+import { ref } from 'vue'
+
+const props = defineProps([
+  'platform',
+  'config',
+])
+
+const config = ref(props.config)
+</script>
+
+<template>
+  <div id="vaapi-encoder" class="config-page">
+    <!-- Strict RC Buffer -->
+    <div class="mb-3">
+      <label for="vaapi_strict_rc_buffer" class="form-label">{{ $t('config.vaapi_strict_rc_buffer') }}</label>
+      <select id="vaapi_strict_rc_buffer" class="form-select" v-model="config.vaapi_strict_rc_buffer">
+        <option value="enabled">{{ $t('_common.enabled') }}</option>
+        <option value="disabled">{{ $t('_common.disabled_def') }}</option>
+      </select>
+      <div class="form-text">{{ $t('config.vaapi_strict_rc_buffer_desc') }}</div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+
+</style>

src_assets/common/assets/web/public/assets/locale/de.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Wenn deaktiviert, wird das Touchpad-Vorhandensein bei der Auswahl des Gamepad-Typs nicht berücksichtigt.",
     "upnp": "UPnP",
     "upnp_desc": "Portweiterleitung für Streaming über das Internet automatisch konfigurieren",
+    "vaapi_strict_rc_buffer": "Bitratenlimit für H.264/HEVC auf AMD GPUs strikt durchsetzen",
+    "vaapi_strict_rc_buffer_desc": "Wenn Sie diese Option aktivieren, können während der Szenenänderung gelöschte Frames über das Netzwerk vermieden werden, aber die Videoqualität kann während der Bewegung reduziert werden.",
     "virtual_sink": "Virtueller Sink",
     "virtual_sink_desc": "Legen Sie ein virtuelles Audiogerät manuell fest. Wenn nicht gesetzt, wird das Gerät automatisch ausgewählt. Wir empfehlen dringend, dieses Feld leer zu lassen, um die automatische Geräteauswahl zu verwenden!",
     "virtual_sink_placeholder": "Steam Streaming Lautsprecher",

src_assets/common/assets/web/public/assets/locale/en.json

@@ -353,6 +353,8 @@
     "touchpad_as_ds4_desc": "If disabled, touchpad presence will not be taken into account during gamepad type selection.",
     "upnp": "UPnP",
     "upnp_desc": "Automatically configure port forwarding for streaming over the Internet",
+    "vaapi_strict_rc_buffer": "Strictly enforce frame bitrate limits for H.264/HEVC on AMD GPUs",
+    "vaapi_strict_rc_buffer_desc": "Enabling this option can avoid dropped frames over the network during scene changes, but video quality may be reduced during motion.",
     "virtual_sink": "Virtual Sink",
     "virtual_sink_desc": "The audio device to be used when audio output isn't allowed on host by the client.\nIf unset, the device is chosen automatically.\nWe strongly recommend leaving this field blank to use automatic device selection!",
     "virtual_sink_placeholder": "Steam Streaming Speakers",

src_assets/common/assets/web/public/assets/locale/en_GB.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "If disabled, touchpad presence will not be taken into account during gamepad type selection.",
     "upnp": "UPnP",
     "upnp_desc": "Automatically configure port forwarding for streaming over the Internet",
+    "vaapi_strict_rc_buffer": "Strictly enforce frame bitrate limits for H.264/HEVC on AMD GPUs",
+    "vaapi_strict_rc_buffer_desc": "Enabling this option can avoid dropped frames over the network during scene changes, but video quality may be reduced during motion.",
     "virtual_sink": "Virtual Sink",
     "virtual_sink_desc": "Manually specify a virtual audio device to use. If unset, the device is chosen automatically. We strongly recommend leaving this field blank to use automatic device selection!",
     "virtual_sink_placeholder": "Steam Streaming Speakers",

src_assets/common/assets/web/public/assets/locale/en_US.json

@@ -310,6 +310,8 @@
     "touchpad_as_ds4_desc": "If disabled, touchpad presence will not be taken into account during gamepad type selection.",
     "upnp": "UPnP",
     "upnp_desc": "Automatically configure port forwarding for streaming over the Internet",
+    "vaapi_strict_rc_buffer": "Strictly enforce frame bitrate limits for H.264/HEVC on AMD GPUs",
+    "vaapi_strict_rc_buffer_desc": "Enabling this option can avoid dropped frames over the network during scene changes, but video quality may be reduced during motion.",
     "virtual_sink": "Virtual Sink",
     "virtual_sink_desc": "Manually specify a virtual audio device to use. If unset, the device is chosen automatically. We strongly recommend leaving this field blank to use automatic device selection!",
     "virtual_sink_placeholder": "Steam Streaming Speakers",

src_assets/common/assets/web/public/assets/locale/es.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Si está desactivado, la presencia del touchpad no se tendrá en cuenta durante la selección del tipo gamepad.",
     "upnp": "UPnP",
     "upnp_desc": "Configurar automáticamente el reenvío de puertos para transmitir a través de Internet",
+    "vaapi_strict_rc_buffer": "Aplicar estrictamente límites de bitrate de fotogramas para H.264/HEVC en AMD GPUs",
+    "vaapi_strict_rc_buffer_desc": "Activar esta opción puede evitar fotogramas soltados en la red durante los cambios de escena, pero la calidad del vídeo puede reducirse durante el movimiento.",
     "virtual_sink": "Enlace virtual",
     "virtual_sink_desc": "Especifique manualmente un dispositivo de audio virtual a utilizar. Si no está activado, el dispositivo se elige automáticamente. ¡Recomendamos encarecidamente dejar este campo en blanco para usar la selección automática de dispositivos!",
     "virtual_sink_placeholder": "Altavoces de Steam Streaming",

src_assets/common/assets/web/public/assets/locale/fr.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Si désactivé, la présence du pavé tactile ne sera pas prise en compte lors de la sélection du type du pavé tactile.",
     "upnp": "UPnP",
     "upnp_desc": "Configurer automatiquement la redirection de port pour le streaming sur Internet",
+    "vaapi_strict_rc_buffer": "Appliquer strictement les limites de débit d'images pour H.264/HEVC sur les GPU AMD",
+    "vaapi_strict_rc_buffer_desc": "L'activation de cette option peut éviter de laisser tomber des images sur le réseau pendant les changements de scène, mais la qualité de la vidéo peut être réduite pendant le mouvement.",
     "virtual_sink": "Évier virtuel",
     "virtual_sink_desc": "Spécifiez manuellement un périphérique audio virtuel à utiliser. Si non défini, le périphérique est choisi automatiquement. Nous vous recommandons fortement de laisser ce champ vide pour utiliser la sélection automatique de l'appareil !",
     "virtual_sink_placeholder": "Steam Streaming Speakers",
@@ -390,7 +392,7 @@
     "troubleshooting": "Dépannage",
     "unpair_all": "Dissocier tous les appareils",
     "unpair_all_error": "Erreur lors de la dissociation",
-    "unpair_all_success": "Désappairage réussi !",
+    "unpair_all_success": "Désappairage réussi.",
     "unpair_desc": "Retirer vos appareils appariés. Les appareils individuellement non appariés avec une session active resteront connectés, mais ne peuvent pas démarrer ou reprendre une session.",
     "unpair_single_no_devices": "Il n'y a aucun appareil associé.",
     "unpair_single_success": "Cependant, le(s) appareil(s) peuvent toujours être dans une session active. Utilisez le bouton 'Forcer la fermeture' ci-dessus pour mettre fin à toute session ouverte.",

src_assets/common/assets/web/public/assets/locale/it.json

@@ -9,7 +9,7 @@
     "disabled_def": "Disabilitato (predefinito)",
     "dismiss": "Ignora",
     "do_cmd": "Esegui Comando",
-    "elevated": "Elevato",
+    "elevated": "Come Admin",
     "enabled": "Abilitato",
     "enabled_def": "Abilitato (predefinito)",
     "error": "Errore!",
@@ -19,7 +19,7 @@
     "save": "Salva",
     "see_more": "Vedi Altro",
     "success": "Operazione riuscita!",
-    "undo_cmd": "Annulla Comando",
+    "undo_cmd": "Comando di Annullamento",
     "username": "Nome utente",
     "warning": "Attenzione!"
   },
@@ -31,11 +31,11 @@
     "app_name_desc": "Il Nome dell'applicazione, come mostrato su Moonlight",
     "applications_desc": "Le applicazioni vengono aggiornate solo al riavvio del client",
     "applications_title": "Applicazioni",
-    "auto_detach": "Continua lo streaming se l'applicazione esce subito",
+    "auto_detach": "Continua lo streaming se l'applicazione chiude improvvisamente",
     "auto_detach_desc": "Cerca di individuare le applicazioni di tipo launcher che si chiudono subito dopo aver avviato un altro programma o una propria istanza. Quando viene rilevata un'app di tipo launcher, viene trattata come un'applicazione separata.",
     "cmd": "Comando",
     "cmd_desc": "L'applicazione principale da avviare. Se vuoto, non verrà avviata alcuna applicazione.",
-    "cmd_note": "Se il percorso del comando eseguibile contiene spazi, è necessario racchiuderlo tra virgolette.",
+    "cmd_note": "Se il percorso del comando eseguibile contiene spazi, è necessario racchiuderlo tra doppie virgolette.",
     "cmd_prep_desc": "Un elenco di comandi da eseguire prima/dopo questa applicazione. Se uno dei comandi preliminari fallisce, l'avvio dell'applicazione viene interrotto.",
     "cmd_prep_name": "Comandi Preliminari",
     "covers_found": "Copertine trovate",
@@ -43,7 +43,7 @@
     "detached_cmds": "Comandi Separati",
     "detached_cmds_add": "Aggiungi comando separato",
     "detached_cmds_desc": "Un elenco di comandi da eseguire in background.",
-    "detached_cmds_note": "Se il percorso del comando eseguibile contiene spazi, è necessario racchiuderlo tra virgolette.",
+    "detached_cmds_note": "Se il percorso del comando eseguibile contiene spazi, è necessario racchiuderlo tra doppie virgolette.",
     "edit": "Modifica",
     "env_app_id": "ID dell'applicazione",
     "env_app_name": "Nome app",
@@ -57,59 +57,59 @@
     "env_client_width": "La larghezza richiesta dal client (int)",
     "env_displayplacer_example": "Esempio - displayplacer per l'automazione della risoluzione:",
     "env_qres_example": "Esempio - QRes per l'automazione della risoluzione:",
-    "env_qres_path": "percorso qres",
+    "env_qres_path": "percorso di QRes",
-    "env_var_name": "Nome Var",
+    "env_var_name": "Nome Variable",
     "env_vars_about": "Informazioni sulle variabili d'ambiente",
     "env_vars_desc": "Tutti i comandi ottengono queste variabili d'ambiente per impostazione predefinita:",
     "env_xrandr_example": "Esempio - Xrandr per l'automazione della risoluzione:",
     "exit_timeout": "Timeout Uscita",
-    "exit_timeout_desc": "Numero di secondi in cui attendere che tutti i processi delle app si ritirino con grazia quando richiesto di uscire. Se disattivato, il valore predefinito è di attendere fino a 5 secondi. Se impostato a zero o a un valore negativo, l'app verrà immediatamente terminata.",
+    "exit_timeout_desc": "Numero di secondi in cui attendere che tutti i processi delle app si chiudano correttamente quando richiesto. Se disattivato, il valore predefinito è di attendere fino a 5 secondi. Se impostato a zero o a un valore negativo, l'app verrà immediatamente terminata.",
     "find_cover": "Trova Copertina",
-    "global_prep_desc": "Abilita/Disabilita l'esecuzione dei Comandi Prep Globali per questa applicazione.",
+    "global_prep_desc": "Abilita/Disabilita l'esecuzione dei Comandi di Preparazione Globali per questa applicazione.",
-    "global_prep_name": "Comandi Prep Globali",
+    "global_prep_name": "Comandi di Preparazione Globali",
     "image": "Immagine",
-    "image_desc": "Icona dell'applicazione/immagine/percorso dell'immagine che verrà inviato al client. L'immagine deve essere un file PNG. Se non impostata, Apollo invierà l'immagine predefinita del box.",
+    "image_desc": "Percorso dell'immagine/icona/foto che verrà inviata al client. L'immagine deve essere un file PNG. Se non impostata, Sunshine invierà l'immagine predefinita.",
     "loading": "Caricamento...",
     "name": "Nome",
     "output_desc": "Il file dove viene memorizzato l'output del comando, se non specificato, l'output viene ignorato",
     "output_name": "Output",
     "run_as_desc": "Questo può essere necessario per alcune applicazioni che richiedono permessi di amministratore per funzionare correttamente.",
-    "wait_all": "Continua lo streaming fino all'uscita di tutti i processi app",
+    "wait_all": "Continua lo streaming fino all'uscita di tutti i processi dell'app",
     "wait_all_desc": "Questo continuerà lo streaming fino a quando tutti i processi avviati dall'app non saranno terminati. Quando non è selezionato, lo streaming si fermerà all'uscita del processo iniziale dell'app, anche se altri processi sono ancora in esecuzione.",
     "working_dir": "Directory di Lavoro",
-    "working_dir_desc": "La directory di lavoro che dovrebbe essere passata al processo. Per esempio, alcune applicazioni usano la directory di lavoro per cercare i file di configurazione. Se non impostato, Apollo predefinirà la directory padre del comando"
+    "working_dir_desc": "La directory di lavoro che dovrebbe essere passata al processo. Per esempio, alcune applicazioni usano la directory di lavoro per cercare i file di configurazione. Se non impostato, Sunshine userà come predefinita la directory padre del comando"
   },
   "config": {
     "adapter_name": "Nome Adattatore",
     "adapter_name_desc_linux_1": "Specifica manualmente una GPU da usare per la cattura.",
     "adapter_name_desc_linux_2": "per trovare tutti i dispositivi con capacità VAAPI",
-    "adapter_name_desc_linux_3": "Sostituisci ``renderD129`` con il dispositivo sopra per elencare il nome e le funzionalità del dispositivo. Per essere supportato da Apollo, ha bisogno di avere minimo:",
+    "adapter_name_desc_linux_3": "Sostituisci ``renderD129`` con il dispositivo sopra per elencare il nome e le funzionalità del dispositivo. Per essere supportato da Sunshine, ha bisogno di avere minimo:",
-    "adapter_name_desc_windows": "Specifica manualmente una GPU da usare per la cattura. Se disattivata, la GPU viene scelta automaticamente. Raccomandiamo vivamente di lasciare vuoto questo campo per utilizzare la selezione automatica della GPU! Nota: questa GPU deve avere un display connesso e acceso. I valori appropriati possono essere trovati usando il seguente comando:",
+    "adapter_name_desc_windows": "Specifica manualmente una GPU da usare per la cattura. Se lascato vuoto, la GPU viene scelta automaticamente. Raccomandiamo vivamente di lasciare vuoto questo campo per utilizzare la selezione automatica della GPU! Nota: questa GPU deve avere un display connesso e acceso. I valori appropriati possono essere trovati usando il seguente comando:",
     "adapter_name_placeholder_windows": "Radeon RX 580 Series",
     "add": "Aggiungi",
-    "address_family": "Famiglia Indirizzo",
+    "address_family": "Famiglia di indirizzi",
     "address_family_both": "IPv4+IPv6",
-    "address_family_desc": "Imposta la famiglia di indirizzi utilizzata da Apollo",
+    "address_family_desc": "Imposta la famiglia di indirizzi utilizzata da Sunshine",
     "address_family_ipv4": "Solo IPv4",
     "always_send_scancodes": "Invia sempre Scancode",
-    "always_send_scancodes_desc": "L'invio di scancode migliora la compatibilità con i giochi e le applicazioni, ma può risultare in input da tastiera errati da alcuni client che non utilizzano un layout di inglese statunitense. Abilita se l' input della tastiera non funziona affatto in certe applicazioni. Disabilita se le chiavi del client generano l'input errato sull'host.",
+    "always_send_scancodes_desc": "L'invio di scancode migliora la compatibilità con i giochi e le applicazioni, ma può risultare in input da tastiera errati da alcuni client che non utilizzano un layout di inglese statunitense. Abilita se l' input della tastiera non funziona affatto in certe applicazioni. Disabilita se i tasti del client generano l'input errato sull'host.",
     "amd_coder": "Coder AMF (H264)",
     "amd_coder_desc": "Consente di selezionare la codifica dell'entropia per dare la priorità alla qualità o alla velocità di codifica. Solo H.264.",
-    "amd_enforce_hrd": "Applicazione Decoder di Riferimento Ipotetico AMF (HRD)",
+    "amd_enforce_hrd": "Applica Decoder di Riferimento Ipotetico (HRD) per AMF",
-    "amd_enforce_hrd_desc": "Aumenta i vincoli in materia di controllo della velocità per soddisfare i requisiti del modello HRD. Questo riduce notevolmente il bitrate overflow, ma può causare artefatti di codifica o qualità ridotta su determinate schede.",
+    "amd_enforce_hrd_desc": "Aumenta i vincoli in materia di controllo della velocità per soddisfare i requisiti del modello HRD. Questo riduce notevolmente l'overflow del bitrate, ma può causare artefatti di codifica o qualità ridotta su determinate schede.",
     "amd_preanalysis": "Preanalisi AMF",
-    "amd_preanalysis_desc": "Ciò consente la preanalisi del controllo della velocità, che può aumentare la qualità a scapito di una maggiore latenza di codifica.",
+    "amd_preanalysis_desc": "Ciò consente la preanalisi nel controllo della velocità, che può aumentare la qualità a scapito di una maggiore latenza di codifica.",
     "amd_quality": "Qualità AMF",
     "amd_quality_balanced": "bilanciato -- bilanciato (predefinito)",
     "amd_quality_desc": "Questo controlla l'equilibrio tra velocità di codifica e qualità.",
     "amd_quality_group": "Impostazioni Qualità AMF",
     "amd_quality_quality": "qualità -- preferisce la qualità",
-    "amd_quality_speed": "velocità -- preferisci la velocità",
+    "amd_quality_speed": "velocità -- preferisce la velocità",
     "amd_rc": "Controllo della Velocità AMF",
     "amd_rc_cbr": "cbr -- bitrate costante",
     "amd_rc_cqp": "cqp -- modalità qp costante",
     "amd_rc_desc": "Questo controlla il metodo di controllo della velocità per garantire che non stiamo superando il target di bitrate client. 'cqp' non è adatto per il target di bitrate e altre opzioni oltre 'vbr_latency' dipendono dall'esecuzione HRD per aiutare a limitare i overflow di bitrate.",
-    "amd_rc_group": "Impostazioni Di Controllo Frequenza Amf",
+    "amd_rc_group": "Impostazioni Controllo di Velocità AMF",
     "amd_rc_vbr_latency": "vbr_latency -- bitrate variabile con vincoli di latenza",
     "amd_rc_vbr_peak": "vbr_peak -- bitrate variabile con vincoli di picco",
     "amd_usage": "Utilizzo AMF",
@@ -121,50 +121,49 @@
     "amd_usage_webcam": "webcam -- webcam (lento)",
     "amd_vbaq": "Quantizzazione Adattiva Basata Sulla Varianza AMF (VBAQ)",
     "amd_vbaq_desc": "Il sistema visivo umano è tipicamente meno sensibile agli artefatti in aree altamente strutturate. In modalità VBAQ, la varianza di pixel è utilizzata per indicare la complessità delle texture spaziali, consentendo al codificatore di allocare più bit ad aree più fluide. Abilitare questa funzione porta a migliorare la qualità visiva soggettiva con alcuni contenuti.",
-    "apply_note": "Fare clic su 'Applica' per applicare le modifiche e riavviare Apollo. Questo terminerà qualsiasi sessione in esecuzione.",
+    "apply_note": "Fare clic su 'Applica' per applicare le modifiche e riavviare Sunshine. Questo terminerà qualsiasi sessione in esecuzione.",
     "audio_sink": "Uscita Audio",
     "audio_sink_desc_linux": "Il nome dell'uscita audio è utilizzato per il Loopback audio. Se non si specifica questa variabile, pulseaudio selezionerà il dispositivo predefinito. È possibile trovare il nome del'uscita audio utilizzando entrambi i comandi:",
-    "audio_sink_desc_macos": "Il nome del lavello audio utilizzato per Audio Loopback. Apollo può accedere solo ai microfoni su macOS a causa delle limitazioni di sistema. Per trasmettere audio di sistema utilizzando Soundflower o BlackHole.",
+    "audio_sink_desc_macos": "Il nome dell'uscita audio utilizzata per Audio Loopback. Sunshine può accedere solo ai microfoni su macOS a causa delle limitazioni di sistema. Puoi usare Soundflower o BlackHole per trasmettere l'audio di sistema.",
     "audio_sink_desc_windows": "Specifica manualmente un dispositivo audio specifico da catturare. Se disattivato, il dispositivo viene scelto automaticamente. Si consiglia vivamente di lasciare vuoto questo campo per utilizzare la selezione automatica del dispositivo! Se si dispone di più dispositivi audio con nomi identici, è possibile ottenere l'ID dispositivo utilizzando il seguente comando:",
     "audio_sink_placeholder_macos": "BlackHole 2ch",
-    "audio_sink_placeholder_windows": "Altoparlanti (Dispositivo Audio Di Alta Definizione)",
+    "audio_sink_placeholder_windows": "Altoparlanti (High Definition Audio Device)",
     "av1_mode": "Supporto AV1",
-    "av1_mode_0": "Apollo fornirà il supporto per AV1 basandosi sulle funzionalità dell'encoder (raccomandato)",
+    "av1_mode_0": "Sunshine fornirà il supporto per AV1 basandosi sulle funzionalità dell'encoder (raccomandato)",
-    "av1_mode_1": "Apollo non fornirà il supporto per AV1",
+    "av1_mode_1": "Sunshine non fornirà il supporto per AV1",
-    "av1_mode_2": "Apollo fornirà il supporto per il profilo principale AV1 a 8 bit",
+    "av1_mode_2": "Sunshine fornirà il supporto per il profilo AV1 Main a 8 bit",
-    "av1_mode_3": "Apollo fornirà il supporto per i profili principali AV1 a 8 bit e 10 bit (HDR)",
+    "av1_mode_3": "Sunshine fornirà il supporto per i profili AV1 Main a 8 bit e 10 bit (HDR)",
-    "av1_mode_desc": "Consente al client di richiedere flussi video principali AV1 8-bit o 10-bit. AV1 è più intensivo da codificare per la CPU, quindi abilitandolo, si utilizza la codifica software, si possono ridurre le prestazioni.",
+    "av1_mode_desc": "Consente al client di richiedere flussi video AV1 Main 8-bit o 10-bit. AV1 è più intensivo da codificare per la CPU, quindi abilitandolo, si utilizza la codifica software, si possono ridurre le prestazioni.",
     "back_button_timeout": "Timeout Emulazione Home/Tasto Guida",
     "back_button_timeout_desc": "Se il pulsante Indietro/Select viene premuto per il numero specificato di millisecondi, viene emulato un pulsante Home/Tasto Guida. Se impostato a un valore < 0 (predefinito), tenendo premuto il pulsante Indietro/Select non verrà emulato il pulsante Home/Tasto Guida.",
     "capture": "Forza un metodo di acquisizione specifico",
-    "capture_desc": "In modalità automatica Apollo userà il primo che funziona. NvFBC richiede driver nvidia patchati.",
+    "capture_desc": "In modalità automatica Sunshine userà il primo che funziona. NvFBC richiede driver nvidia patchati.",
     "cert": "Certificato",
     "cert_desc": "Il certificato utilizzato per l'accoppiamento web UI e il client Moonlight. Per la migliore compatibilità, dovrebbe avere una chiave pubblica RSA-2048.",
     "channels": "Massimi Client Connessi",
-    "channels_desc_1": "Apollo può consentire che una singola sessione di streaming sia condivisa con più client contemporaneamente.",
+    "channels_desc_1": "Sunshine può consentire che una singola sessione di streaming sia condivisa con più client contemporaneamente.",
-    "channels_desc_2": "Alcuni codificatori hardware possono avere limitazioni che riducono le prestazioni con più flussi.",
+    "channels_desc_2": "Alcuni encoder hardware possono avere limitazioni che riducono le prestazioni con più flussi.",
     "coder_cabac": "cabac -- codifica aritmetica binaria adattiva contestuale - qualità superiore",
     "coder_cavlc": "cavlc -- codifica contestuale adattativa a lunghezza variabile - decodifica più veloce",
     "configuration": "Configurazione",
     "controller": "Abilita l'input del Gamepad",
     "controller_desc": "Permette ai guest di controllare il sistema host con un gamepad / controller",
     "credentials_file": "File Credenziali",
-    "credentials_file_desc": "Memorizza il nome utente/password separatamente dal file di stato di Apollo.",
+    "credentials_file_desc": "Memorizza il nome utente/password separatamente dal file di stato di Sunshine.",
     "ds4_back_as_touchpad_click": "Mappa Indietro/Select come Clic Touchpad",
     "ds4_back_as_touchpad_click_desc": "Quando si forza l'emulazione DS4, mappa Indietro/Select come Clic Touchpad",
-    "encoder": "Forza un codificatore specifico",
+    "encoder": "Forza un encoder specifico",
-    "encoder_desc": "Forza un encoder specifico, altrimenti Apollo selezionerà l'opzione migliore disponibile. Nota: Se si specifica un codificatore hardware su Windows, deve corrispondere alla GPU a cui è collegato il display.",
+    "encoder_desc": "Forza un encoder specifico, altrimenti Sunshine selezionerà l'opzione migliore disponibile. Nota: Se si specifica un codificatore hardware su Windows, deve corrispondere alla GPU a cui è collegato il display.",
     "encoder_software": "Software",
-    "external_ip": "Ip Esterno",
+    "external_ip": "IP Esterno",
-    "external_ip_desc": "Se non viene fornito alcun indirizzo IP esterno, Apollo lo rileverà automaticamente",
+    "external_ip_desc": "Se non viene fornito alcun indirizzo IP esterno, Sunshine lo rileverà automaticamente",
     "fec_percentage": "Percentuale FEC",
-    "fec_percentage_desc": "Percentuale di pacchetti corretti per pacchetto dati in ogni fotogramma video. Valori più elevati possono correggere maggiori perdite di rete, ma al costo di un uso crescente della larghezza di banda.",
+    "fec_percentage_desc": "Percentuale di correzione errore per pacchetto dati in ogni fotogramma video. Valori più elevati possono correggere maggiori perdite di rete, ma al costo di un uso crescente della larghezza di banda.",
     "ffmpeg_auto": "auto -- lascia che decida ffmpeg (predefinito)",
     "file_apps": "File Applicazioni",
-    "file_apps_desc": "Il file in cui vengono memorizzate le attuali applicazioni di Apollo.",
+    "file_apps_desc": "Il file in cui vengono memorizzate le attuali applicazioni di Sunshine.",
     "file_state": "File Stato",
-    "file_state_desc": "Il file in cui viene memorizzato lo stato attuale di Apollo",
+    "file_state_desc": "Il file in cui viene memorizzato lo stato attuale di Sunshine",
-    "fps": "FPS Forniti",
     "gamepad": "Tipo di Gamepad Emulato",
     "gamepad_auto": "Opzioni di selezione automatica",
     "gamepad_desc": "Scegli quale tipo di gamepad emulare sull'host",
@@ -177,29 +176,29 @@
     "global_prep_cmd": "Comandi di preparazione",
     "global_prep_cmd_desc": "Configura un elenco di comandi da eseguire prima o dopo aver eseguito qualsiasi applicazione. Se uno qualsiasi dei comandi di preparazione specificati fallisce, il processo di avvio dell'applicazione verrà interrotto.",
     "hevc_mode": "Supporto HEVC",
-    "hevc_mode_0": "Apollo fornirà il supporto per HEVC basandosi sulle funzionalità dell'encoder (raccomandato)",
+    "hevc_mode_0": "Sunshine fornirà il supporto per HEVC basandosi sulle funzionalità dell'encoder (raccomandato)",
-    "hevc_mode_1": "Apollo non fornirà il supporto per HEVC",
+    "hevc_mode_1": "Sunshine non fornirà il supporto per HEVC",
-    "hevc_mode_2": "Apollo fornirà il supporto per il profilo principale HEVC",
+    "hevc_mode_2": "Sunshine fornirà il supporto per il profilo HEVC Main",
-    "hevc_mode_3": "Apollo fornirà il supporto per i profili HEVC Main e Main10 (HDR)",
+    "hevc_mode_3": "Sunshine fornirà il supporto per i profili HEVC Main e Main10 (HDR)",
     "hevc_mode_desc": "Consente al client di richiedere flussi video HEVC Main o HEVC Main10. HEVC è più intensivo per la CPU, quindi abilitarlo può ridurre le prestazioni quando si utilizza la codifica software.",
-    "high_resolution_scrolling": "Supporto Scorrimento Ad Alta Risoluzione",
+    "high_resolution_scrolling": "Supporto Scorrimento Mouse ad Alta Risoluzione",
-    "high_resolution_scrolling_desc": "Quando abilitato, Apollo passerà attraverso gli eventi di scorrimento ad alta risoluzione dai client Moonlight. Può essere utile disabilitarlo per le vecchie applicazioni che scorrono troppo velocemente con eventi di scorrimento ad alta risoluzione.",
+    "high_resolution_scrolling_desc": "Quando abilitato, Sunshine passerà gli eventi di scorrimento ad alta risoluzione dei client Moonlight. Può essere utile disabilitarlo per le vecchie applicazioni che scorrono troppo velocemente con eventi di scorrimento ad alta risoluzione.",
-    "install_steam_audio_drivers": "Installa I Driver Audio Di Steam",
+    "install_steam_audio_drivers": "Installa i Driver Audio di Steam",
     "install_steam_audio_drivers_desc": "Se Steam è installato, installerà automaticamente il driver Steam Streaming Speakers per supportare il suono surround 5.1/7.1 e silenziare l'audio host.",
-    "key_repeat_delay": "Ritardo Ripetizione Chiave",
+    "key_repeat_delay": "Ritardo Ripetizione Tasti",
     "key_repeat_delay_desc": "Controlla quanto velocemente i tasti si ripeteranno. È Il ritardo iniziale in millisecondi prima di ripetere i tasti.",
     "key_repeat_frequency": "Frequenza Di Ripetizione Tasti",
-    "key_repeat_frequency_desc": "Quante volte i tasti si ripetono ogni secondo. Questa opzione configurabile supporta i decimali.",
+    "key_repeat_frequency_desc": "Quante volte i tasti si ripetono ogni secondo. Questa opzione supporta i decimali.",
     "key_rightalt_to_key_windows": "Mappare il tasto Alt destro sul tasto Windows",
-    "key_rightalt_to_key_win_desc": "Potrebbe succedere che non sia possibile inviare il Tasto Windows direttamente da Moonlight. In questi casi può essere utile far credere a Apollo che il tasto Alt Destro è il Tasto Windows",
+    "key_rightalt_to_key_win_desc": "Potrebbe succedere che non sia possibile inviare il Tasto Windows direttamente da Moonlight. In questi casi può essere utile far credere a Sunshine che il tasto Alt Destro è il Tasto Windows",
-    "keyboard": "Abilita Inserimento da Tastiera",
+    "keyboard": "Abilita Input da Tastiera",
     "keyboard_desc": "Consente ai guest di controllare il sistema host con la tastiera",
     "lan_encryption_mode": "Modalità Crittografia LAN",
     "lan_encryption_mode_1": "Abilitato per i client supportati",
-    "lan_encryption_mode_2": "Richiesto per tutti i client",
+    "lan_encryption_mode_2": "Obbligatorio per tutti i client",
     "lan_encryption_mode_desc": "Questo determina quando la crittografia sarà utilizzata durante lo streaming sulla rete locale. La crittografia può ridurre le prestazioni di streaming, in particolare su host e client meno potenti.",
-    "locale": "Localizzazione",
+    "locale": "Lingua",
-    "locale_desc": "La localizzazione utilizzata per l'interfaccia utente di Apollo.",
+    "locale_desc": "La lingua utilizzata per l'interfaccia utente di Sunshine.",
     "log_level": "Livello di Log",
     "log_level_0": "Dettagliato",
     "log_level_1": "Debug",
@@ -210,31 +209,31 @@
     "log_level_6": "Nessuno",
     "log_level_desc": "Il livello minimo di log sullo standard output",
     "log_path": "Percorso File Di Log",
-    "log_path_desc": "Il file in cui vengono memorizzati i log attuali di Apollo.",
+    "log_path_desc": "Il file in cui vengono memorizzati i log attuali di Sunshine.",
     "min_fps_factor": "Fattore FPS Minimo",
-    "min_fps_factor_desc": "Apollo userà questo fattore per calcolare il tempo minimo tra i quadri. Aumentare leggermente questo valore può aiutare durante lo streaming per lo più di contenuti statici. Valori più alti consumeranno più larghezza di banda.",
+    "min_fps_factor_desc": "Sunshine userà questo fattore per calcolare il tempo minimo tra i frame. Aumentare leggermente questo valore può aiutare durante lo streaming per lo più di contenuti statici. Valori più alti consumeranno più larghezza di banda.",
-    "min_threads": "Conteggio Minimo Thread Cpu",
+    "min_threads": "Conteggio Minimo Thread CPU",
-    "min_threads_desc": "Aumentare leggermente il valore riduce l'efficienza di codifica, ma di solito ne vale la pena per guadagnare l'impiego di più core della CPU per la codifica. Il valore ideale è il valore più basso che può codificare in modo affidabile le impostazioni di streaming desiderate sul vostro hardware.",
+    "min_threads_desc": "Aumentare leggermente il valore riduce l'efficienza di codifica, ma di solito ne vale la pena per guadagnare l'impiego di più core della CPU per la codifica. Il valore ideale è il valore più basso che può codificare in modo affidabile in base le impostazioni di streaming desiderate sul vostro hardware.",
     "misc": "Opzioni varie",
     "motion_as_ds4": "Emula un gamepad DS4 se quello del client segnala che ci sono sensori di movimento",
     "motion_as_ds4_desc": "Se disabilitato, i sensori di movimento non saranno presi in considerazione durante la selezione del tipo gamepad.",
     "mouse": "Abilita l'Input del Mouse",
     "mouse_desc": "Permette ai guest di controllare il sistema host con il mouse",
-    "native_pen_touch": "Supporto Nativo Della Penna/Tocco",
+    "native_pen_touch": "Supporto Nativo Della Penna/Touch",
-    "native_pen_touch_desc": "Se abilitato, Apollo passerà direttamente gli eventi nativi della penna/tocco dal client Moonlight. Può essere utile disabilitarlo per le applicazioni più vecchie senza supporto nativo della penna/touch.",
+    "native_pen_touch_desc": "Se abilitato, Sunshine passerà direttamente gli eventi nativi della penna/touch dal client Moonlight. Può essere utile disabilitarlo per le applicazioni più vecchie senza supporto nativo della penna/touch.",
-    "notify_pre_releases": "Notifiche PreRelease",
+    "notify_pre_releases": "Notifiche Pre-Rilascio",
-    "notify_pre_releases_desc": "Indica se notificare o meno le nuove versioni pre-rilascio di Apollo",
+    "notify_pre_releases_desc": "Indica se notificare o meno le nuove versioni pre-rilascio di Sunshine",
     "nvenc_h264_cavlc": "Preferisci CAVLC a CABAC in H.264",
     "nvenc_h264_cavlc_desc": "La forma più semplice di codifica dell'entropia. CAVLC ha bisogno di circa il 10% di bitrate in più per la stessa qualità. Rilevante solo per i dispositivi di decodifica molto vecchi.",
-    "nvenc_latency_over_power": "Preferisci la latenza di codifica più bassa rispetto al risparmio energetico",
+    "nvenc_latency_over_power": "Prioritizza una latenza di codifica più bassa rispetto al risparmio energetico",
-    "nvenc_latency_over_power_desc": "Apollo richiede la massima velocità di clock GPU durante lo streaming per ridurre la latenza di codifica. La disabilitazione non è consigliata in quanto ciò può portare ad un aumento significativo della latenza di codifica.",
+    "nvenc_latency_over_power_desc": "Sunshine richiede la massima velocità di clock GPU durante lo streaming per ridurre la latenza di codifica. La disabilitazione non è consigliata in quanto ciò può portare ad un aumento significativo della latenza di codifica.",
-    "nvenc_opengl_vulkan_on_dxgi": "Presentare OpenGL/Vulkan in cima a DXGI",
+    "nvenc_opengl_vulkan_on_dxgi": "Presenta OpenGL/Vulkan sopra DXGI",
-    "nvenc_opengl_vulkan_on_dxgi_desc": "Apollo non può catturare i programmi OpenGL e Vulkan a schermo intero al frame rate a meno che non presentino in cima a DXGI. Questa è impostazione a livello di sistema che viene ripristinata all'uscita del programma Apollo.",
+    "nvenc_opengl_vulkan_on_dxgi_desc": "Sunshine non può catturare i programmi OpenGL e Vulkan a schermo intero al massimo frame rate a meno che non presentino sopra DXGI. Questa è una impostazione a livello di sistema che viene ripristinata all'uscita del programma sunshine.",
     "nvenc_preset": "Preimpostazione prestazioni",
     "nvenc_preset_1": "(più veloce, predefinito)",
     "nvenc_preset_7": "(più lento)",
-    "nvenc_preset_desc": "Numeri più alti intensificano la compressione (qualità a un dato bitrate) al costo di una maggiore latenza di codifica. È consigliata la modifica solo quando c'è un limite di rete o del decoder, altrimenti un effetto simile può essere raggiunto aumentando il bitrate.",
+    "nvenc_preset_desc": "Numeri più alti migliorano la compressione (qualità a un dato bitrate) a costo di una maggiore latenza di codifica. È consigliata la modifica solo quando c'è un limite di rete o del decoder, altrimenti un effetto simile può essere raggiunto aumentando il bitrate.",
-    "nvenc_realtime_hags": "Usa la priorità in tempo reale nello scheduling hardware dell'accelerazione gpu",
+    "nvenc_realtime_hags": "Usa la priorità in tempo reale nello scheduling hardware dell'accelerazione GPU",
     "nvenc_realtime_hags_desc": "Attualmente i driver NVIDIA possono bloccarsi durante la codifica quando HAGS è abilitato, la priorità in tempo reale viene utilizzata e l'utilizzo VRAM è vicino al massimo. Disabilitare questa opzione riduce la priorità ad alta, eludendo il blocco al costo di una riduzione delle prestazioni di acquisizione quando la GPU è pesantemente caricata.",
     "nvenc_spatial_aq": "AQ spaziale",
     "nvenc_spatial_aq_desc": "Assegna valori QP più alti alle parti piatte del video. È consigliato abilitarlo per lo streaming a bitrate più bassi.",
@@ -244,30 +243,30 @@
     "nvenc_twopass_desc": "Aggiunge un passaggio di codifica preliminare. Questo permette di rilevare più vettori di movimento, distribuire meglio il bitrate attraverso il frame e rispettare più rigorosamente i limiti di bitrate. Disabilitarlo non è raccomandato in quanto questo può portare a occasionali bitrate overshoot e successiva perdita del pacchetto.",
     "nvenc_twopass_disabled": "Disabilitato (più veloce, non consigliato)",
     "nvenc_twopass_full_res": "Risoluzione completa (lenta)",
-    "nvenc_twopass_quarter_res": "Risoluzione del trimestre (più veloce, predefinito)",
+    "nvenc_twopass_quarter_res": "Un quarto di risoluzione (più veloce, predefinito)",
-    "nvenc_vbv_increase": "Incremento percentuale VBV/HRD singolo telaio",
+    "nvenc_vbv_increase": "Incremento percentuale VBV/HRD singolo frame",
-    "nvenc_vbv_increase_desc": "Per impostazione predefinita, il sole utilizza un singolo frame VBV/HRD, il che significa che qualsiasi dimensione del frame video codificato non dovrebbe superare il bitrate richiesto diviso per il frame rate richiesto. Rilassare questa restrizione può essere utile e agire come bitrate variabile a bassa latenza, ma può anche portare alla perdita di pacchetto se la rete non ha headroom buffer per gestire picchi di bitrate. Il valore massimo accettato è di 400, che corrisponde a 5x il limite di dimensione superiore del fotogramma video codificato.",
+    "nvenc_vbv_increase_desc": "Per impostazione predefinita, Sunshine utilizza VBV/HRD a singolo frame, in questo modo la dimensione di un frame video codificato non supererà il bitrate richiesto diviso per il frame rate richiesto. Allentare questa restrizione può portare benefici, agendo come un bitrate variabile a bassa latenza, ma può anche portare alla perdita di pacchetti se la rete non ha banda aggiuntiva sufficiente per gestire picchi di bitrate. Il valore massimo accettato è di 400, che corrisponde a 5x la dimensione limite dei frame video codificati.",
     "origin_web_ui_allowed": "Origine Web UI Consentita",
-    "origin_web_ui_allowed_desc": "L'origine dell'indirizzo di endpoint remoto a cui non viene negato l'accesso all'interfaccia utente Web",
+    "origin_web_ui_allowed_desc": "L'origine dell'indirizzo di endpoint remoto a cui viene consentito l'accesso all'interfaccia utente Web",
     "origin_web_ui_allowed_lan": "Solo quelli in LAN possono accedere all'interfaccia utente Web",
     "origin_web_ui_allowed_pc": "Solo localhost può accedere all'interfaccia Web",
     "origin_web_ui_allowed_wan": "Chiunque può accedere all'interfaccia Web",
-    "output_name_desc_unix": "Durante l'avvio di Apollo, dovresti vedere l'elenco dei display rilevati. Nota: devi usare il valore id all'interno della parentesi.",
+    "output_name_desc_unix": "Durante l'avvio di Sunshine, dovresti vedere l'elenco dei display rilevati. Nota: devi usare il valore id all'interno della parentesi. Quello in basso è un esempio, la lista effettiva può essere trovata in \"Risoluzione dei Problemi\".",
-    "output_name_desc_windows": "Specifica manualmente un display da usare per la cattura. Se disattivato, viene catturato il display primario. Nota: Se hai specificato una GPU sopra, questo display deve essere collegato a quella GPU. I valori appropriati possono essere trovati usando il seguente comando:",
+    "output_name_desc_windows": "Specifica manualmente un display da usare per la cattura. Se lasciato vuoto, viene catturato il display primario. Nota: Se hai specificato una GPU sopra, questo display deve essere collegato a quella GPU. I valori appropriati possono essere trovati usando il seguente comando:",
-    "output_name_unix": "Visualizza numero",
+    "output_name_unix": "Numero di Display",
-    "output_name_windows": "Nome Uscita",
+    "output_name_windows": "Nome Output",
     "ping_timeout": "Timeout Ping",
-    "ping_timeout_desc": "Per quanto tempo attendere in millisecondi per i dati dalla luce della luna prima di spegnere il flusso",
+    "ping_timeout_desc": "Per quanti millisecondi attendere dati da Moonlight prima di chiudere lo streaming",
     "pkey": "Chiave Privata",
     "pkey_desc": "La chiave privata utilizzata per l'accoppiamento web UI e client Moonlight. Per la migliore compatibilità, questa dovrebbe essere una chiave privata RSA-2048.",
     "port": "Porta",
-    "port_alert_1": "Apollo non può utilizzare porte sotto 1024!",
+    "port_alert_1": "Sunshine non può utilizzare porte sotto 1024!",
     "port_alert_2": "I porti sopra 65535 non sono disponibili!",
-    "port_desc": "Imposta la famiglia di porti utilizzati da Apollo",
+    "port_desc": "Imposta la famiglia di porte utilizzati da Sunshine",
     "port_http_port_note": "Usa questa porta per connetterti con Moonlight.",
     "port_note": "Nota",
     "port_port": "Porta",
-    "port_protocol": "Protocol",
+    "port_protocol": "Protocollo",
     "port_tcp": "TCP",
     "port_udp": "UDP",
     "port_warning": "Esporre l'interfaccia Web su Internet è un rischio per la sicurezza! Procedi a tuo rischio!",
@@ -275,68 +274,68 @@
     "qp": "Parametro Di Quantizzazione",
     "qp_desc": "Alcuni dispositivi potrebbero non supportare Constant Bit Rate. Per questi dispositivi, viene invece utilizzato QP. Valore più alto significa più compressione, ma meno qualità.",
     "qsv_coder": "Coder QuickSync (H264)",
-    "qsv_preset": "QuickSync Preset",
+    "qsv_preset": "Preimpostazione QuickSync",
     "qsv_preset_fast": "più veloce (qualità inferiore)",
     "qsv_preset_faster": "più veloce (qualità minima)",
     "qsv_preset_medium": "medio (predefinito)",
     "qsv_preset_slow": "lento (buona qualità)",
     "qsv_preset_slower": "più lento (migliore qualità)",
     "qsv_preset_slowest": "più lento (migliore qualità)",
-    "qsv_preset_veryfast": "più veloce (qualità minima)",
+    "qsv_preset_veryfast": "ancora più veloce (qualità minima)",
-    "qsv_slow_hevc": "Permetti La Lenta Codifica HEVC",
+    "qsv_slow_hevc": "Permetti la codifica lenta in HEVC",
     "qsv_slow_hevc_desc": "Questo può abilitare la codifica HEVC su vecchie GPU Intel, al costo di un maggiore utilizzo della GPU e prestazioni peggiori.",
-    "res_fps_desc": "Le modalità di visualizzazione pubblicizzate da Apollo. Alcune versioni di Moonlight, come Moonlight-nx (Switch), si basano su queste liste per garantire che le risoluzioni e fps richieste siano supportate. Questa impostazione non cambia il modo in cui lo schermo viene inviato al Moonlight.",
+    "restart_note": "Sunshine sta riavviando per applicare le modifiche.",
-    "resolutions": "Risoluzioni Pubblicizzate",
+    "sunshine_name": "Nome Sunshine",
-    "restart_note": "Apollo sta riavviando per applicare le modifiche.",
-    "sunshine_name": "Nome Apollo",
     "sunshine_name_desc": "Il nome visualizzato da Moonlight. Se non specificato, viene utilizzato il nome host del PC",
-    "sw_preset": "Preset SO",
+    "sw_preset": "Preset SW",
     "sw_preset_desc": "Ottimizza il trade-off tra velocità di codifica (fotogrammi codificati al secondo) e efficienza di compressione (qualità per bit nel bitstream). Predefiniti a superfast.",
     "sw_preset_fast": "veloce",
     "sw_preset_faster": "più veloce",
     "sw_preset_medium": "medio",
     "sw_preset_slow": "lento",
     "sw_preset_slower": "più lento",
-    "sw_preset_superfast": "superfast (predefinito)",
+    "sw_preset_superfast": "superveloce (predefinito)",
-    "sw_preset_ultrafast": "ultrafast",
+    "sw_preset_ultrafast": "ultra veloce",
-    "sw_preset_veryfast": "veryfast",
+    "sw_preset_veryfast": "molto veloce",
-    "sw_preset_veryslow": "veryslow",
+    "sw_preset_veryslow": "molto lento",
-    "sw_tune": "SW Tune",
+    "sw_tune": "Rifinimento SW",
-    "sw_tune_animation": "animazione -- buona per i cartoni animati; utilizza un maggiore sblocco e più quadri di riferimento",
+    "sw_tune_animation": "animazione -- buona per i cartoni animati; utilizza un maggiore de-blocking e più frame di riferimento",
-    "sw_tune_desc": "Opzioni di sintonizzazione, che vengono applicate dopo la preimpostazione. Predefinite a zerolatency.",
+    "sw_tune_desc": "Opzioni di rifinimento, che vengono applicate dopo la preimpostazione. Predefinite a zerolatency.",
     "sw_tune_fastdecode": "fastdecode -- permette una decodifica più veloce disabilitando alcuni filtri",
-    "sw_tune_film": "film -- uso per contenuti cinematografici di alta qualità; riduce lo sblocco",
+    "sw_tune_film": "film -- uso per contenuti cinematografici di alta qualità; riduce il deblocking",
-    "sw_tune_grain": "grano -- conserva la struttura del grano nel vecchio materiale di film granuloso",
+    "sw_tune_grain": "grain -- conserva la struttura della grana nel vecchio materiale di film",
     "sw_tune_stillimage": "stillimage -- buono per contenuti simili alle presentazioni",
     "sw_tune_zerolatency": "zerolatency -- buono per la codifica veloce e lo streaming a bassa latenza (predefinito)",
-    "touchpad_as_ds4": "Emula un gamepad DS4 se il gamepad client segnala un touchpad è presente",
+    "touchpad_as_ds4": "Emula un gamepad DS4 se il gamepad client segnala che un touchpad è presente",
     "touchpad_as_ds4_desc": "Se disabilitata, la presenza del touchpad non sarà presa in considerazione durante la selezione del tipo del gamepad.",
     "upnp": "UPnP",
     "upnp_desc": "Configura automaticamente l'inoltro delle porte per lo streaming su Internet",
-    "virtual_sink": "Lavello Virtuale",
+    "vaapi_strict_rc_buffer": "Applicare rigorosamente i limiti di bitrate frame per H.264/HEVC su GPU AMD",
+    "vaapi_strict_rc_buffer_desc": "Abilitare questa opzione può evitare di cadere quadri sulla rete durante i cambiamenti di scena, ma la qualità video può essere ridotta durante il movimento.",
+    "virtual_sink": "Uscita Audio Virtuale",
     "virtual_sink_desc": "Specifica manualmente un dispositivo audio virtuale da usare. Se disattivato, il dispositivo viene scelto automaticamente. Si consiglia vivamente di lasciare vuoto questo campo per utilizzare la selezione automatica del dispositivo!",
     "virtual_sink_placeholder": "Altoparlanti Streaming Di Steam",
-    "vt_coder": "VideoToolbox Coder",
+    "vt_coder": "Coder VideoToolbox",
     "vt_realtime": "Codifica VideoToolbox In Tempo Reale",
     "vt_software": "Codifica Software VideoToolbox",
-    "vt_software_allowed": "Consentito",
+    "vt_software_allowed": "Consentita",
-    "vt_software_forced": "Forzato",
+    "vt_software_forced": "Forzata",
     "wan_encryption_mode": "Modalità Crittografia WAN",
     "wan_encryption_mode_1": "Abilitato per i client supportati (predefinito)",
-    "wan_encryption_mode_2": "Richiesto per tutti i client",
+    "wan_encryption_mode_2": "Obbligatorio per tutti i client",
     "wan_encryption_mode_desc": "Questo determina quando la crittografia sarà utilizzata durante lo streaming su Internet. La crittografia può ridurre le prestazioni di streaming, in particolare su host e client meno potenti."
   },
   "index": {
-    "description": "Apollo è un host di flussi di giochi auto-ospitato per Moonlight.",
+    "description": "Sunshine è una piattaforma autonoma di game stream per Moonlight.",
     "download": "Download",
-    "installed_version_not_stable": "Stai eseguendo una versione pre-rilascio di Apollo. Potresti riscontrare bug o altri problemi. Si prega di segnalare eventuali problemi incontrati. Grazie per aver contribuito a rendere Apollo un software migliore!",
+    "installed_version_not_stable": "Stai eseguendo una versione in anteprima di Sunshine. Potresti riscontrare bug o altri problemi. Si prega di segnalare eventuali problemi incontrati. Grazie per aver contribuito a rendere Sunshine un software migliore!",
     "loading_latest": "Caricamento dell'ultima versione...",
     "new_pre_release": "Una nuova versione pre-rilascio è disponibile!",
     "new_stable": "Una nuova versione Stabile è disponibile!",
-    "startup_errors": "<b>Attenzione!</b> Apollo ha rilevato questi errori durante l'avvio. Si <b>raccomanda vivamente di</b> risolverli prima dello streaming.",
+    "startup_errors": "<b>Attenzione!</b> Sunshine ha rilevato questi errori durante l'avvio. Ti <b>raccomandamo vivamente </b> di risolverli prima dello streaming.",
-    "version_dirty": "Grazie per aver contribuito a rendere Apollo un software migliore!",
+    "version_dirty": "Grazie per aver contribuito a rendere Sunshine un software migliore!",
-    "version_latest": "Stai eseguendo l'ultima versione di Apollo",
+    "version_latest": "Stai eseguendo l'ultima versione di Sunshine",
-    "welcome": "Ciao, Apollo!"
+    "welcome": "Ciao, Sunshine!"
   },
   "navbar": {
     "applications": "Applicazioni",
@@ -359,10 +358,10 @@
     "success_msg": "La password è stata modificata con successo! Questa pagina verrà ricaricata presto, il tuo browser ti chiederà le nuove credenziali."
   },
   "pin": {
-    "device_name": "Nome Del Dispositivo",
+    "device_name": "Nome del Dispositivo",
     "pair_failure": "Accoppiamento non riuscito: verificare se il PIN è digitato correttamente",
-    "pair_success": "Successo! Controlla la luce della luna per continuare",
+    "pair_success": "Fatto! Controlla Moonlight per proseguire",
-    "pin_pairing": "PIN Pairing",
+    "pin_pairing": "Accoppiamento con PIN",
     "send": "Invia",
     "warning_msg": "Assicurati di avere accesso al client con cui stai accoppiando. Questo software può dare il controllo totale al tuo computer, quindi fai attenzione!"
   },
@@ -373,7 +372,7 @@
     "license": "Licenza",
     "lizardbyte_website": "Sito web di LizardByte",
     "resources": "Risorse",
-    "resources_desc": "Risorse per Apollo!",
+    "resources_desc": "Risorse per Sunshine!",
     "third_party_notice": "Avvisi di terze parti"
   },
   "troubleshooting": {
@@ -382,26 +381,26 @@
     "force_close_error": "Errore durante la chiusura dell'applicazione",
     "force_close_success": "Applicazione chiusa con successo!",
     "logs": "Log",
-    "logs_desc": "Vedi i log caricati da Apollo",
+    "logs_desc": "Vedi i log caricati da Sunshine",
     "logs_find": "Trova...",
-    "restart_apollo": "Riavvia Apollo",
+    "restart_sunshine": "Riavvia Sunshine",
-    "restart_apollo_desc": "Se Apollo non funziona correttamente, puoi provare a riavviarlo. Questo terminerà qualsiasi sessione in esecuzione.",
+    "restart_sunshine_desc": "Se Sunshine non funziona correttamente, puoi provare a riavviarlo. Questo terminerà qualsiasi sessione in esecuzione.",
-    "restart_apollo_success": "Apollo sta riavviando",
+    "restart_sunshine_success": "Sunshine sta riavviando",
-    "troubleshooting": "Risoluzione Dei Problemi",
+    "troubleshooting": "Risoluzione dei Problemi",
-    "unpair_all": "Disaccoppia Tutto",
+    "unpair_all": "Rimuovi Tutto",
-    "unpair_all_error": "Errore durante la disconnessione",
+    "unpair_all_error": "Errore durante la rimozione",
-    "unpair_all_success": "Disaccoppiamento Riuscito!",
+    "unpair_all_success": "Rimozione Riuscita.",
-    "unpair_desc": "Rimuove i dispositivi accoppiati. I dispositivi separati con una sessione attiva rimarranno collegati, ma non possono avviare o riprendere una sessione.",
+    "unpair_desc": "Rimuove i dispositivi accoppiati. I dispositivi separati con una sessione attiva rimarranno collegati, ma non potranno avviare o riprendere una sessione.",
     "unpair_single_no_devices": "Non ci sono dispositivi accoppiati.",
     "unpair_single_success": "Tuttavia, il dispositivo o i dispositivi possono essere ancora in una sessione attiva. Usa il pulsante 'Force Close' sopra per terminare qualsiasi sessione aperta.",
     "unpair_single_unknown": "Client Sconosciuto",
-    "unpair_title": "Disconnetti Dispositivi"
+    "unpair_title": "Rimuovi Dispositivi"
   },
   "welcome": {
     "confirm_password": "Conferma password",
     "create_creds": "Prima di iniziare, è necessario creare un nuovo nome utente e una nuova password per accedere all'interfaccia web.",
-    "create_creds_alert": "Le credenziali in basso sono necesarie per accadere alla Web UI di Apollo. Mantienile al sicuro, poichè non potrai più visualizzarle!",
+    "create_creds_alert": "Le credenziali in basso sono necessarie per accedere all'interfaccia web di Sunshine. Tienile al sicuro, poichè non potrai più visualizzarle!",
-    "greeting": "Benvenuto in Apollo!",
+    "greeting": "Benvenuto in Sunshine!",
     "login": "Login",
     "welcome_success": "Questa pagina verrà ricaricata, il tuo browser ti richiederà le nuove credenziali"
   }

src_assets/common/assets/web/public/assets/locale/ja.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "無効にすると、ゲームパッドの種類選択中にタッチパッドの存在が考慮されません。",
     "upnp": "UPnP",
     "upnp_desc": "インターネット経由でストリーミングするポート転送を自動的に設定します",
+    "vaapi_strict_rc_buffer": "AMD GPUでH.264/HEVCのフレームビットレート制限を厳密に強制する",
+    "vaapi_strict_rc_buffer_desc": "このオプションを有効にすると、シーンの変更中にネットワーク上でフレームがドロップされるのを避けることができますが、移動中にビデオの品質が低下する可能性があります。",
     "virtual_sink": "Virtual Sink",
     "virtual_sink_desc": "使用する仮想オーディオデバイスを手動で指定します。未設定の場合は、デバイスが自動的に選択されます。 自動デバイス選択を使用するには、このフィールドを空白のままにすることを強くお勧めします!",
     "virtual_sink_placeholder": "Steamストリーミングスピーカー",

src_assets/common/assets/web/public/assets/locale/pt.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Se desativada, a presença de touchpad não será tida em conta durante a seleção de tipos de controle.",
     "upnp": "UPNP",
     "upnp_desc": "Configurar automaticamente o encaminhamento de portas para transmissão na Internet",
+    "vaapi_strict_rc_buffer": "Impedir com rigor limites de taxa de bits para H.264/HEVC nas GPUs AMD",
+    "vaapi_strict_rc_buffer_desc": "Habilitar esta opção pode evitar frames lançados pela rede durante as mudanças de cena, mas a qualidade de vídeo pode ser reduzida durante o movimento.",
     "virtual_sink": "Pia Virtual",
     "virtual_sink_desc": "Especifique manualmente um dispositivo de áudio virtual para usar. Se não for definido, o dispositivo é escolhido automaticamente. Recomendamos fortemente deixar este campo em branco para usar a seleção automática de dispositivo!",
     "virtual_sink_placeholder": "Alto-falantes de streaming Steam",

src_assets/common/assets/web/public/assets/locale/ru.json

@@ -8,91 +8,91 @@
     "disabled": "Отключено",
     "disabled_def": "Отключено (по умолчанию)",
     "dismiss": "Отклонить",
-    "do_cmd": "Выполнить команду",
+    "do_cmd": "Команда запуска",
-    "elevated": "Повышенный",
+    "elevated": "Требуются",
     "enabled": "Включено",
     "enabled_def": "Включено (по умолчанию)",
     "error": "Ошибка!",
     "note": "Примечание:",
     "password": "Пароль",
-    "run_as": "Запустить как Администратор",
+    "run_as": "Права администратора",
     "save": "Сохранить",
     "see_more": "Подробнее",
     "success": "Успех!",
-    "undo_cmd": "Отменить команду",
+    "undo_cmd": "Команда закрытия",
     "username": "Имя пользователя",
     "warning": "Предупреждение!"
   },
   "apps": {
     "actions": "Действия",
     "add_cmds": "Добавить команды",
-    "add_new": "Добавить новый",
+    "add_new": "Добавить новое",
     "app_name": "Название приложения",
-    "app_name_desc": "Имя приложения, как показано в Moonlight",
+    "app_name_desc": "Имя приложения, для показа в Moonlight",
-    "applications_desc": "Приложения обновляются только при перезапуске клиента",
+    "applications_desc": "Приложения обновятся только после перезапуска клиента",
     "applications_title": "Приложения",
     "auto_detach": "Продолжить трансляцию, если приложение завершит работу быстро",
-    "auto_detach_desc": "Это попытается автоматически обнаружить приложения лаунчера, которые быстро закрываются после запуска другой программы или экземпляра самостоятельно. Когда приложение запускается тип, оно рассматривается как отдельное приложение.",
+    "auto_detach_desc": "Пытаться автоматически обнаружить приложения-лаунчеры, которые быстро закрываются после запуска другой программы или собственной копии. Когда такое приложение обнаружено, оно рассматривается как независимое.",
     "cmd": "Команда",
     "cmd_desc": "Основное приложение для запуска. Если пустое, то не будет запущено приложение.",
     "cmd_note": "Если путь к исполняемому файлу содержит пробелы, вы должны заключить его в кавычки.",
-    "cmd_prep_desc": "Список команд, которые должны быть выполнены до/после этого приложения. Если одна из команд не удается, запуск приложения прерван.",
+    "cmd_prep_desc": "Список команд, которые должны быть выполнены до/после этого приложения. Если одна из команд не выполнена, запуск приложения прерывается.",
-    "cmd_prep_name": "Подготовка команд",
+    "cmd_prep_name": "Команды подготовки",
-    "covers_found": "Найдено обложек",
+    "covers_found": "Найденные обложки",
     "delete": "Удалить",
-    "detached_cmds": "Отдельные команды",
+    "detached_cmds": "Независимые команды",
-    "detached_cmds_add": "Добавить отдельную команду",
+    "detached_cmds_add": "Добавить независимую команду",
-    "detached_cmds_desc": "Список команд для работы в фоновом режиме.",
+    "detached_cmds_desc": "Список команд, работающих в фоновом режиме.",
-    "detached_cmds_note": "Если путь к исполняемому файлу содержит пробелы, вы должны заключить его в кавычки.",
+    "detached_cmds_note": "Если путь к исполняемому файлу содержит пробелы, следует заключить его в кавычки.",
-    "edit": "Редактирование",
+    "edit": "Изменить",
     "env_app_id": "ID приложения",
     "env_app_name": "Название приложения",
     "env_client_audio_config": "Запрошенная клиентом конфигурация аудио (2.0/5.1/7.1)",
-    "env_client_enable_sops": "Клиент запросил опцию оптимизации игры для оптимального потокового вещания (true/false)",
+    "env_client_enable_sops": "Клиент запросил оптимизацию настроек игры для потокового вещания (истина/ложь)",
-    "env_client_fps": "FPS запрошен клиентом (int)",
+    "env_client_fps": "Частота кадров, запрошенная клиентом (целое)",
-    "env_client_gcmap": "Запрашиваемая маска геймпада, в bitset/bitfield формате (int)",
+    "env_client_gcmap": "Запрашиваемая маска геймпада, в формате bitset/bitfield (целое)",
-    "env_client_hdr": "HDR включен клиентом (true/false)",
+    "env_client_hdr": "HDR включен клиентом (истина/ложь)",
-    "env_client_height": "Высота, запрошенная клиентом (int)",
+    "env_client_height": "Высота, запрошенная клиентом (целое)",
-    "env_client_host_audio": "Клиент запросил звук узла (true/false)",
+    "env_client_host_audio": "Клиент запросил звук с сервера (истина/ложь)",
-    "env_client_width": "Ширина запрошенная клиентом (int)",
+    "env_client_width": "Ширина, запрошенная клиентом (целое)",
     "env_displayplacer_example": "Пример - displayplacer для автоматизации решения:",
-    "env_qres_example": "Пример - QRes для автоматизации разрешения:",
+    "env_qres_example": "Пример: автопереключение разрешения через QRes:",
     "env_qres_path": "путь qres",
-    "env_var_name": "Имя Вара",
+    "env_var_name": "Переменная окружения",
     "env_vars_about": "О переменных среды",
-    "env_vars_desc": "Все команды получают эти переменные окружения по умолчанию:",
+    "env_vars_desc": "Всем командам по умолчанию передаются эти переменные окружения:",
     "env_xrandr_example": "Пример - Xrandr для автоматизации решения:",
-    "exit_timeout": "Таймаут выхода",
+    "exit_timeout": "Ожидание завершения",
-    "exit_timeout_desc": "Количество секунд, в течение которых все процессы приложения смогут легко выйти из приложения. Если не установлено, то приложение будет немедленно прекращено до 5 секунд. Если установлено значение нуля или отрицательное значение, приложение будет немедленно прекращено.",
+    "exit_timeout_desc": "Сколько секунд ожидать корректного завершения всех процессов приложения при закрытии. Если не указано, то по умолчанию, ожидание длится 5 секунд. Если указан нуль или отрицательное значение, приложение будет прекращено незамедлительно.",
     "find_cover": "Найти обложку",
     "global_prep_desc": "Включить/отключить исполнение глобальных команд подготовки для этого приложения.",
     "global_prep_name": "Глобальные команды",
     "image": "Изображение",
-    "image_desc": "Значок приложения/путь изображения/изображения, который будет отправлен клиенту. Изображение должно быть PNG файлом. Если не установлено, Apollo будет отправлять изображение по умолчанию.",
+    "image_desc": "Путь к иконке/обложке/изображению, который будет отправлен клиенту. Изображение должно быть PNG файлом. Если не указано, Sunshine пошлёт обложку по умолчанию.",
     "loading": "Загрузка...",
-    "name": "Наименование",
+    "name": "Название",
     "output_desc": "Файл, в котором сохраняется вывод команды, если он не указан, вывод игнорируется",
     "output_name": "Вывод",
     "run_as_desc": "Это может потребоваться для некоторых приложений, которым требуются права администратора для правильного запуска.",
-    "wait_all": "Продолжить вещание, пока не завершится все процессы приложения",
+    "wait_all": "Продолжать вещание, пока не завершатся все процессы приложения",
-    "wait_all_desc": "Это будет продолжаться, пока все процессы не будут запущены приложением. Если флажок не установлен, стриминг будет остановлен, когда начальный процесс завершится, даже если запущены другие процессы.",
+    "wait_all_desc": "Продолжать вещание, пока все процессы, запущенные приложением не будут завершены. Если не выбрано, вещание прекратится, по завершении начального процесса приложения, даже если запущены другие подпроцессы.",
     "working_dir": "Рабочая папка",
-    "working_dir_desc": "Рабочий каталог, передаваемый процессу. Например, некоторые приложения используют рабочий каталог для поиска конфигурационных файлов. Если не установлено, Apollo будет по умолчанию родительский каталог команды"
+    "working_dir_desc": "Рабочий каталог, передаваемый процессу. К примеру, некоторые приложения используют рабочий каталог для поиска конфигурационных файлов. Если не указан, Sunshine по умолчанию использует вышестоящий каталог команды"
   },
   "config": {
     "adapter_name": "Имя адаптера",
     "adapter_name_desc_linux_1": "Вручную укажите GPU для захвата.",
-    "adapter_name_desc_linux_2": "найти все устройства, способные к VAAPI",
+    "adapter_name_desc_linux_2": "найти все устройства, поддерживающие VAAPI",
-    "adapter_name_desc_linux_3": "Замените ``renderD129`` устройством сверху, чтобы перечислить имя и возможности устройства. Чтобы быть поддержанным Apollo, он должен иметь как минимум свое:",
+    "adapter_name_desc_linux_3": "Замените ``renderD129`` устройством сверху, чтобы перечислить имя и возможности устройства. Чтобы быть поддержанным Sunshine, он должен иметь как минимум свое:",
     "adapter_name_desc_windows": "Укажите GPU для захвата. Если флажок установлен, GPU выбирается автоматически. Мы настоятельно рекомендуем оставить это поле пустым, чтобы использовать автоматический выбор GPU! Примечание: этот GPU должен иметь дисплей подключён и включен. Соответствующие значения могут быть найдены с помощью следующей команды:",
     "adapter_name_placeholder_windows": "Radeon RX 580 серия",
     "add": "Добавить",
     "address_family": "Семейство адресов",
     "address_family_both": "IPv4 + IPv6",
-    "address_family_desc": "Установить семейство адресов, используемое Apollo",
+    "address_family_desc": "Установить семейство адресов, используемое Sunshine",
     "address_family_ipv4": "Только IPv4",
-    "always_send_scancodes": "Всегда отправлять коды",
+    "always_send_scancodes": "Всегда посылать коды клавиш",
-    "always_send_scancodes_desc": "Отправка scancodes улучшает совместимость с играми и приложениями, но может привести к неправильному вводу клавиатуры от некоторых клиентов, которые не используют американскую клавиатуру. Включите, если ввод клавиатуры вообще не работает в некоторых приложениях. Отключено, если ключи на клиенте генерируют неправильный входной параметр на хосте.",
+    "always_send_scancodes_desc": "Передача кодов клавиш улучшает совместимость с играми и приложениями, но может привести к неправильному вводу с клавиатуры, если клиент используют раскладку, отличную от английской США. Включите, если в каких-то приложениях ввод с клавиатуры не работает вовсе. Отключите, если клавиши клиента передают на ввод не те клавиши сервер.",
     "amd_coder": "AMF Coder (H264)",
     "amd_coder_desc": "Позволяет выбрать энтропическую кодировку для приоритизации скорости или качества кодирования. H.264 только.",
     "amd_enforce_hrd": "AMF Hypothetical Reference Decoder (HRD) Enforcement",
@@ -101,10 +101,10 @@
     "amd_preanalysis_desc": "Это позволяет проводить предварительный анализ скорости управления, который может повысить качество за счет увеличения задержки кодирования.",
     "amd_quality": "Качество AMF",
     "amd_quality_balanced": "сбалансированный -- сбалансированный (по умолчанию)",
-    "amd_quality_desc": "Это определяет баланс между скоростью кодирования и качеством.",
+    "amd_quality_desc": "Задаёт соотношение между скоростью и качеством кодирования.",
     "amd_quality_group": "Настройки качества AMF",
-    "amd_quality_quality": "качество -- предпочитаемое качество",
+    "amd_quality_quality": "качество -- упор на качество",
-    "amd_quality_speed": "скорость - скорость отдачи",
+    "amd_quality_speed": "скорость -- упор на скорость",
     "amd_rc": "Контроль скорости AMF",
     "amd_rc_cbr": "cbr -- постоянный битрейт",
     "amd_rc_cqp": "cqp -- постоянный режим qp",
@@ -121,27 +121,27 @@
     "amd_usage_webcam": "веб-камера -- веб-камера (медленно)",
     "amd_vbaq": "Адаптивное квантование на основе отклонений AMF (VBAQ)",
     "amd_vbaq_desc": "Как правило, визуальная система человека менее чувствительна к артефактам в особо текстурированных районах. В режиме VBAQ отклонение пикселей используется для обозначения сложности пространственной текстуры, что позволяет кодировщику выделять больше битов для более плавности зон. Включение этой функции приводит к улучшению субъективного качества зрения с некоторым содержимым.",
-    "apply_note": "Нажмите 'Применить', чтобы перезапустить Apollo и применить изменения. Все запущенные сессии будут завершены.",
+    "apply_note": "Нажмите 'Применить', чтобы перезапустить Sunshine и применить изменения. Все запущенные сессии будут завершены.",
     "audio_sink": "Снимок звука",
-    "audio_sink_desc_linux": "Название звуковой сигнала, используемой для аудиоциклов. Если эта переменная не указана, пульс будет выбирать стандартное устройство монитора. Вы можете найти название звуковой раковины, используя либо команду:",
+    "audio_sink_desc_linux": "Название звукового приёмника, используемого для обратной ретрансляции. Если эта переменная не указана, pulseaudio выберет устройство по умолчанию. Определить название звукового приёмника можно либо командой:",
-    "audio_sink_desc_macos": "Название звуковой раковины, используемой для аудиоциклов. Apollo может получить доступ только к микрофонам в macOS из-за ограничений системы. Для трансляции системного аудио с помощью Soundflower или BlackHole.",
+    "audio_sink_desc_macos": "Название звуковой раковины, используемой для аудиоциклов. Sunshine может получить доступ только к микрофонам в macOS из-за ограничений системы. Для трансляции системного аудио с помощью Soundflower или BlackHole.",
     "audio_sink_desc_windows": "Укажите вручную определённое аудиоустройство для записи. Если устройство выключено, оно выбирается автоматически. Рекомендуем оставить это поле пустым, чтобы использовать автоматический выбор устройств! Если у вас несколько аудио устройств с одинаковыми именами, вы можете получить ID устройства, используя следующую команду:",
     "audio_sink_placeholder_macos": "BlackHole 2ch",
     "audio_sink_placeholder_windows": "Динамики (High Definition Audio Device)",
     "av1_mode": "Поддержка AV1",
-    "av1_mode_0": "Apollo будет рекламировать поддержку AV1 на основе возможностей кодировщика (рекомендуется)",
+    "av1_mode_0": "Sunshine будет рекламировать поддержку AV1 на основе возможностей кодировщика (рекомендуется)",
-    "av1_mode_1": "Apollo не будет рекламировать поддержку AV1",
+    "av1_mode_1": "Sunshine не будет рекламировать поддержку AV1",
-    "av1_mode_2": "Apollo рекламирует поддержку AV1 Main 8-bit профиля",
+    "av1_mode_2": "Sunshine рекламирует поддержку AV1 Main 8-bit профиля",
-    "av1_mode_3": "Apollo будет рекламировать поддержку профилей AV1 Main 8-bit и 10-bit (HDR)",
+    "av1_mode_3": "Sunshine будет рекламировать поддержку профилей AV1 Main 8-bit и 10-bit (HDR)",
     "av1_mode_desc": "Позволяет клиенту запрашивать AV1 Main 8-bit или 10-битные видео потоки. AV1 является более интенсивным процессором для кодирования, поэтому включение этой опции может снизить производительность при использовании программного обеспечения.",
     "back_button_timeout": "Таймаут эмуляции кнопки Домой",
     "back_button_timeout_desc": "Если кнопка Назад/Выбор удерживается вниз для заданного количества миллисекунд, то кнопка Home/Guide будет эмулирована. Если установлено значение < 0 (по умолчанию), удерживая кнопку Назад/Выделение не будет эмулировать кнопку Домашний/Гид.",
     "capture": "Принудительный метод захвата",
-    "capture_desc": "В автоматическом режиме Apollo будет использовать первый работающий драйвер NvFBC.",
+    "capture_desc": "В автоматическом режиме Sunshine будет использовать первый работающий драйвер NvFBC.",
     "cert": "Сертификат",
-    "cert_desc": "Сертификат, используемый для пары клиентов веб-интерфейса и Moonlight, для лучшей совместимости должен иметь публичный ключ RSA-2048.",
+    "cert_desc": "Сертификат, используемый для веб-интерфейса и привязки клиентов Moonlight. Для совместимости должен иметь открытый ключ RSA-2048.",
     "channels": "Максимальное число подключенных клиентов",
-    "channels_desc_1": "Apollo позволяет одновременное совместное использование одного сеанса потокового вещания.",
+    "channels_desc_1": "Sunshine позволяет одновременное совместное использование одного сеанса потокового вещания.",
     "channels_desc_2": "Некоторые аппаратные кодировщики могут иметь ограничения, уменьшающие производительность с несколькими потоками.",
     "coder_cabac": "cabac -- контекстная адаптивная арифметическая кодировка - более высокое качество",
     "coder_cavlc": "cavlc -- контекстное адаптивное кодирование переменной длины - ускорение декодирования",
@@ -149,24 +149,23 @@
     "controller": "Enable Gamepad Input",
     "controller_desc": "Позволяет гостям контролировать хост-систему с помощью геймпада / контроллера",
     "credentials_file": "Файл учётных данных",
-    "credentials_file_desc": "Храните имя пользователя/пароль отдельно от файла состояния Apollo.",
+    "credentials_file_desc": "Храните имя пользователя/пароль отдельно от файла состояния Sunshine.",
     "ds4_back_as_touchpad_click": "Назад/Выберете для нажатия сенсорной панели",
     "ds4_back_as_touchpad_click_desc": "При принудительной эмуляции DS4, нажмите на карточку Назад/Выделение для сенсорной панели",
     "encoder": "Принудительный кодировщик",
-    "encoder_desc": "Принудительно использовать специальный кодировщик, в противном случае Apollo будет выбирать наилучший доступный вариант. Примечание: Если вы укажете аппаратный кодировщик в Windows, он должен соответствовать GPU, где установлен дисплей.",
+    "encoder_desc": "Принудительно использовать конкретный кодировщик, иначе Sunshine выберет наилучший доступный вариант. Примечание: Если указать аппаратный кодировщик в Windows, он должен соответствовать GPU, к которому подключён экран.",
     "encoder_software": "Программный",
     "external_ip": "Внешний IP",
-    "external_ip_desc": "Если внешний IP адрес не указан, Apollo будет автоматически определять внешний IP",
+    "external_ip_desc": "Если внешний IP адрес не указан, Sunshine будет автоматически определять внешний IP",
     "fec_percentage": "Процент FEC",
     "fec_percentage_desc": "Процент погрешности исправления пакетов по каждому пакету данных в каждом видеокадре. Более высокие значения могут корректно повлиять на потерю сетевых пакетов, но за счет увеличения пропускной способности.",
     "ffmpeg_auto": "auto -- пусть ffmpeg решить (по умолчанию)",
     "file_apps": "Файл приложений",
-    "file_apps_desc": "Файл, в котором хранятся текущие приложения Apollo.",
+    "file_apps_desc": "Файл, в котором хранятся текущие приложения Sunshine.",
-    "file_state": "Файл штата",
+    "file_state": "Файл состояния",
-    "file_state_desc": "Файл, в котором хранится текущее состояние Apollo",
+    "file_state_desc": "Файл, в котором хранится текущее состояние Sunshine",
-    "fps": "Рекламные FPS",
+    "gamepad": "Тип эмулируемого геймпада",
-    "gamepad": "Эмулированный тип геймпада",
+    "gamepad_auto": "Настройка автоматического выбора",
-    "gamepad_auto": "Автоматические настройки выбора",
     "gamepad_desc": "Выберите тип геймпада для эмулирования на хосте",
     "gamepad_ds4": "DS4 (PS4)",
     "gamepad_ds5": "DS5 (PS5)",
@@ -174,43 +173,43 @@
     "gamepad_manual": "Ручные настройки DS4",
     "gamepad_x360": "X360 (Xbox 360)",
     "gamepad_xone": "XOne (Xbox One)",
-    "global_prep_cmd": "Подготовка команд",
+    "global_prep_cmd": "Команды подготовки",
     "global_prep_cmd_desc": "Настроить список команд, которые будут выполнены до или после запуска любого приложения. Если какая-либо из указанных команд подготовки не удается, процесс запуска приложения будет прерван.",
     "hevc_mode": "Поддержка HEVC",
-    "hevc_mode_0": "Apollo будет рекламировать поддержку HEVC на основе возможностей кодировщика (рекомендуется)",
+    "hevc_mode_0": "Sunshine будет рекламировать поддержку HEVC на основе возможностей кодировщика (рекомендуется)",
-    "hevc_mode_1": "Apollo не будет рекламировать поддержку HEVC",
+    "hevc_mode_1": "Sunshine не будет рекламировать поддержку HEVC",
-    "hevc_mode_2": "Apollo будет рекламировать поддержку HEVC Main",
+    "hevc_mode_2": "Sunshine будет рекламировать поддержку HEVC Main",
-    "hevc_mode_3": "Apollo будет рекламировать поддержку профилей HEVC Main и Main10 (HDR)",
+    "hevc_mode_3": "Sunshine будет рекламировать поддержку профилей HEVC Main и Main10 (HDR)",
     "hevc_mode_desc": "Позволяет клиенту запрашивать HEVC Main или HEVC Main10 видео потоков. HEVC является более процессорным в кодировке, поэтому включение этой опции может снизить производительность при использовании программного обеспечения.",
     "high_resolution_scrolling": "Поддержка прокрутки высокого разрешения",
-    "high_resolution_scrolling_desc": "Когда включено, Apollo будет прокручивать события с высоким разрешением от клиентов лунного света. Это может быть полезно для отключения для старых приложений, которые слишком быстро прокручивать при прокрутке событий высокого разрешения.",
+    "high_resolution_scrolling_desc": "Когда включено, Sunshine будет прокручивать события с высоким разрешением от клиентов лунного света. Это может быть полезно для отключения для старых приложений, которые слишком быстро прокручивать при прокрутке событий высокого разрешения.",
     "install_steam_audio_drivers": "Установить Steam Audio Drivers",
-    "install_steam_audio_drivers_desc": "Если Steam установлен, он автоматически установит драйвер Steam Streaming Speakers для поддержки 5.1/7.1 объемного звука и отключения хоста.",
+    "install_steam_audio_drivers_desc": "Если Steam установлен, он автоматически установит драйвер Steam Streaming Speakers для поддержки объёмного звука 5.1/7.1 и заглушения звука на сервере.",
-    "key_repeat_delay": "Задержка повтора ключа",
+    "key_repeat_delay": "Задержка повтора нажатий",
-    "key_repeat_delay_desc": "Контролируйте как быстрые клавиши будут повторяться. Первоначальная задержка в миллисекундах перед повтором ключей.",
+    "key_repeat_delay_desc": "Контролируйте как быстрые клавиши будут повторяться. Начальная задержка в миллисекундах до повторных нажатий.",
-    "key_repeat_frequency": "Частота повторения ключа",
+    "key_repeat_frequency": "Частота повторения нажатий",
-    "key_repeat_frequency_desc": "Как часто ключи повторяют каждую секунду. Эта настраиваемая опция поддерживает десятичные дроби.",
+    "key_repeat_frequency_desc": "Как часто нажатия повторяются за секунду. Эта настройка поддерживает десятичные дроби.",
-    "key_rightalt_to_key_windows": "Карта клавиши Alt справа для клавиши Windows",
+    "key_rightalt_to_key_windows": "Переопределить клавишу правый Alt как клавишу Windows",
-    "key_rightalt_to_key_win_desc": "Возможно, вы не можете отправить ключ Windows непосредственно с лунного света. В этих случаях было бы полезно заставить Солнечный свет думать, что ключ правой Alt является клавишей Windows",
+    "key_rightalt_to_key_win_desc": "Возможно, вы не можете послать нажатие кнопки Windows непосредственно из Moonlight. В таком случае, полезно чтобы Sunshine думал, что клавиша правый Alt является клавишей Windows",
-    "keyboard": "Включить ввод клавиатуры",
+    "keyboard": "Включить ввод с клавиатуры",
     "keyboard_desc": "Позволяет гостям управлять системой хоста с помощью клавиатуры",
     "lan_encryption_mode": "Режим шифрования LAN",
     "lan_encryption_mode_1": "Включено для поддерживаемых клиентов",
     "lan_encryption_mode_2": "Требуется для всех клиентов",
-    "lan_encryption_mode_desc": "Определяет, когда шифрование будет использоваться при потоке по локальной сети. Шифрование может снизить производительность потокового вещания, особенно на менее мощных узлах и клиентах.",
+    "lan_encryption_mode_desc": "Определяет, когда шифрование будет использоваться при вещании в локальной сети. Шифрование может снизить качество вещания, особенно на более слабых серверах и клиентах.",
     "locale": "Язык",
-    "locale_desc": "Локализация, используемая для пользовательского интерфейса Apollo.",
+    "locale_desc": "Локализация, используемая для пользовательского интерфейса Sunshine.",
-    "log_level": "Уровень журнала",
+    "log_level": "Уровень журналирования",
-    "log_level_0": "Verbose",
+    "log_level_0": "Подробные",
-    "log_level_1": "Debug",
+    "log_level_1": "Отладочные",
-    "log_level_2": "Инфо",
+    "log_level_2": "Информация",
-    "log_level_3": "Предупреждение",
+    "log_level_3": "Предупреждения",
-    "log_level_4": "Ошибка",
+    "log_level_4": "Ошибки",
-    "log_level_5": "Fatal",
+    "log_level_5": "Критические",
     "log_level_6": "Нет",
-    "log_level_desc": "Минимальный уровень журнала, напечатанный по стандарту",
+    "log_level_desc": "Минимальный log level выведен в stdout",
-    "log_path": "Путь к лог-файлу",
+    "log_path": "Путь к файлу журнала",
-    "log_path_desc": "Файл, в котором хранятся текущие журналы Apollo.",
+    "log_path_desc": "Файл, в котором хранятся текущие журналы Sunshine.",
     "min_fps_factor": "Минимальный коэффициент FPS",
     "min_fps_factor_desc": "Солнечный свет будет использовать этот фактор для расчета минимального времени между рамками. Увеличение этого значения может помочь при потоке в основном статического контента. Более высокие значения будут потреблять больше пропускной способности.",
     "min_threads": "Минимальное количество потоков ЦП",
@@ -221,16 +220,16 @@
     "mouse": "Включить ввод мыши",
     "mouse_desc": "Позволяет гостям контролировать хост-систему мышкой",
     "native_pen_touch": "Родная Pencil/Touch поддержка",
-    "native_pen_touch_desc": "Если включено, Apollo будет проходить через родные события pen/touch от клиентов Moonlight. Это может быть полезно для более старых приложений без поддержки pen/touch .",
+    "native_pen_touch_desc": "Если включено, Sunshine будет проходить через родные события pen/touch от клиентов Moonlight. Это может быть полезно для более старых приложений без поддержки pen/touch .",
     "notify_pre_releases": "Уведомления о предварительном выпуске",
-    "notify_pre_releases_desc": "Уведомлять ли о новых предварительных версиях Apollo",
+    "notify_pre_releases_desc": "Уведомлять ли о новых предварительных версиях Sunshine",
     "nvenc_h264_cavlc": "Предпочитайте CAVLC поверх CABAC в H.264",
     "nvenc_h264_cavlc_desc": "Форма кодирования энтропии. CAVLC требует на 10% больше битрейта для того же качества. Только для очень старых декодирующих устройств.",
     "nvenc_latency_over_power": "Предпочитайте более низкую задержку кодирования по сравнению с экономией энергии",
-    "nvenc_latency_over_power_desc": "Apollo requests maximum GPU clock speed while streaming to reduce encoding latency. Отключение этого значения не рекомендуется, так как это может привести к значительному увеличению задержки кодирования.",
+    "nvenc_latency_over_power_desc": "Sunshine requests maximum GPU clock speed while streaming to reduce encoding latency. Отключение этого значения не рекомендуется, так как это может привести к значительному увеличению задержки кодирования.",
     "nvenc_opengl_vulkan_on_dxgi": "Настоящий OpenGL/Vulkan на вершине DXGI",
-    "nvenc_opengl_vulkan_on_dxgi_desc": "Apollo не может захватывать полноэкранные программы OpenGL и Vulkan с полной скоростью кадра, если они не присутствуют поверх DXGI. Это общесистемная настройка, которая возвращается при выходе из программы.",
+    "nvenc_opengl_vulkan_on_dxgi_desc": "Sunshine не может захватывать полноэкранные программы OpenGL и Vulkan с полной скоростью кадра, если они не присутствуют поверх DXGI. Это общесистемная настройка, которая возвращается при выходе из программы.",
-    "nvenc_preset": "Пресет производительности",
+    "nvenc_preset": "Преднастройка производительности",
     "nvenc_preset_1": "(быстрый, по умолчанию)",
     "nvenc_preset_7": "(медленно)",
     "nvenc_preset_desc": "Более высокие значения улучшают сжатие (качество на заданном битрейте) за счет увеличения задержки кодирования. Рекомендуется изменять только когда ограничено сетью или декодером, в противном случае подобный эффект может быть достигнут путем увеличения битрейта.",
@@ -247,111 +246,111 @@
     "nvenc_twopass_quarter_res": "Квартальное разрешение (по умолчанию)",
     "nvenc_vbv_increase": "Однокадровое увеличение VBV/HRD",
     "nvenc_vbv_increase_desc": "По умолчанию солнечный свет использует однокадровый VBV/HRD, что означает, что любой кодируемый размер видеокадра не должен превышать запрашиваемый битрейт, поделенный на заданную скорость кадра. Расслабляя это ограничение может быть полезным и выступать в качестве битрейта с низкой задержкой, но может также привести к потере пакетов, если в сети нет заголовка буфера для обработки битрейтов. Максимально допустимое значение - 400, что соответствует 5-кратному увеличенному пределу видеокадра в кодировке.",
-    "origin_web_ui_allowed": "Оригинальный Web UI разрешён",
+    "origin_web_ui_allowed": "Веб-интерфейс Origin разрешён",
-    "origin_web_ui_allowed_desc": "Источник адреса удаленной конечной точки, который не запрещает доступ к Web UI",
+    "origin_web_ui_allowed_desc": "Источник адреса удаленной конечной точки, которой не запрещён доступ к веб-интерфейсу",
-    "origin_web_ui_allowed_lan": "Только в LAN могут получить доступ к Web UI",
+    "origin_web_ui_allowed_lan": "Только из LAN могут получить доступ к веб-интерфейсу",
-    "origin_web_ui_allowed_pc": "Только локальный хост может получить доступ к Web UI",
+    "origin_web_ui_allowed_pc": "Только локальный ПК имеет доступ к веб-интерфейсу",
-    "origin_web_ui_allowed_wan": "Любой может получить доступ к веб-интерфейсу",
+    "origin_web_ui_allowed_wan": "Любой имеет доступ к веб-интерфейсу",
-    "output_name_desc_unix": "Во время запуска Apollo вы увидите список обнаруженных дисплей. Примечание: используйте id значение внутри скобки.",
+    "output_name_desc_unix": "Во время запуска Sunshine вы увидите список обнаруженных экранов. Примечание: используйте значение id в скобках. Пример ниже; нужный экран можно обнаружить на вкладке Устранение проблем.",
-    "output_name_desc_windows": "Вручную укажите дисплей для захвата. Если не установлено, то будет произведен захват основного экрана. Примечание: Если вы указали GPU выше, этот экран должен быть подключен к этому GPU. Соответствующие значения могут быть найдены с помощью следующей команды:",
+    "output_name_desc_windows": "Вручную укажите экран для захвата. Если не указано, то будет произведён захват основного экрана. Примечание: Если вы ранее указали GPU, этот экран должен быть подключен к тому GPU. Подходящие значения определяются с помощью следующей команды:",
-    "output_name_unix": "Отобразить номер",
+    "output_name_unix": "Номер экрана",
     "output_name_windows": "Имя вывода",
     "ping_timeout": "Таймаут пинга",
-    "ping_timeout_desc": "Как долго ждать в миллисекундах данных с лунного света перед выключением потока",
+    "ping_timeout_desc": "Время ожидания данных от Moonlight до завершения вещания, в миллисекундах",
-    "pkey": "Приватный ключ",
+    "pkey": "Закрытый ключ",
-    "pkey_desc": "Приватный ключ, используемый для пары клиентов Moonlight. Для лучшей совместимости это должен быть приватный ключ RSA-2048.",
+    "pkey_desc": "Закрытый ключ, используемый для веб-интерфейса и привязки клиентов Moonlight. Для совместимости должен быть закрытым ключом RSA-2048.",
     "port": "Порт",
-    "port_alert_1": "Солнечный свет не может использовать порты ниже 1024!",
+    "port_alert_1": "Sunshine не может использовать порты ниже 1024!",
     "port_alert_2": "Порты выше 65535 недоступны!",
-    "port_desc": "Установить семейство портов, используемых Apollo",
+    "port_desc": "Установить семейство портов, используемых Sunshine",
-    "port_http_port_note": "Используйте этот порт для соединения с лунным светом.",
+    "port_http_port_note": "Используйте этот порт для соединения с Moonlight.",
     "port_note": "Примечание",
     "port_port": "Порт",
-    "port_protocol": "Protocol",
+    "port_protocol": "Протокол",
     "port_tcp": "TCP",
     "port_udp": "UDP",
-    "port_warning": "Размещение веб-интерфейса в Интернете является риском для безопасности! Продолжайте на свой страх и риск!",
+    "port_warning": "Доступность веб-интерфейса из Интернета не безопасна! Продолжайте на свой страх и риск!",
-    "port_web_ui": "Web UI",
+    "port_web_ui": "Веб-интерфейс",
-    "qp": "Параметр количественного измерения",
+    "qp": "Параметр квантования",
-    "qp_desc": "Некоторые устройства могут не поддерживать постоянную ставку бит. Для этих устройств используется QP. Более высокое значение означает больше сжатия, но меньшее качество.",
+    "qp_desc": "Некоторые устройства могут не поддерживать постоянную ширину поток. Для таких устройств используется параметр квантования. Более высокое значение означает большее сжатие, но меньшее качество.",
-    "qsv_coder": "QuickSync Coder (H264)",
+    "qsv_coder": "Кодировщик QuickSync (H264)",
-    "qsv_preset": "QuickSync Preset",
+    "qsv_preset": "Предустановка QuickSync",
-    "qsv_preset_fast": "быстрее (меньшее качество)",
+    "qsv_preset_fast": "fast (низкое качество)",
-    "qsv_preset_faster": "самый быстрый (низкое качество)",
+    "qsv_preset_faster": "faster (худшее качество)",
-    "qsv_preset_medium": "среднее (по умолчанию)",
+    "qsv_preset_medium": "medium (по умолчанию)",
-    "qsv_preset_slow": "медленно (хорошее качество)",
+    "qsv_preset_slow": "slow (хорошее качество)",
-    "qsv_preset_slower": "медленнее (лучшее качество)",
+    "qsv_preset_slower": "slower (отличное качество)",
-    "qsv_preset_slowest": "самый медленный (лучшее качество)",
+    "qsv_preset_slowest": "slowest (лучшее качество)",
     "qsv_preset_veryfast": "самый быстрый (низкое качество)",
     "qsv_slow_hevc": "Разрешить Slow HEVC кодирование",
     "qsv_slow_hevc_desc": "Это позволяет включить HEVC кодирование на старых процессорах Intel за счет более высокого использования GPU и более низкой производительности.",
-    "res_fps_desc": "Режимы демонстрации, рекламируемые Apollo. Некоторые версии Moonlight, такие как Moonlight-nx (Switch), полагаются на эти списки, чтобы обеспечить поддержку запрашиваемых резолюций и fps. Этот параметр не изменяет способа передачи экрана на Луну.",
+    "restart_note": "Sunshine перезапускается, чтобы применить изменения.",
-    "resolutions": "Рекламные резолюции",
+    "sunshine_name": "Название сервера Sunshine",
-    "restart_note": "Apollo перезапускается, чтобы применить изменения.",
+    "sunshine_name_desc": "Имя сервера, отображаемое в Moonlight. Если не указано, используется имя ПК",
-    "sunshine_name": "Название сервиса Apollo",
+    "sw_preset": "Предустановки программного кодирования",
-    "sunshine_name_desc": "Имя хоста, отображаемое при Moonlight. Если не указано, используется имя хоста",
-    "sw_preset": "SW пресеты",
     "sw_preset_desc": "Оптимизировать компромисс между скоростью кодирования (кодированные кадры в секунду) и эффективностью сжатия (качество за бит в bitstream). По умолчанию супербыстро.",
     "sw_preset_fast": "быстро",
     "sw_preset_faster": "быстрее",
     "sw_preset_medium": "средняя",
     "sw_preset_slow": "медленно",
     "sw_preset_slower": "медленнее",
-    "sw_preset_superfast": "супербыстрый (по умолчанию)",
+    "sw_preset_superfast": "сверхбыстро (по умолчанию)",
-    "sw_preset_ultrafast": "ультразвук",
+    "sw_preset_ultrafast": "ультрабыстро",
     "sw_preset_veryfast": "veryfast",
     "sw_preset_veryslow": "veryslow",
-    "sw_tune": "SW Tune",
+    "sw_tune": "Подстройки Программного кодирования",
-    "sw_tune_animation": "анимация -- подходит для мультфильмов, использует более высокую блокировку и больше эталонных кадров",
+    "sw_tune_animation": "animation -- подходит для мультфильмов, использует агрессивное подавление блочности и больше опорных кадров",
-    "sw_tune_desc": "Настройка параметров, применяемых после пресета. По умолчанию нулевая настройка.",
+    "sw_tune_desc": "Подстроечные параметры, применяемые после предустановки. По умолчанию zerolatency.",
-    "sw_tune_fastdecode": "fastdecode -- позволяет ускорить декодирование, отключив некоторые фильтры",
+    "sw_tune_fastdecode": "fastdecode -- позволяет ускорить декодирование отключением некоторых фильтров",
-    "sw_tune_film": "фильм -- используется для высококачественного содержания фильма; снижает блокировку",
+    "sw_tune_film": "фильм -- используется для высококачественного кино; меньше подавляет блочность",
-    "sw_tune_grain": "зерно - сохраняет структуру зерна в старых, зернистых пленках",
+    "sw_tune_grain": "grain -- предаёт зернистость старой фотоплёнки",
-    "sw_tune_stillimage": "stillimage -- подходит для содержимого как слайд-шоу",
+    "sw_tune_stillimage": "stillimage -- хорош для малоподвижных изображений",
-    "sw_tune_zerolatency": "zerolatency -- подходит для быстрой кодировки и потокового низкозадержки (по умолчанию)",
+    "sw_tune_zerolatency": "zerolatency -- хорош для быстрого кодирования и вещания с низкой задержкой (по умолчанию)",
-    "touchpad_as_ds4": "Эмулируйте геймпад DS4, если клиент сообщает, что сенсорная панель присутствует",
+    "touchpad_as_ds4": "Эмулировать геймпад DS4, если клиент сообщает, о наличии сенсорной панели",
     "touchpad_as_ds4_desc": "Если отключено, присутствие сенсорной панели не будет учитываться при выборе типа геймпада.",
     "upnp": "UPnP",
-    "upnp_desc": "Автоматически настраивать переадресацию портов для трансляции через Интернет",
+    "upnp_desc": "Автоматически настраивать переадресацию портов для вещания через Интернет",
-    "virtual_sink": "Виртуальный снимок",
+    "vaapi_strict_rc_buffer": "Строго применять ограничения скорости битрейта для H.264/HEVC на AMD GPU",
-    "virtual_sink_desc": "Вручную укажите виртуальное аудио устройство. Если установлено, устройство будет выбрано автоматически. Рекомендуем оставить это поле пустым, чтобы использовать автоматический выбор устройств!",
+    "vaapi_strict_rc_buffer_desc": "Включение этой опции позволит избежать сброса кадров по сети во время изменения сцен, но во время движения качество видео может быть снижено.",
+    "virtual_sink": "Виртуальный приёмник",
+    "virtual_sink_desc": "Вручную укажите виртуальное аудио устройство. Если не указано, устройство будет выбрано автоматически. Рекомендуем оставить это поле пустым, для автоматического выбора устройств!",
     "virtual_sink_placeholder": "Динамики Steam",
-    "vt_coder": "VideoToolbox Coder",
+    "vt_coder": "Кодировщик VideoToolbox",
-    "vt_realtime": "VideoToolbox в реальном времени кодирования",
+    "vt_realtime": "Кодирование в реальном времени через VideoToolbox",
-    "vt_software": "Программное кодирование VideoToolbox",
+    "vt_software": "Программное кодирование через VideoToolbox",
     "vt_software_allowed": "Разрешено",
     "vt_software_forced": "Принудительно",
     "wan_encryption_mode": "Режим шифрования WAN",
     "wan_encryption_mode_1": "Включено для поддерживаемых клиентов (по умолчанию)",
     "wan_encryption_mode_2": "Требуется для всех клиентов",
-    "wan_encryption_mode_desc": "Определяет, когда шифрование будет использоваться при потоке через Интернет. Шифрование может снизить производительность потокового вещания, особенно на менее мощных хостах и клиентах."
+    "wan_encryption_mode_desc": "Определяет, когда будет использоваться шифрование при вещании через Интернет. Шифрование может снизить качество вещания, особенно на более слабых серверах и клиентах."
   },
   "index": {
-    "description": "Apollo - это хост для самостоятельной игры на Лунном свете.",
+    "description": "Sunshine - это ваш собственный сервер вещания игр для Moonlight.",
     "download": "Скачать",
-    "installed_version_not_stable": "Вы используете предварительную версию Apollo. Вы можете столкнуться с ошибками или другими проблемами. Пожалуйста, сообщайте о проблемах, с которыми вы столкнулись. Благодарим вас за помощь в создании программного обеспечения для Apollo!",
+    "installed_version_not_stable": "Вы используете предварительную версию Sunshine. Вы можете столкнуться с ошибками или другими проблемами. Пожалуйста, сообщайте о проблемах, с которыми вы столкнётесь. Благодарим за помощь по улучшению Sunshine!",
-    "loading_latest": "Загрузка последней версии...",
+    "loading_latest": "Загрузка свежей версии...",
     "new_pre_release": "Доступна новая предварительная версия!",
     "new_stable": "Доступна новая стабильная версия!",
-    "startup_errors": "<b>Внимание!</b> Apollo обнаружил эти ошибки во время запуска. Мы <b>НАСТОЯТЕЛЬНО РЕКОМЕНДУЕМ</b> исправить их перед началом трансляции.",
+    "startup_errors": "<b>Внимание!</b> Sunshine обнаружил эти ошибки во время запуска. Мы <b>НАСТОЯТЕЛЬНО РЕКОМЕНДУЕМ</b> исправить их перед запуском вещания.",
-    "version_dirty": "Спасибо за помощь в создании программного обеспечения Apollo!",
+    "version_dirty": "Спасибо за помощь в создании программного обеспечения Sunshine!",
-    "version_latest": "Вы используете последнюю версию Apollo",
+    "version_latest": "Вы используете свежую версию Sunshine",
-    "welcome": "Здравствуйте, Солнце!"
+    "welcome": "Привет, Sunshine!"
   },
   "navbar": {
     "applications": "Приложения",
-    "configuration": "Конфигурация",
+    "configuration": "Настройки",
-    "home": "Домашний",
+    "home": "Главная",
     "password": "Изменить пароль",
-    "pin": "Закрепить",
+    "pin": "Pin",
-    "theme_auto": "Авто",
+    "theme_auto": "Автоматически",
-    "theme_dark": "Тёмная",
+    "theme_dark": "Тёмное",
-    "theme_light": "Светлая",
+    "theme_light": "Светлое",
-    "toggle_theme": "Тема",
+    "toggle_theme": "Оформление",
     "troubleshoot": "Устранение проблем"
   },
   "password": {
-    "confirm_password": "Подтверждение пароля",
+    "confirm_password": "Подтвердите пароль",
     "current_creds": "Текущие учетные данные",
     "new_creds": "Новые учетные данные",
     "new_username_desc": "Если не указано, имя пользователя не изменится",
@@ -360,49 +359,49 @@
   },
   "pin": {
     "device_name": "Имя устройства",
-    "pair_failure": "Соединение не удалось: проверьте, правильно ли введен PIN-код",
+    "pair_failure": "Не удалось привязать: проверьте, правильность PIN-кода",
-    "pair_success": "Успех! Пожалуйста, отметьте Лунный свет для продолжения",
+    "pair_success": "Успешно! Перейдите в Moonlight для продолжения",
-    "pin_pairing": "PIN Pairing",
+    "pin_pairing": "PIN привязки",
     "send": "Отправить",
-    "warning_msg": "Убедитесь, что у вас есть доступ к клиенту, с которым вы сотрудничаете. Это программное обеспечение может дать полный контроль вашему компьютеру, так что будьте осторожны!"
+    "warning_msg": "Убедитесь, что клиент, который вы привязываете доступен. Данное ПО может передать полный контроль над вашим компьютером, так что будьте осторожны!"
   },
   "resource_card": {
     "github_discussions": "GitHub Discussions",
     "legal": "Юридическая информация",
-    "legal_desc": "Продолжая использовать программное обеспечение, вы соглашаетесь с условиями в следующих документах.",
+    "legal_desc": "Используя данное ПО, вы соглашаетесь с условиями, изложенными в следующих документах.",
     "license": "Лицензия",
     "lizardbyte_website": "Сайт LizardByte",
-    "resources": "Ресурсы",
+    "resources": "Полезные источники",
-    "resources_desc": "Ресурсы Apollo!",
+    "resources_desc": "Полезные ресурсы, посвящённые Sunshine!",
-    "third_party_notice": "Уведомление о третьих лицах"
+    "third_party_notice": "Уведомление о третьих сторонах"
   },
   "troubleshooting": {
     "force_close": "Принудительное закрытие",
-    "force_close_desc": "Если Moonlight жалуется на запущенное приложение, принудительное закрытие приложения устранит проблему.",
+    "force_close_desc": "Если Moonlight жалуется на запущенное приложение, принудительное закрытие приложения должно помочь.",
     "force_close_error": "Ошибка при закрытии приложения",
-    "force_close_success": "Заявка успешно закрыта!",
+    "force_close_success": "Приложение закрыто успешно!",
-    "logs": "Логи",
+    "logs": "Журналы",
-    "logs_desc": "Смотреть журналы, загруженные Apollo",
+    "logs_desc": "Смотреть журналы, выгруженные Sunshine",
     "logs_find": "Найти...",
-    "restart_apollo": "Перезапустить солнечный свет",
+    "restart_sunshine": "Перезапустить Sunshine",
-    "restart_apollo_desc": "Если Apollo работает некорректно, вы можете попробовать перезапустить его. Это прекратит работу всех запущенных сессий.",
+    "restart_sunshine_desc": "Если Sunshine работает некорректно, вы можете попробовать перезапустить его. Это прекратит работу всех запущенных сеансов.",
-    "restart_apollo_success": "Солнечный свет перезапускается",
+    "restart_sunshine_success": "Sunshine перезапускается",
     "troubleshooting": "Устранение проблем",
-    "unpair_all": "Отменить все",
+    "unpair_all": "Отвязать все",
-    "unpair_all_error": "Ошибка при отмене подключения",
+    "unpair_all_error": "Ошибка при отвязывании",
-    "unpair_all_success": "Успешное восстановление!",
+    "unpair_all_success": "Все устройства отвязаны.",
-    "unpair_desc": "Удалите ваши сопряженные устройства. Отдельные несвязанные устройства с активным сеансом останутся подключенными, но не могут начать или возобновить сессию.",
+    "unpair_desc": "Удалите свои привязанные устройства. Устройства с активным сеансом, отвязанные по одному, останутся подключенными, но не смогут начать или возобновить сеанс.",
-    "unpair_single_no_devices": "Нет сопряженных устройств.",
+    "unpair_single_no_devices": "Нет привязанных устройств.",
-    "unpair_single_success": "Однако устройство (устройства) все еще может находиться в активном сеансе. Используйте кнопку «Закрыть» выше для завершения любых открытых сеансов.",
+    "unpair_single_success": "Однако, устройство (устройства) может находиться в имеющемся сеансе. Воспользуйтесь кнопкой «Принудительное закрытие» выше для завершения всех сеансов.",
     "unpair_single_unknown": "Неизвестный клиент",
-    "unpair_title": "Непарные устройства"
+    "unpair_title": "Отвязать устройства"
   },
   "welcome": {
     "confirm_password": "Подтвердите пароль",
-    "create_creds": "Перед началом работы нам нужно сделать новый логин и пароль для доступа к Web UI.",
+    "create_creds": "Перед началом работы нам нужно создать новые логин и пароль для доступа к веб-интерфейсу.",
-    "create_creds_alert": "Учетные данные, указанные ниже, необходимы для доступа к сетевому интерфейсу Apollo. Храните их в безопасности, так как вы никогда их не увидите снова!",
+    "create_creds_alert": "Учетные данные, указанные ниже, необходимы для доступа к веб-интерфейсу Sunshine. Сохраните их в надёжном месте, так как больше вы их не увидите!",
-    "greeting": "Добро пожаловать в Apollo!",
+    "greeting": "Добро пожаловать в Sunshine!",
-    "login": "Логин",
+    "login": "Вход",
     "welcome_success": "Эта страница скоро перезагрузится, ваш браузер запросит новые учетные данные"
   }
 }

src_assets/common/assets/web/public/assets/locale/sv.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Om inaktiverad, kommer närvaro av pekplatta inte att beaktas under val av speltyp.",
     "upnp": "UPPNP",
     "upnp_desc": "Konfigurera portvidarebefordran automatiskt för streaming över Internet",
+    "vaapi_strict_rc_buffer": "Strikt genomdriva rambitrate gränser för H.264/HEVC på AMD GPU",
+    "vaapi_strict_rc_buffer_desc": "Om du aktiverar det här alternativet kan du undvika tappade ramar över nätverket under scenändringar, men videokvaliteten kan minskas under rörelse.",
     "virtual_sink": "Virtuell sink",
     "virtual_sink_desc": "Ange manuellt en virtuell ljudenhet som ska användas. Om enheten inte är inställd väljs enheten automatiskt. Vi rekommenderar starkt att lämna detta fält tomt för att använda automatiskt val av enhet!",
     "virtual_sink_placeholder": "Steam-strömmande högtalare",

src_assets/common/assets/web/public/assets/locale/tr.json

@@ -313,6 +313,8 @@
     "touchpad_as_ds4_desc": "Devre dışı bırakılırsa, oyun kumandası türü seçimi sırasında dokunmatik yüzey varlığı dikkate alınmaz.",
     "upnp": "UPnP",
     "upnp_desc": "İnternet üzerinden akış için port yönlendirmeyi otomatik olarak yapılandırın",
+    "vaapi_strict_rc_buffer": "AMD GPU'larda H.264/HEVC için kare bit hızı sınırlarını kesin olarak uygulayın",
+    "vaapi_strict_rc_buffer_desc": "Bu seçeneğin etkinleştirilmesi, sahne değişiklikleri sırasında ağ üzerinden karelerin düşmesini önleyebilir, ancak hareket sırasında video kalitesi düşebilir.",
     "virtual_sink": "Sanal Lavabo",
     "virtual_sink_desc": "Kullanılacak sanal ses cihazını manuel olarak belirleyin. Ayarlanmamışsa, cihaz otomatik olarak seçilir. Otomatik cihaz seçimini kullanmak için bu alanı boş bırakmanızı şiddetle tavsiye ederiz!",
     "virtual_sink_placeholder": "Steam Akış Hoparlörleri",

src_assets/common/assets/web/public/assets/locale/zh.json

@@ -353,6 +353,8 @@
     "touchpad_as_ds4_desc": "如果禁用，则在选择游戏手柄类型时不会考虑触摸板的存在。",
     "upnp": "UPnP",
     "upnp_desc": "为公网串流自动配置端口转发",
+    "vaapi_strict_rc_buffer": "在AMD GPU上严格强制执行H.264/HEVC帧比特率限制",
+    "vaapi_strict_rc_buffer_desc": "启用此选项可以在场景更改时避免在网络上放置帧，但在移动时可能会降低视频质量。",
     "virtual_sink": "虚拟音频输出设备",
     "virtual_sink_desc": "当客户端禁止PC播放音频时使用的音频输出设备。\n如未指定，则将自动选择。\n我们强烈建议将此字段留空，以便使用自动设备选择！",
     "virtual_sink_placeholder": "Steam Streaming Speakers",

tests/unit/platform/test_common.cpp

@@ -4,6 +4,8 @@
  */
 #include <src/platform/common.h>
 
+#include <boost/asio/ip/host_name.hpp>
+
 #include "../../tests_common.h"
 
 struct SetEnvTest: ::testing::TestWithParam<std::tuple<std::string, std::string, int>> {
@@ -47,3 +49,8 @@ INSTANTIATE_TEST_SUITE_P(
     std::make_tuple("SUNSHINE_UNIT_TEST_ENV_VAR", "test_value_0", 0),
     std::make_tuple("SUNSHINE_UNIT_TEST_ENV_VAR", "test_value_1", 0),
     std::make_tuple("", "test_value", -1)));
+
+TEST(HostnameTests, TestAsioEquality) {
+  // These should be equivalent on all platforms for ASCII hostnames
+  ASSERT_EQ(platf::get_host_name(), boost::asio::ip::host_name());
+}

vite.config.js

@@ -20,13 +20,22 @@ if (process.env.SUNSHINE_BUILD_HOMEBREW) {
     console.log("Building for homebrew, using default paths")
 }
 else {
+    // If the paths supplied in the environment variables contain any symbolic links
+    // at any point in the series of directories, the entire build will fail with
+    // a cryptic error message like this:
+    //     RollupError: The "fileName" or "name" properties of emitted chunks and assets
+    //     must be strings that are neither absolute nor relative paths.
+    // To avoid this, we resolve the potential symlinks using `fs.realpathSync` before
+    // doing anything else with the paths.
     if (process.env.SUNSHINE_SOURCE_ASSETS_DIR) {
-        console.log("Using srcdir from Cmake: " + resolve(process.env.SUNSHINE_SOURCE_ASSETS_DIR,"common/assets/web"));
+        let path = resolve(fs.realpathSync(process.env.SUNSHINE_SOURCE_ASSETS_DIR), "common/assets/web");
-        assetsSrcPath = resolve(process.env.SUNSHINE_SOURCE_ASSETS_DIR,"common/assets/web")
+        console.log("Using srcdir from Cmake: " + path);
+        assetsSrcPath = path;
     }
     if (process.env.SUNSHINE_ASSETS_DIR) {
-        console.log("Using destdir from Cmake: " + resolve(process.env.SUNSHINE_ASSETS_DIR,"assets/web"));
+        let path = resolve(fs.realpathSync(process.env.SUNSHINE_ASSETS_DIR), "assets/web");
-        assetsDstPath = resolve(process.env.SUNSHINE_ASSETS_DIR,"assets/web")
+        console.log("Using destdir from Cmake: " + path);
+        assetsDstPath = path;
     }
 }