Fix Video Super Resolution on systems without Windows 11 D3D12 interfaces

A user on Windows 10 with an RTX 3060 Ti could not stream at all, while
RTX 4070 Ti and 5060 Ti machines worked. The GPU was not the cause: the
3060 Ti host was the only one still on Windows 10.

D3D12CreateDevice() requested ID3D12Device9, an Agility SDK / Windows 11
interface, and failed with E_NOINTERFACE (0x80004002) since we ship no
Agility runtime. ID3D12GraphicsCommandList7 and
ID3D12VideoProcessCommandList3 had the same problem and would have failed
right after. None of the methods we actually call require those versions,
so lower each member to the minimum interface the code uses. ID3D12Device
and ID3D12GraphicsCommandList cover every call site;
ID3D12VideoProcessCommandList1 provides ProcessFrames1(). m_VideoDevice
stays ID3D12VideoDevice2 because CreateVideoProcessor1() lives there.

With video enhancement enabled, AV_HWDEVICE_TYPE_D3D11VA fell through to
D3D12VARenderer in both passes, so D3D11VA was never instantiated. Once
D3D12 failed there was nothing left but libplacebo/Vulkan, turning
"upscaler unavailable" into "no video at all". Latch the failure in
VideoEnhancement so D3D11VA can take over, and disable enhancement for
that session so the stats overlay does not advertise a missing upscaler.
Move the D3D12VA_ENABLED and IsWindows10OrGreater() checks ahead of device
creation and latch them too, which makes D3D12VA_ENABLED=0 reproduce a
system that lacks the required interfaces.

The FSR1 hooks were destroyed after pl_vulkan_destroy() and
pl_log_destroy(), a use-after-free of the pl_gpu they were parsed on that
also leaked their GPU resources on every renderer recreation. Release them
while the GPU is still alive. Parse the HDR shader variant only for 10-bit
streams, since the SDR hook was previously duplicated for no benefit, and
log a parse failure instead of silently rendering without the hook.

Video enhancement availability only reflected that FFmpeg advertises a
D3D12VA hwaccel, which stays true where the device cannot be created, so
the setting looked usable on affected systems. Grey out the checkbox, the
mode label and the mode dropdown when D3D12 is out of reach.

Finally, log the OS version at startup. Renderer availability depends on
it and the logs carried no way to recover it.

Author: linckosz

app/backend/systemproperties.cpp

@@ -300,9 +300,16 @@ bool SystemProperties::isVideoEnhancementSwitchable()
  *
  * Check if either Video Super-Resolution features can be used by the GPU.
  *
+ * isAvailable() only reflects that FFmpeg advertises a hwaccel able to carry the
+ * feature, which stays true on systems where the D3D12 device cannot actually be
+ * created. On Windows the upscaler lives in the D3D12 renderer (the Vulkan/FSR1
+ * path is not user-selectable there), so a D3D12 failure means the feature is out
+ * of reach and the setting must be greyed out.
+ *
  * \return bool Returns true if the GPU is capable
  */
 bool SystemProperties::isVideoEnhancementAvailable()
 {
-    return VideoEnhancement::getInstance().isAvailable();
+    return VideoEnhancement::getInstance().isAvailable() &&
+           VideoEnhancement::getInstance().isD3D12Available();
 }

app/gui/SettingsView.qml

@@ -919,7 +919,11 @@ Flickable {
                     visible: SystemProperties.isVideoEnhancementSwitchable()
                     width: parent.width
                     id: resSuperResolutionModeTitle
-                    text: qsTr("Video Super Resolution Mode<br><i>(Dropdown available only in Debug mode)</br></i>")
+                    enabled: SystemProperties.isVideoEnhancementAvailable()
+                    text: SystemProperties.isVideoEnhancementAvailable() ?
+                              qsTr("Video Super Resolution Mode<br><i>(Dropdown available only in Debug mode)</br></i>")
+                            :
+                              qsTr("Video Super Resolution Mode (unavailable on this system)")
                     font.pointSize: 12
                     wrapMode: Text.Wrap
                 }
@@ -928,6 +932,7 @@ Flickable {
                 AutoResizingComboBox {
 
                     visible: SystemProperties.isVideoEnhancementSwitchable()
+                    enabled: SystemProperties.isVideoEnhancementAvailable()
 
                     ToolTip.delay: 1000
                     ToolTip.timeout: 5000

app/main.cpp

@@ -13,6 +13,7 @@
 #include <QElapsedTimer>
 #include <QTemporaryFile>
 #include <QRegularExpression>
+#include <QSysInfo>
 
 #ifdef Q_OS_UNIX
 #include <sys/socket.h>
@@ -814,6 +815,13 @@ int main(int argc, char *argv[])
         break;
     }
 
+    // Log the OS we're running on.
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Running on %s (%s %s)",
+                QSysInfo::prettyProductName().toUtf8().constData(),
+                QSysInfo::kernelType().toUtf8().constData(),
+                QSysInfo::kernelVersion().toUtf8().constData());
+
     SDL_version compileVersion;
     SDL_VERSION(&compileVersion);
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,

app/streaming/video/ffmpeg-renderers/d3d12va.cpp

@@ -2512,31 +2512,42 @@ bool D3D12VARenderer::initialize(PDECODER_PARAMETERS params)
         return false;
     }
 
+    // Both of these are permanent for the lifetime of the process, so they latch
+    // the D3D12 renderer as unavailable to let D3D11VA take over. Setting
+    // D3D12VA_ENABLED=0 therefore reproduces exactly what a system without the
+    // required D3D12 interfaces does.
+    if (qgetenv("D3D12VA_ENABLED") == "0") {
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                    "D3D12VA is disabled by environment variable");
+        m_VideoEnhancement->setD3D12Available(false);
+        return false;
+    } else if (!IsWindows10OrGreater()) {
+        // Use DXVA2 on anything older than Win10, so we don't have to handle a bunch
+        // of legacy Win7/Win8 codepaths in here.
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "D3D12VA renderer is only supported on Windows 10 or later.");
+        m_VideoEnhancement->setD3D12Available(false);
+        return false;
+    }
+
     // Device creation
     m_hr = D3D12CreateDevice(
         m_Adapter.Get(),
         D3D_FEATURE_LEVEL_12_0,
         IID_PPV_ARGS(&m_Device)
         );
     if(!verifyHResult(m_hr, "D3D12CreateDevice(... m_Device)")){
+        // This system cannot host a D3D12 device at all, so there is no point
+        // retrying this renderer. Let D3D11VA take over instead of falling all
+        // the way through to the Vulkan renderer.
+        m_VideoEnhancement->setD3D12Available(false);
         return false;
     }
 
     // VideoDevice creation
     m_hr = m_Device.As(&m_VideoDevice);
     if(!verifyHResult(m_hr, "m_Device.As(&m_VideoDevice);")){
-        return false;
-    }
-
-    if (qgetenv("D3D12VA_ENABLED") == "0") {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "D3D12VA is disabled by environment variable");
-        return false;
-    } else if (!IsWindows10OrGreater()) {
-        // Use DXVA2 on anything older than Win10, so we don't have to handle a bunch
-        // of legacy Win7/Win8 codepaths in here.
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "D3D12VA renderer is only supported on Windows 10 or later.");
+        m_VideoEnhancement->setD3D12Available(false);
         return false;
     }
 

app/streaming/video/ffmpeg-renderers/d3d12va.h

@@ -198,7 +198,7 @@ class D3D12VARenderer : public QObject, public IFFmpegRenderer
     UINT m_AdapterIndex = 0;
     ComPtr<IDXGIFactory6> m_Factory;
     ComPtr<IDXGIAdapter1> m_Adapter;
-    ComPtr<ID3D12Device9> m_Device;
+    ComPtr<ID3D12Device> m_Device;
     ComPtr<ID3D12VideoDevice2> m_VideoDevice;
     decoder m_Decoder;
     bool m_SkipRenderStep2 = false;
@@ -269,13 +269,13 @@ class D3D12VARenderer : public QObject, public IFFmpegRenderer
     std::vector<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS> m_OutputArgsUpscalerConvert;
 
     ComPtr<ID3D12CommandAllocator> m_VideoProcessCommandAllocator;
-    ComPtr<ID3D12VideoProcessCommandList3> m_VideoProcessCommandList;
+    ComPtr<ID3D12VideoProcessCommandList1> m_VideoProcessCommandList;
     ComPtr<ID3D12CommandQueue> m_VideoProcessCommandQueue;
     ComPtr<ID3D12CommandAllocator> m_GraphicsCommandAllocator;
-    ComPtr<ID3D12GraphicsCommandList7> m_GraphicsCommandList;
+    ComPtr<ID3D12GraphicsCommandList> m_GraphicsCommandList;
     ComPtr<ID3D12CommandQueue> m_GraphicsCommandQueue;
     ComPtr<ID3D12CommandAllocator> m_OverlayCommandAllocator;
-    ComPtr<ID3D12GraphicsCommandList7> m_OverlayCommandList;
+    ComPtr<ID3D12GraphicsCommandList> m_OverlayCommandList;
     ComPtr<ID3D12CommandQueue> m_OverlayCommandQueue;
     D3D12_RESOURCE_BARRIER m_Barrier;
 
@@ -374,7 +374,7 @@ class D3D12VARenderer : public QObject, public IFFmpegRenderer
 
     // Used for debug purpose only
     ComPtr<ID3D12CommandAllocator> m_PictureCommandAllocator;
-    ComPtr<ID3D12GraphicsCommandList7> m_PictureCommandList;
+    ComPtr<ID3D12GraphicsCommandList> m_PictureCommandList;
     ComPtr<ID3D12CommandQueue> m_PictureCommandQueue;
     void DebugExportToPNG(
         ID3D12Resource* srctexture,

app/streaming/video/ffmpeg-renderers/plvk.cpp

@@ -182,6 +182,18 @@ PlVkRenderer::~PlVkRenderer()
         DrmMasterLocker locker;
 
         pl_renderer_destroy(&m_Renderer);
+
+        // The FSR hooks own GPU resources, so they must be released while the
+        // pl_gpu they were parsed on is still alive. m_FsrHookHDR stays null when
+        // only the SDR variant was parsed and m_RenderParamsHDR points at m_FsrHook.
+        if (m_FsrHookHDR != nullptr && m_FsrHookHDR != m_FsrHook) {
+            pl_mpv_user_shader_destroy(&m_FsrHookHDR);
+        }
+        m_FsrHookHDR = nullptr;
+        if (m_FsrHook != nullptr) {
+            pl_mpv_user_shader_destroy(&m_FsrHook);
+        }
+
         pl_swapchain_destroy(&m_Swapchain);
 #ifdef Q_OS_DARWIN
         m_MetalTextureFactory.reset();
@@ -199,15 +211,6 @@ PlVkRenderer::~PlVkRenderer()
 
     // m_Log must always be the last object destroyed
     pl_log_destroy(&m_Log);
-
-    if (m_FsrHook) {
-        pl_mpv_user_shader_destroy(&m_FsrHook);
-        m_FsrHook = nullptr;
-    }
-    if (m_FsrHookHDR) {
-        pl_mpv_user_shader_destroy(&m_FsrHookHDR);
-        m_FsrHookHDR = nullptr;
-    }
 }
 
 bool PlVkRenderer::chooseVulkanDevice(PDECODER_PARAMETERS params, bool hdrOutputRequired)
@@ -650,23 +653,32 @@ bool PlVkRenderer::initialize(PDECODER_PARAMETERS params)
         m_RenderParams.num_hooks = m_FsrHook ? 1 : 0;
 
         // FSR1 (HDR)
-        // The shader has been customized to set the sharpening at 0.75 and PQ at true for HDR
-        std::string FsrShaderHDR;
-        // Check if HDR is enabled by the user in the UI settings.
+        // The shader has been customized to set the sharpening at 0.75 and PQ at true for HDR.
+        // Only a 10-bit stream can carry PQ frames, so for anything else the SDR hook is reused
+        // rather than parsing and allocating GPU resources for a second identical copy of it.
         if (params->videoFormat & VIDEO_FORMAT_MASK_10BIT) {
-            FsrShaderHDR = loadGLSL(":/enhancer/FSR1_HDR.glsl");
-        } else {
-            FsrShaderHDR = loadGLSL(":/enhancer/FSR1.glsl");
+            std::string FsrShaderHDR = loadGLSL(":/enhancer/FSR1_HDR.glsl");
+            m_FsrHookHDR = pl_mpv_user_shader_parse(m_Vulkan->gpu, FsrShaderHDR.c_str(), FsrShaderHDR.size());
+            m_RenderParamsHDR.hooks     = &m_FsrHookHDR;
+            m_RenderParamsHDR.num_hooks = m_FsrHookHDR ? 1 : 0;
+        }
+        else {
+            m_RenderParamsHDR.hooks     = &m_FsrHook;
+            m_RenderParamsHDR.num_hooks = m_FsrHook ? 1 : 0;
         }
-        m_FsrHookHDR = pl_mpv_user_shader_parse(m_Vulkan->gpu, FsrShaderHDR.c_str(), FsrShaderHDR.size());
-        m_RenderParamsHDR.hooks     = &m_FsrHookHDR;
-        m_RenderParamsHDR.num_hooks = m_FsrHookHDR ? 1 : 0;
 
-        int drawableWidth, drawableHeight;
-        SDL_Vulkan_GetDrawableSize(m_Window, &drawableWidth, &drawableHeight);
-        m_VideoEnhancement->setRatio(static_cast<float>(drawableHeight) / static_cast<float>(params->height));
+        if (m_RenderParams.num_hooks == 0 || m_RenderParamsHDR.num_hooks == 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "Failed to parse the FSR1 shader. Video enhancement is disabled for this session.");
+            m_VideoEnhancement->enableVideoEnhancement(false);
+        }
+        else {
+            int drawableWidth, drawableHeight;
+            SDL_Vulkan_GetDrawableSize(m_Window, &drawableWidth, &drawableHeight);
+            m_VideoEnhancement->setRatio(static_cast<float>(drawableHeight) / static_cast<float>(params->height));
 
-        m_VideoEnhancement->setAlgo("Shader FSR1");
+            m_VideoEnhancement->setAlgo("Shader FSR1");
+        }
     }
 
     return true;

app/streaming/video/ffmpeg.cpp

@@ -1038,22 +1038,37 @@ IFFmpegRenderer* FFmpegVideoDecoder::createHwAccelRenderer(const AVCodecHWConfig
 
     // Keep track of the Device Type selected
     VideoEnhancement::getInstance().setDeviceType(hwDecodeCfg->device_type);
-    
+
+    bool enableVideoEnhancement = params->enableVideoEnhancement;
+#ifdef Q_OS_WIN32
+    // D3D11VA is only reached with enhancement requested when the D3D12 renderer
+    // is unusable on this system. That renderer is the one providing the upscaler,
+    // so the session runs without enhancement rather than advertising a missing one.
+    if (enableVideoEnhancement &&
+            hwDecodeCfg->device_type == AV_HWDEVICE_TYPE_D3D11VA &&
+            !VideoEnhancement::getInstance().isD3D12Available()) {
+        enableVideoEnhancement = false;
+    }
+#endif
+
     // Reset Video enhancer enabler
-    VideoEnhancement::getInstance().enableVideoEnhancement(params->enableVideoEnhancement);
-    
+    VideoEnhancement::getInstance().enableVideoEnhancement(enableVideoEnhancement);
+
     // First pass using our top-tier hwaccel implementations
     if (pass == 0) {
         switch (hwDecodeCfg->device_type) {
 #ifdef Q_OS_WIN32
         // DXVA2 appears in the hwaccel list before D3D11VA, so we only check for D3D11VA
         // on the first pass to ensure we prefer D3D11VA over DXVA2.
         case AV_HWDEVICE_TYPE_D3D11VA:
-            if (!params->enableVideoEnhancement){
+            if (!params->enableVideoEnhancement || !VideoEnhancement::getInstance().isD3D12Available()){
                 return new D3D11VARenderer(pass);
             }
             // Do not break here
         case AV_HWDEVICE_TYPE_D3D12VA:
+            if (!VideoEnhancement::getInstance().isD3D12Available()){
+                return nullptr;
+            }
             // D3D12VARenderer is also able to receive frame from AV_HWDEVICE_TYPE_D3D11VA via Interop
             return new D3D12VARenderer(pass);
 #endif
@@ -1117,11 +1132,14 @@ IFFmpegRenderer* FFmpegVideoDecoder::createHwAccelRenderer(const AVCodecHWConfig
         case AV_HWDEVICE_TYPE_DXVA2:
             return new DXVA2Renderer(pass);
         case AV_HWDEVICE_TYPE_D3D11VA:
-            if (!params->enableVideoEnhancement){
+            if (!params->enableVideoEnhancement || !VideoEnhancement::getInstance().isD3D12Available()){
                 return new D3D11VARenderer(pass);
             }
             // Do not break here
         case AV_HWDEVICE_TYPE_D3D12VA:
+            if (!VideoEnhancement::getInstance().isD3D12Available()){
+                return nullptr;
+            }
             // D3D12VARenderer is also able to receive frame from AV_HWDEVICE_TYPE_D3D11VA via Interop
             return new D3D12VARenderer(pass);
 #endif

app/streaming/video/videoenhancement.cpp

@@ -159,6 +159,29 @@ bool VideoEnhancement::isHDRcapable(){
     return m_HDRcapable;
 }
 
+/**
+ * \brief Set the D3D12 renderer availability
+ *
+ * The D3D12 renderer needs interfaces that are missing on older Windows releases.
+ * Once its initialization has failed, there is no point retrying it for the rest
+ * of the process, and the D3D11 renderer must be allowed to take over.
+ *
+ * \param bool available
+ * \return void
+ */
+void VideoEnhancement::setD3D12Available(bool available){
+    m_D3D12Available = available;
+}
+
+/**
+ * \brief Check the D3D12 renderer availability
+ *
+ * \return bool Returns false if the D3D12 renderer already failed to initialize
+ */
+bool VideoEnhancement::isD3D12Available(){
+    return m_D3D12Available;
+}
+
 /**
  * \brief Check if Video Enhancement feature is enabled
  *

app/streaming/video/videoenhancement.h

@@ -17,6 +17,8 @@ class VideoEnhancement
     bool m_Enabled = false;
     bool m_VSRcapable = false;
     bool m_HDRcapable = false;
+    // Set to false once the D3D12 renderer proved it cannot be created on this system
+    bool m_D3D12Available = true;
     float m_Ratio;
     std::string m_Algo;
     int m_DeviceType;
@@ -53,6 +55,8 @@ class VideoEnhancement
     bool isVSRcapable();
     void setHDRcapable(bool capable);
     bool isHDRcapable();
+    void setD3D12Available(bool available);
+    bool isD3D12Available();
     bool isVideoEnhancementEnabled();
     bool enableVideoEnhancement(bool activate = true);
     void setAdapterIndex(int adapterIndex);