add HDR support (#166)

Author: EndlesslyFlowering

ShaderGlass/CaptureManager.cpp

@@ -122,6 +122,7 @@ bool CaptureManager::StartSession()
                               !m_options.imageFile.empty(),
                               m_options.flipMode,
                               m_options.allowTearing,
+                              m_options.useHDR,
                               m_d3dDevice,
                               m_context);
     UpdatePixelSize();
@@ -160,8 +161,12 @@ bool CaptureManager::StartSession()
     }
     else
     {
+        winrt::Windows::Graphics::DirectX::DirectXPixelFormat pixelFormat =
+            m_options.useHDR ? winrt::Windows::Graphics::DirectX::DirectXPixelFormat::R16G16B16A16Float
+                             : winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized;
+
         m_session = make_unique<CaptureSession>(
-            device, captureItem, winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized, *m_shaderGlass, m_options.maxCaptureRate, m_frameEvent);
+            device, captureItem, pixelFormat, *m_shaderGlass, m_options.maxCaptureRate, m_frameEvent);
     }
 
     m_active = true;

ShaderGlass/CaptureManager.h

@@ -36,6 +36,7 @@ struct CaptureOptions
     bool         flipMode {false};
     bool         allowTearing {false};
     bool         maxCaptureRate {false};
+    bool         useHDR {false};
     RECT         croppedArea {0, 0, 0, 0};
     bool         vertical {false};
 };

ShaderGlass/ShaderGlass.cpp

@@ -36,6 +36,7 @@ void ShaderGlass::Initialize(HWND                                outputWindow,
                              bool                                image,
                              bool                                flipMode,
                              bool                                allowTearing,
+                             bool                                useHDR,
                              winrt::com_ptr<ID3D11Device>        device,
                              winrt::com_ptr<ID3D11DeviceContext> context)
 {
@@ -45,6 +46,7 @@ void ShaderGlass::Initialize(HWND                                outputWindow,
     m_image         = image;
     m_flipMode      = flipMode;
     m_allowTearing  = allowTearing;
+    m_useHDR        = useHDR;
     m_device        = device;
     m_context       = context;
 
@@ -105,7 +107,7 @@ void ShaderGlass::Initialize(HWND                                outputWindow,
         DXGI_SWAP_CHAIN_DESC1 d3d11SwapChainDesc = {};
         d3d11SwapChainDesc.Width                 = 0;
         d3d11SwapChainDesc.Height                = 0;
-        d3d11SwapChainDesc.Format                = DXGI_FORMAT_B8G8R8A8_UNORM;
+        d3d11SwapChainDesc.Format                = m_useHDR ? DXGI_FORMAT_R16G16B16A16_FLOAT : DXGI_FORMAT_B8G8R8A8_UNORM;
         d3d11SwapChainDesc.SampleDesc.Count      = 1;
         d3d11SwapChainDesc.SampleDesc.Quality    = 0;
         d3d11SwapChainDesc.BufferUsage           = DXGI_USAGE_RENDER_TARGET_OUTPUT;
@@ -150,6 +152,14 @@ void ShaderGlass::Initialize(HWND                                outputWindow,
     hr                         = m_device->CreateRasterizerState(&desc, m_rasterizerState.put());
     assert(SUCCEEDED(hr));
 
+    if(m_useHDR)
+    {
+        hr = m_swapChain->QueryInterface(__uuidof(IDXGISwapChain3), reinterpret_cast<void**>(m_swapChain3.put()));
+        assert(SUCCEEDED(hr));
+
+        SetSwapchainColorSpace();
+    }
+
     m_context->RSSetState(m_rasterizerState.get());
 
     m_preprocessShader.Create(m_device);
@@ -324,6 +334,17 @@ std::vector<std::tuple<int, ShaderParam*>> ShaderGlass::Params()
     return params;
 }
 
+void ShaderGlass::SetSwapchainColorSpace()
+{
+    assert(m_swapChain3.get());
+
+    if(m_swapChain3.get())
+    {
+        hr = m_swapChain3->SetColorSpace1(DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709);
+        assert(SUCCEEDED(hr));
+    }
+}
+
 bool ShaderGlass::TryResizeSwapChain(const RECT& clientRect, bool force)
 {
     if(force || (clientRect.right != m_lastSize.x) || (clientRect.bottom != m_lastSize.y))
@@ -350,6 +371,11 @@ bool ShaderGlass::TryResizeSwapChain(const RECT& clientRect, bool force)
 
             hr = m_device->CreateRenderTargetView(m_displayTexture.get(), NULL, m_displayRenderTarget.put());
             assert(SUCCEEDED(hr));
+
+            if(m_useHDR)
+            {
+                SetSwapchainColorSpace();
+            }
         }
         return true;
     }

ShaderGlass/ShaderGlass.h

@@ -25,6 +25,7 @@ class ShaderGlass
                      bool                                image,
                      bool                                flipMode,
                      bool                                allowTearing,
+                     bool                                useHDR,
                      winrt::com_ptr<ID3D11Device>        device,
                      winrt::com_ptr<ID3D11DeviceContext> context);
     void  Process(winrt::com_ptr<ID3D11Texture2D> texture, ULONGLONG frameTicks);
@@ -51,6 +52,7 @@ class ShaderGlass
 
 private:
     bool TryResizeSwapChain(const RECT& clientRect, bool force);
+    void SetSwapchainColorSpace();
     void DestroyShaders();
     void DestroyPasses();
     void DestroyTargets();
@@ -65,6 +67,7 @@ class ShaderGlass
     winrt::com_ptr<ID3D11Device>             m_device {nullptr};
     winrt::com_ptr<ID3D11ShaderResourceView> m_originalView {nullptr};
     winrt::com_ptr<IDXGISwapChain1>          m_swapChain {nullptr};
+    winrt::com_ptr<IDXGISwapChain3>          m_swapChain3 {nullptr};
     winrt::com_ptr<ID3D11RasterizerState>    m_rasterizerState {nullptr};
     winrt::com_ptr<ID3D11Texture2D>          m_displayTexture {nullptr};
     winrt::com_ptr<ID3D11RenderTargetView>   m_displayRenderTarget {nullptr};
@@ -85,6 +88,7 @@ class ShaderGlass
     bool       m_image {false};
     bool       m_flipMode {false};
     bool       m_allowTearing {false};
+    bool       m_useHDR {false};
     int        m_frameCounter {0};
     int        m_logicalFrameCounter {0};
     ULONGLONG  m_startTicks {0};

ShaderGlass/ShaderGlass.rc

@@ -1338,6 +1338,32 @@ LRESULT CALLBACK ShaderWindow::WndProc(HWND hWnd, UINT message, WPARAM wParam, L
                 SaveMaxCaptureRateState(true);
             }
             break;
+        case ID_ADVANCED_USEHDR:
+            if(GetMenuState(m_advancedMenu, ID_ADVANCED_USEHDR, MF_BYCOMMAND) & MF_CHECKED)
+            {
+                CheckMenuItem(m_advancedMenu, ID_ADVANCED_USEHDR, MF_UNCHECKED);
+                SaveUseHDRState(false);
+
+                EnableMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_ENABLED);
+
+                if(GetFlipModeState())
+                {
+                    CheckMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_CHECKED);
+                }
+                else
+                {
+                    CheckMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_UNCHECKED);
+                }
+            }
+            else
+            {
+                CheckMenuItem(m_advancedMenu, ID_ADVANCED_USEHDR, MF_CHECKED);
+                SaveUseHDRState(true);
+
+                CheckMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_CHECKED);
+                EnableMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_GRAYED);
+            }
+            break;
         case ID_DESKTOP_LOCKINPUTAREA:
             if(!HasCaptureAPI())
                 break;
@@ -2093,8 +2119,18 @@ bool ShaderWindow::Create(_In_ HINSTANCE hInstance, _In_ int nCmdShow)
     {
         CheckMenuItem(m_programMenu, ID_PROCESSING_GLOBALHOTKEYS, MF_BYCOMMAND | MF_UNCHECKED);
     }
-    if(GetFlipModeState())
+    if(GetUseHDRState())
+    {
+        CheckMenuItem(m_advancedMenu, ID_ADVANCED_USEHDR, MF_BYCOMMAND | MF_CHECKED);
+        m_captureOptions.useHDR = true;
+
+        CheckMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_CHECKED);
+        EnableMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_GRAYED);
+        m_captureOptions.flipMode = true;
+    }
+    else if(GetFlipModeState())
     {
+        EnableMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_ENABLED);
         CheckMenuItem(m_advancedMenu, ID_PRESENTATION_USEFLIPMODE, MF_BYCOMMAND | MF_CHECKED);
         m_captureOptions.flipMode = true;
     }
@@ -2248,6 +2284,16 @@ bool ShaderWindow::GetMaxCaptureRateState()
     return GetRegistryOption(TEXT("Max Capture Rate"), false);
 }
 
+void ShaderWindow::SaveUseHDRState(bool state)
+{
+    SaveRegistryOption(TEXT("Use HDR"), state);
+}
+
+bool ShaderWindow::GetUseHDRState()
+{
+    return GetRegistryOption(TEXT("Use HDR"), false);
+}
+
 void ShaderWindow::SaveRememberFPS(int fps)
 {
     SaveRegistryInt(TEXT("Remember FPS"), fps);

ShaderGlass/ShaderWindow.cpp

@@ -113,6 +113,8 @@ class ShaderWindow
     bool GetTearingState();
     void SaveMaxCaptureRateState(bool state);
     bool GetMaxCaptureRateState();
+    void SaveUseHDRState(bool state);
+    bool GetUseHDRState();
     void SaveRememberFPS(int fps);
     bool RememberFPS();
     int  GetRememberFPS();

ShaderGlass/ShaderWindow.h

@@ -177,6 +177,7 @@
 #define ID_FPS_REMEMBERFPS              32918
 #define ID_PROCESSING_SETASDEFAULT      32919
 #define ID_PROCESSING_REMOVEDEFAULT     32920
+#define ID_ADVANCED_USEHDR              32921
 #define IDC_STATIC                      -1
 #define IDC_STATIC_LABEL                -1
 
@@ -186,7 +187,7 @@
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NO_MFC                     1
 #define _APS_NEXT_RESOURCE_VALUE        138
-#define _APS_NEXT_COMMAND_VALUE         32921
+#define _APS_NEXT_COMMAND_VALUE         32922
 #define _APS_NEXT_CONTROL_VALUE         1002
 #define _APS_NEXT_SYMED_VALUE           116
 #endif