feat(nvenc): support for split frame encoding on GPUs with 2+ nvenc blocks. Ported from #3061

Author: andygrundman

docs/configuration.md

@@ -2347,6 +2347,46 @@ editing the `conf` file in a text editor. Use the examples as reference.
     </tr>
 </table>
 
+### nvenc_split_encode
+
+<table>
+    <tr>
+        <td>Description</td>
+        <td colspan="2">
+            Split the encoding of each video frame over multiple NVENC hardware units.
+            Significantly reduces encoding latency with a marginal compression efficiency penalty.
+            This option is ignored if your GPU has a singular NVENC unit.
+            @note{This option only applies when using NVENC [encoder](#encoderhttpslocalhost47990configencoder) with HEVC or AV1.}
+            @note{Applies to Windows only.}
+        </td>
+    </tr>
+    <tr>
+        <td>Default</td>
+        <td colspan="2">@code{}
+            driver_decides
+            @endcode</td>
+    </tr>
+    <tr>
+        <td>Example</td>
+        <td colspan="2">@code{}
+            nvenc_split_encode = driver_decides
+            @endcode</td>
+    </tr>
+    <tr>
+        <td rowspan="3">Choices</td>
+        <td>disabled</td>
+        <td>Disabled</td>
+    </tr>
+    <tr>
+        <td>driver_decides</td>
+        <td>The NVIDIA driver will automatically enable split frame encoding when the following conditions are met: 2+ NVENC units, resolution is at least 4K, and the preset is P1-P4.</td>
+    </tr>
+    <tr>
+        <td>enabled</td>
+        <td>Enabled</td>
+    </tr>
+</table>
+
 ### nvenc_latency_over_power
 
 <table>

src/config.cpp

@@ -64,6 +64,21 @@ namespace config {
       return nvenc::nvenc_two_pass::quarter_resolution;
     }
 
+    nvenc::nvenc_split_frame_encoding split_encode_from_view(const std::string_view &preset) {
+      using enum nvenc::nvenc_split_frame_encoding;
+      if (preset == "disabled") {
+        return disabled;
+      }
+      if (preset == "driver_decides") {
+        return driver_decides;
+      }
+      if (preset == "enabled") {
+        return force_enabled;
+      }
+      BOOST_LOG(warning) << "config: unknown nvenc_split_encode value: " << preset;
+      return driver_decides;
+    }
+
   }  // namespace nv
 
   namespace amd {
@@ -1083,6 +1098,7 @@ namespace config {
     bool_f(vars, "nvenc_spatial_aq", video.nv.adaptive_quantization);
     generic_f(vars, "nvenc_twopass", video.nv.two_pass, nv::twopass_from_view);
     bool_f(vars, "nvenc_h264_cavlc", video.nv.h264_cavlc);
+    generic_f(vars, "nvenc_split_encode", video.nv.split_frame_encoding, nv::split_encode_from_view);
     bool_f(vars, "nvenc_realtime_hags", video.nv_realtime_hags);
     bool_f(vars, "nvenc_opengl_vulkan_on_dxgi", video.nv_opengl_vulkan_on_dxgi);
     bool_f(vars, "nvenc_latency_over_power", video.nv_sunshine_high_power_mode);

src/nvenc/nvenc_base.cpp

@@ -98,7 +98,6 @@ namespace nvenc {
   }
 
   bool nvenc_base::create_encoder(const nvenc_config &config, const video::config_t &client_config, const nvenc_colorspace_t &colorspace, NV_ENC_BUFFER_FORMAT buffer_format) {
-    minimum_api_version = NVENCAPI_VERSION;
     if (!nvenc && !init_library()) {
       return false;
     }
@@ -115,7 +114,7 @@ namespace nvenc {
     encoder_params.buffer_format = buffer_format;
     encoder_params.rfi = true;
 
-    NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS session_params = { NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER };
+    NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS session_params = {NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER};
     session_params.device = device;
     session_params.deviceType = device_type;
     session_params.apiVersion = NVENCAPI_VERSION;
@@ -136,7 +135,7 @@ namespace nvenc {
       return false;
     }
 
-    NV_ENC_INITIALIZE_PARAMS init_params = { NV_ENC_INITIALIZE_PARAMS_VER };
+    NV_ENC_INITIALIZE_PARAMS init_params = {NV_ENC_INITIALIZE_PARAMS_VER};
 
     switch (client_config.videoFormat) {
       case 0:
@@ -170,11 +169,14 @@ namespace nvenc {
     }
 
     auto get_encoder_cap = [&](NV_ENC_CAPS cap) {
-      NV_ENC_CAPS_PARAM param = { NV_ENC_CAPS_PARAM_VER };
+      NV_ENC_CAPS_PARAM param = {NV_ENC_CAPS_PARAM_VER};
       param.capsToQuery = cap;
       int value = 0;
-      nvenc->nvEncGetEncodeCaps(encoder, init_params.encodeGUID, &param, &value);
-      return value;
+      int ret = nvenc->nvEncGetEncodeCaps(encoder, init_params.encodeGUID, &param, &value);
+      if (ret == NV_ENC_SUCCESS) {
+        return value;
+      }
+      return 0;
     };
 
     auto buffer_is_10bit = [&]() {
@@ -229,10 +231,17 @@ namespace nvenc {
       init_params.frameRateDen = fps.den;
     }
 
+    if (client_config.videoFormat > 0 && get_encoder_cap(NV_ENC_CAPS_NUM_ENCODER_ENGINES) > 1) {
+      // SFE supports HEVC/AV1 if you have more than 1 nvenc block
+      using enum nvenc_split_frame_encoding;
+      init_params.splitEncodeMode = config.split_frame_encoding == disabled      ? NV_ENC_SPLIT_DISABLE_MODE :
+                                    config.split_frame_encoding == force_enabled ? NV_ENC_SPLIT_AUTO_FORCED_MODE :
+                                                                                   NV_ENC_SPLIT_AUTO_MODE;
+    }
 
     NV_ENC_PRESET_CONFIG preset_config = {
       .version = NV_ENC_PRESET_CONFIG_VER,
-      .presetCfg = { .version = NV_ENC_CONFIG_VER },
+      .presetCfg = {.version = NV_ENC_CONFIG_VER},
     };
     if (nvenc_failed(nvenc->nvEncGetEncodePresetConfigEx(encoder, init_params.encodeGUID, init_params.presetGUID, init_params.tuningInfo, &preset_config))) {
       BOOST_LOG(error) << "NvEnc: NvEncGetEncodePresetConfigEx() failed: " << last_nvenc_error_string;
@@ -398,15 +407,15 @@ namespace nvenc {
     }
 
     if (async_event_handle) {
-      NV_ENC_EVENT_PARAMS event_params = { NV_ENC_EVENT_PARAMS_VER };
+      NV_ENC_EVENT_PARAMS event_params = {NV_ENC_EVENT_PARAMS_VER};
       event_params.completionEvent = async_event_handle;
       if (nvenc_failed(nvenc->nvEncRegisterAsyncEvent(encoder, &event_params))) {
         BOOST_LOG(error) << "NvEnc: NvEncRegisterAsyncEvent() failed: " << last_nvenc_error_string;
         return false;
       }
     }
 
-    NV_ENC_CREATE_BITSTREAM_BUFFER create_bitstream_buffer = { NV_ENC_CREATE_BITSTREAM_BUFFER_VER };
+    NV_ENC_CREATE_BITSTREAM_BUFFER create_bitstream_buffer = {NV_ENC_CREATE_BITSTREAM_BUFFER_VER};
     if (nvenc_failed(nvenc->nvEncCreateBitstreamBuffer(encoder, &create_bitstream_buffer))) {
       BOOST_LOG(error) << "NvEnc: NvEncCreateBitstreamBuffer() failed: " << last_nvenc_error_string;
       return false;
@@ -458,6 +467,13 @@ namespace nvenc {
       if (config.insert_filler_data) {
         extra += " filler-data";
       }
+      if (client_config.videoFormat > 0 && get_encoder_cap(NV_ENC_CAPS_NUM_ENCODER_ENGINES) > 1) {
+        if (init_params.splitEncodeMode == NV_ENC_SPLIT_AUTO_MODE) {
+          extra += " sfe-auto";
+        } else if (init_params.splitEncodeMode == NV_ENC_SPLIT_AUTO_FORCED_MODE) {
+          extra += " sfe";
+        }
+      }
 
       BOOST_LOG(info) << "NvEnc: created encoder " << video_format_string << quality_preset_string_from_guid(init_params.presetGUID) << extra;
     }
@@ -475,7 +491,7 @@ namespace nvenc {
       output_bitstream = nullptr;
     }
     if (encoder && async_event_handle) {
-      NV_ENC_EVENT_PARAMS event_params = { NV_ENC_EVENT_PARAMS_VER };
+      NV_ENC_EVENT_PARAMS event_params = {NV_ENC_EVENT_PARAMS_VER};
       event_params.completionEvent = async_event_handle;
       if (nvenc_failed(nvenc->nvEncUnregisterAsyncEvent(encoder, &event_params))) {
         BOOST_LOG(error) << "NvEnc: NvEncUnregisterAsyncEvent() failed: " << last_nvenc_error_string;
@@ -511,7 +527,7 @@ namespace nvenc {
       return {};
     }
 
-    NV_ENC_MAP_INPUT_RESOURCE mapped_input_buffer = { NV_ENC_MAP_INPUT_RESOURCE_VER };
+    NV_ENC_MAP_INPUT_RESOURCE mapped_input_buffer = {NV_ENC_MAP_INPUT_RESOURCE_VER};
     mapped_input_buffer.registeredResource = registered_input_buffer;
 
     if (nvenc_failed(nvenc->nvEncMapInputResource(encoder, &mapped_input_buffer))) {
@@ -524,7 +540,7 @@ namespace nvenc {
       }
     });
 
-    NV_ENC_PIC_PARAMS pic_params = { NV_ENC_PIC_PARAMS_VER };
+    NV_ENC_PIC_PARAMS pic_params = {NV_ENC_PIC_PARAMS_VER};
     pic_params.inputWidth = encoder_params.width;
     pic_params.inputHeight = encoder_params.height;
     pic_params.encodePicFlags = force_idr ? NV_ENC_PIC_FLAG_FORCEIDR : 0;
@@ -540,7 +556,7 @@ namespace nvenc {
       return {};
     }
 
-    NV_ENC_LOCK_BITSTREAM lock_bitstream = { NV_ENC_LOCK_BITSTREAM_VER };
+    NV_ENC_LOCK_BITSTREAM lock_bitstream = {NV_ENC_LOCK_BITSTREAM_VER};
     lock_bitstream.outputBitstream = output_bitstream;
     lock_bitstream.doNotWait = async_event_handle ? 1 : 0;
 
@@ -587,8 +603,7 @@ namespace nvenc {
       return false;
     }
 
-    if (first_frame >= encoder_state.last_rfi_range.first &&
-        last_frame <= encoder_state.last_rfi_range.second) {
+    if (first_frame >= encoder_state.last_rfi_range.first && last_frame <= encoder_state.last_rfi_range.second) {
       BOOST_LOG(debug) << "NvEnc: rfi request " << first_frame << "-" << last_frame << " already done";
       return true;
     }

src/nvenc/nvenc_base.h

@@ -132,7 +132,6 @@ namespace nvenc {
 
   private:
     NV_ENC_OUTPUT_PTR output_bitstream = nullptr;
-    uint32_t minimum_api_version = 0;
 
     struct {
       uint64_t last_encoded_frame_index = 0;

src/nvenc/nvenc_config.h

@@ -12,6 +12,12 @@ namespace nvenc {
     full_resolution,  ///< Better overall statistics, slower and uses more extra vram
   };
 
+  enum class nvenc_split_frame_encoding {
+    disabled,  ///< Disable
+    driver_decides,  ///< Let driver decide
+    force_enabled,  ///< Force-enable
+  };
+
   /**
    * @brief NVENC encoder configuration.
    */
@@ -48,6 +54,9 @@ namespace nvenc {
 
     // Add filler data to encoded frames to stay at target bitrate, mainly for testing
     bool insert_filler_data = false;
+
+    // Enable split-frame encoding if the gpu has multiple NVENC hardware clusters
+    nvenc_split_frame_encoding split_frame_encoding = nvenc_split_frame_encoding::driver_decides;
   };
 
 }  // namespace nvenc

src/nvenc/nvenc_d3d11_native.cpp

@@ -51,7 +51,7 @@ namespace nvenc {
     }
 
     if (!registered_input_buffer) {
-      NV_ENC_REGISTER_RESOURCE register_resource = { NV_ENC_REGISTER_RESOURCE_VER };
+      NV_ENC_REGISTER_RESOURCE register_resource = {NV_ENC_REGISTER_RESOURCE_VER};
       register_resource.resourceType = NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX;
       register_resource.width = encoder_params.width;
       register_resource.height = encoder_params.height;

src/nvenc/nvenc_d3d11_on_cuda.cpp

@@ -169,7 +169,7 @@ namespace nvenc {
     }
 
     if (!registered_input_buffer) {
-      NV_ENC_REGISTER_RESOURCE register_resource = { NV_ENC_REGISTER_RESOURCE_VER };
+      NV_ENC_REGISTER_RESOURCE register_resource = {NV_ENC_REGISTER_RESOURCE_VER};
       register_resource.resourceType = NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR;
       register_resource.width = encoder_params.width;
       register_resource.height = encoder_params.height;

src_assets/common/assets/web/config.html

@@ -289,6 +289,7 @@ <h1 class="my-4">{{ $t('config.configuration') }}</h1>
               "nvenc_spatial_aq": "disabled",
               "nvenc_vbv_increase": 0,
               "nvenc_realtime_hags": "enabled",
+              "nvenc_split_encode": "driver_decides",
               "nvenc_latency_over_power": "enabled",
               "nvenc_opengl_vulkan_on_dxgi": "enabled",
               "nvenc_h264_cavlc": "disabled",

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

@@ -27,6 +27,17 @@ const config = ref(props.config)
       <div class="form-text">{{ $t('config.nvenc_preset_desc') }}</div>
     </div>
 
+    <!-- Split frame encoding -->
+    <div class="mb-3" v-if="platform === 'windows'">
+      <label for="nvenc_split_encode" class="form-label">{{ $t('config.nvenc_split_encode') }}</label>
+      <select id="nvenc_split_encode" class="form-select" v-model="config.nvenc_split_encode">
+        <option value="disabled">{{ $t('_common.disabled') }}</option>
+        <option value="driver_decides">{{ $t('config.nvenc_split_encode_driver_decides_def') }}</option>
+        <option value="enabled">{{ $t('_common.enabled') }}</option>
+      </select>
+      <div class="form-text">{{ $t('config.nvenc_split_encode_desc') }}</div>
+    </div>
+
     <!-- Two-pass mode -->
     <div class="mb-3">
       <label for="nvenc_twopass" class="form-label">{{ $t('config.nvenc_twopass') }}</label>

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

@@ -301,6 +301,9 @@
     "nvenc_realtime_hags_desc": "Currently NVIDIA drivers may freeze in encoder when HAGS is enabled, realtime priority is used and VRAM utilization is close to maximum. Disabling this option lowers the priority to high, sidestepping the freeze at the cost of reduced capture performance when the GPU is heavily loaded.",
     "nvenc_spatial_aq": "Spatial AQ",
     "nvenc_spatial_aq_desc": "Assign higher QP values to flat regions of the video. Recommended to enable when streaming at lower bitrates.",
+    "nvenc_split_encode": "Split frame encoding",
+    "nvenc_split_encode_desc": "Split the encoding of each video frame over multiple NVENC hardware units. Significantly reduces host processing latency with a marginal compression efficiency penalty. The default option enables SFE if the following conditions are met: there are 2+ NVENC units, the stream is 4K resolution or higher, and the preset is P1-P4. Set this to Enabled to use SFE at lower resolutions or higher presets.",
+    "nvenc_split_encode_driver_decides_def": "Driver decides (default)",
     "nvenc_twopass": "Two-pass mode",
     "nvenc_twopass_desc": "Adds preliminary encoding pass. This allows to detect more motion vectors, better distribute bitrate across the frame and more strictly adhere to bitrate limits. Disabling it is not recommended since this can lead to occasional bitrate overshoot and subsequent packet loss.",
     "nvenc_twopass_disabled": "Disabled (fastest, not recommended)",