[idd] postprocess: centralize compute effect utilities

idd/LGIdd/postprocess/effect/CColorTransformEffect.cpp

@@ -34,60 +34,17 @@ namespace
     TRANSFER_SRGB,
     TRANSFER_PQ,
   };
-
-  bool CreateUploadBuffer(const ComPtr<ID3D12Device3>& device, size_t size,
-    ComPtr<ID3D12Resource>& resource)
-  {
-    D3D12_HEAP_PROPERTIES heapProps = {};
-    heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
-
-    D3D12_RESOURCE_DESC desc = {};
-    desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-    desc.Width = size;
-    desc.Height = 1;
-    desc.DepthOrArraySize = 1;
-    desc.MipLevels = 1;
-    desc.SampleDesc.Count = 1;
-    desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-
-    const HRESULT hr = device->CreateCommittedResource(&heapProps,
-      D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ,
-      nullptr, IID_PPV_ARGS(&resource));
-    return SUCCEEDED(hr);
-  }
-
-  bool Upload(const ComPtr<ID3D12Resource>& resource,
-    const void * data, size_t size)
-  {
-    void * dst = nullptr;
-    const D3D12_RANGE readRange = { 0, 0 };
-    if (FAILED(resource->Map(0, &readRange, &dst)))
-      return false;
-    std::memcpy(dst, data, size);
-    resource->Unmap(0, nullptr);
-    return true;
-  }
 }
 
 bool CColorTransformEffect::Init(const ComPtr<ID3D12Device3>& device)
 {
-  D3D12_DESCRIPTOR_RANGE ranges[4] = {};
+  D3D12_DESCRIPTOR_RANGE ranges[] =
-  ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
+  {
-  ranges[0].NumDescriptors = 1;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 0),
-  ranges[0].BaseShaderRegister = 0;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0),
-  ranges[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1),
-  ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0),
-  ranges[1].NumDescriptors = 1;
+  };
-  ranges[1].BaseShaderRegister = 0;
-  ranges[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
-  ranges[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
-  ranges[2].NumDescriptors = 1;
-  ranges[2].BaseShaderRegister = 1;
-  ranges[2].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
-  ranges[3].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
-  ranges[3].NumDescriptors = 1;
-  ranges[3].BaseShaderRegister = 0;
-  ranges[3].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
 
   const char * shader =
     "cbuffer Constants : register(b0)\n"
@@ -194,8 +151,9 @@ bool CColorTransformEffect::Init(const ComPtr<ID3D12Device3>& device)
 
   const size_t constSize = AlignTo(sizeof(m_consts),
     (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  if (!CreateUploadBuffer(device, constSize, m_constBuffer) ||
+  if (FAILED(CreateUploadBuffer(device, constSize, m_constBuffer)) ||
-      !CreateUploadBuffer(device, sizeof(float) * 4096 * 4, m_lutBuffer))
+      FAILED(CreateUploadBuffer(
+        device, sizeof(float) * 4096 * 4, m_lutBuffer)))
   {
     DEBUG_ERROR("Failed to create color transform buffers");
     return false;
@@ -261,8 +219,8 @@ PostProcessStatus CColorTransformEffect::SetFormat(
 
   m_srcFormat = src.desc.Format;
   m_dstFormat = dstFormat;
-  m_threadsX = ((unsigned)desc.Width  + (Threads - 1)) / Threads;
+  m_threadsX  = Groups((unsigned)desc.Width);
-  m_threadsY = ((unsigned)desc.Height + (Threads - 1)) / Threads;
+  m_threadsY  = Groups(desc.Height);
 
   dst.desc   = desc;
   dst.format = frameType;
@@ -285,8 +243,8 @@ ComPtr<ID3D12Resource> CColorTransformEffect::Run(
   // upload buffers are guaranteed not to be in use by the GPU.
   if (m_uploadPending)
   {
-    if (!Upload(m_constBuffer, &m_consts, sizeof(m_consts)) ||
+    if (FAILED(Upload(m_constBuffer, &m_consts, sizeof(m_consts))) ||
-        !Upload(m_lutBuffer, m_lut, sizeof(m_lut)))
+        FAILED(Upload(m_lutBuffer, m_lut, sizeof(m_lut))))
       DEBUG_ERROR("Failed to upload display color transform");
     else
       m_uploadPending = false;
@@ -295,41 +253,19 @@ ComPtr<ID3D12Resource> CColorTransformEffect::Run(
   TransitionDst(commandList, D3D12_RESOURCE_STATE_COMMON,
     D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
 
-  D3D12_CPU_DESCRIPTOR_HANDLE handle =
+  CBV(device, 0, m_constBuffer.Get(), sizeof(m_consts));
-    m_descHeap->GetCPUDescriptorHandleForHeapStart();
+  SRV(device, 1, src.Get(), m_srcFormat);
-  const UINT inc = device->GetDescriptorHandleIncrementSize(
-    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
-
-  D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
-  cbvDesc.BufferLocation = m_constBuffer->GetGPUVirtualAddress();
-  cbvDesc.SizeInBytes = (UINT)AlignTo(sizeof(m_consts),
-    (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  device->CreateConstantBufferView(&cbvDesc, handle);
-  handle.ptr += inc;
-
-  D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-  srvDesc.Format = m_srcFormat;
-  srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
-  srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-  srvDesc.Texture2D.MipLevels = 1;
-  device->CreateShaderResourceView(src.Get(), &srvDesc, handle);
-  handle.ptr += inc;
 
   D3D12_SHADER_RESOURCE_VIEW_DESC lutDesc = {};
-  lutDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
+  lutDesc.Format                  = DXGI_FORMAT_R32G32B32A32_FLOAT;
-  lutDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+  lutDesc.ViewDimension           = D3D12_SRV_DIMENSION_BUFFER;
   lutDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-  lutDesc.Buffer.NumElements = 4096;
+  lutDesc.Buffer.NumElements      = 4096;
-  device->CreateShaderResourceView(m_lutBuffer.Get(), &lutDesc, handle);
+  device->CreateShaderResourceView(
-  handle.ptr += inc;
+    m_lutBuffer.Get(), &lutDesc, Handle(device, 2));
 
-  D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
+  UAV(device, 3, m_dst.Get(), m_dstFormat);
-  uavDesc.Format = m_dstFormat;
+  Dispatch(commandList);
-  uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
-  device->CreateUnorderedAccessView(m_dst.Get(), nullptr, &uavDesc, handle);
-
-  Bind(commandList);
-  commandList->Dispatch(m_threadsX, m_threadsY, 1);
 
   TransitionDst(commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
     D3D12_RESOURCE_STATE_COMMON);

idd/LGIdd/postprocess/effect/CComputeEffect.cpp

@@ -73,6 +73,52 @@ namespace PostProcessUtil
     desc.Flags              = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
     return CreateDefaultResource(device, desc, resource);
   }
+
+  HRESULT CreateUploadBuffer(const ComPtr<ID3D12Device3>& device,
+    size_t size, ComPtr<ID3D12Resource>& resource)
+  {
+    D3D12_HEAP_PROPERTIES heapProps = {};
+    heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
+
+    D3D12_RESOURCE_DESC desc = {};
+    desc.Dimension        = D3D12_RESOURCE_DIMENSION_BUFFER;
+    desc.Width            = size;
+    desc.Height           = 1;
+    desc.DepthOrArraySize = 1;
+    desc.MipLevels        = 1;
+    desc.SampleDesc.Count = 1;
+    desc.Layout           = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+
+    return device->CreateCommittedResource(&heapProps,
+      D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ,
+      nullptr, IID_PPV_ARGS(&resource));
+  }
+
+  HRESULT Upload(const ComPtr<ID3D12Resource>& resource,
+    const void * data, size_t size)
+  {
+    void * dst = nullptr;
+    const D3D12_RANGE readRange = { 0, 0 };
+    const HRESULT hr = resource->Map(0, &readRange, &dst);
+    if (FAILED(hr))
+      return hr;
+
+    std::memcpy(dst, data, size);
+    resource->Unmap(0, nullptr);
+    return S_OK;
+  }
+
+  D3D12_DESCRIPTOR_RANGE Range(
+    D3D12_DESCRIPTOR_RANGE_TYPE type, UINT shaderRegister)
+  {
+    D3D12_DESCRIPTOR_RANGE range = {};
+    range.RangeType                         = type;
+    range.NumDescriptors                    = 1;
+    range.BaseShaderRegister                = shaderRegister;
+    range.OffsetInDescriptorsFromTableStart =
+      D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
+    return range;
+  }
 }
 
 bool CComputeEffect::InitCompute(const ComPtr<ID3D12Device3>& device,
@@ -81,13 +127,16 @@ bool CComputeEffect::InitCompute(const ComPtr<ID3D12Device3>& device,
   const char * shader)
 {
   D3D12_ROOT_PARAMETER rootParam = {};
-  rootParam.ParameterType    = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
+  rootParam.ParameterType                       =
-  rootParam.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
+    D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
+  rootParam.ShaderVisibility                    =
+    D3D12_SHADER_VISIBILITY_ALL;
   rootParam.DescriptorTable.NumDescriptorRanges = rangeCount;
   rootParam.DescriptorTable.pDescriptorRanges   = ranges;
 
   D3D12_VERSIONED_ROOT_SIGNATURE_DESC rootSignatureDesc = {};
-  rootSignatureDesc.Version = D3D_ROOT_SIGNATURE_VERSION_1;
+  rootSignatureDesc.Version                    =
+    D3D_ROOT_SIGNATURE_VERSION_1;
   rootSignatureDesc.Desc_1_0.NumParameters     = 1;
   rootSignatureDesc.Desc_1_0.pParameters       = &rootParam;
   rootSignatureDesc.Desc_1_0.NumStaticSamplers = samplerCount;
@@ -140,7 +189,7 @@ bool CComputeEffect::InitCompute(const ComPtr<ID3D12Device3>& device,
   }
 
   D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {};
-  psoDesc.pRootSignature = m_rootSignature.Get();
+  psoDesc.pRootSignature     = m_rootSignature.Get();
   psoDesc.CS.pShaderBytecode = blob->GetBufferPointer();
   psoDesc.CS.BytecodeLength  = blob->GetBufferSize();
 
@@ -180,6 +229,54 @@ void CComputeEffect::Bind(const ComPtr<ID3D12GraphicsCommandList>& commandList)
     0, m_descHeap->GetGPUDescriptorHandleForHeapStart());
 }
 
+void CComputeEffect::Dispatch(
+  const ComPtr<ID3D12GraphicsCommandList>& commandList)
+{
+  Bind(commandList);
+  commandList->Dispatch(m_threadsX, m_threadsY, 1);
+}
+
+D3D12_CPU_DESCRIPTOR_HANDLE CComputeEffect::Handle(
+  const ComPtr<ID3D12Device3>& device, UINT index) const
+{
+  D3D12_CPU_DESCRIPTOR_HANDLE handle =
+    m_descHeap->GetCPUDescriptorHandleForHeapStart();
+  handle.ptr += index * device->GetDescriptorHandleIncrementSize(
+    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+  return handle;
+}
+
+void CComputeEffect::CBV(const ComPtr<ID3D12Device3>& device, UINT index,
+  ID3D12Resource * resource, size_t size) const
+{
+  D3D12_CONSTANT_BUFFER_VIEW_DESC desc = {};
+  desc.BufferLocation = resource->GetGPUVirtualAddress();
+  desc.SizeInBytes    = (UINT)PostProcessUtil::AlignTo(size,
+    (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
+  device->CreateConstantBufferView(&desc, Handle(device, index));
+}
+
+void CComputeEffect::SRV(const ComPtr<ID3D12Device3>& device, UINT index,
+  ID3D12Resource * resource, DXGI_FORMAT format) const
+{
+  D3D12_SHADER_RESOURCE_VIEW_DESC desc = {};
+  desc.Format                  = format;
+  desc.ViewDimension           = D3D12_SRV_DIMENSION_TEXTURE2D;
+  desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+  desc.Texture2D.MipLevels     = 1;
+  device->CreateShaderResourceView(resource, &desc, Handle(device, index));
+}
+
+void CComputeEffect::UAV(const ComPtr<ID3D12Device3>& device, UINT index,
+  ID3D12Resource * resource, DXGI_FORMAT format) const
+{
+  D3D12_UNORDERED_ACCESS_VIEW_DESC desc = {};
+  desc.Format        = format;
+  desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+  device->CreateUnorderedAccessView(
+    resource, nullptr, &desc, Handle(device, index));
+}
+
 void CComputeEffect::TransitionDst(
   const ComPtr<ID3D12GraphicsCommandList>& commandList,
   D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after)

idd/LGIdd/postprocess/effect/CComputeEffect.h

@@ -22,6 +22,7 @@
 
 #include "postprocess/CPostProcessor.h"
 
+#include <cstddef>
 
 #define POST_PROCESS_THREADS_STR "8"
 
@@ -39,6 +40,18 @@ namespace PostProcessUtil
     const D3D12_RESOURCE_DESC& desc, ComPtr<ID3D12Resource>& resource);
   bool CreateDefaultBuffer(const ComPtr<ID3D12Device3>& device,
     UINT64 size, ComPtr<ID3D12Resource>& resource);
+  HRESULT CreateUploadBuffer(const ComPtr<ID3D12Device3>& device,
+    size_t size, ComPtr<ID3D12Resource>& resource);
+  HRESULT Upload(const ComPtr<ID3D12Resource>& resource,
+    const void * data, size_t size);
+
+  D3D12_DESCRIPTOR_RANGE Range(
+    D3D12_DESCRIPTOR_RANGE_TYPE type, UINT shaderRegister);
+
+  static constexpr unsigned Groups(unsigned value)
+  {
+    return (value + (Threads - 1)) / Threads;
+  }
 }
 
 class CComputeEffect : public CPostProcessEffect
@@ -48,8 +61,8 @@ protected:
   ComPtr<ID3D12PipelineState>  m_pso;
   ComPtr<ID3D12DescriptorHeap> m_descHeap;
   ComPtr<ID3D12Resource>       m_dst;
-  unsigned m_threadsX = 0;
+  unsigned                     m_threadsX = 0;
-  unsigned m_threadsY = 0;
+  unsigned                     m_threadsY = 0;
 
   bool InitCompute(const ComPtr<ID3D12Device3>& device,
     const D3D12_DESCRIPTOR_RANGE * ranges, UINT rangeCount,
@@ -57,6 +70,16 @@ protected:
     const char * shader);
 
   void Bind(const ComPtr<ID3D12GraphicsCommandList>& commandList);
+  void Dispatch(const ComPtr<ID3D12GraphicsCommandList>& commandList);
+
+  D3D12_CPU_DESCRIPTOR_HANDLE Handle(
+    const ComPtr<ID3D12Device3>& device, UINT index) const;
+  void CBV(const ComPtr<ID3D12Device3>& device, UINT index,
+    ID3D12Resource * resource, size_t size) const;
+  void SRV(const ComPtr<ID3D12Device3>& device, UINT index,
+    ID3D12Resource * resource, DXGI_FORMAT format) const;
+  void UAV(const ComPtr<ID3D12Device3>& device, UINT index,
+    ID3D12Resource * resource, DXGI_FORMAT format) const;
 
   void TransitionDst(const ComPtr<ID3D12GraphicsCommandList>& commandList,
     D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after);

idd/LGIdd/postprocess/effect/CDownsampleEffect.cpp

@@ -27,7 +27,6 @@
 #include <cmath>
 #include <cwchar>
 #include <cwctype>
-#include <cstring>
 
 using namespace PostProcessUtil;
 
@@ -108,19 +107,12 @@ bool CDownsampleEffect::Init(const ComPtr<ID3D12Device3>& device)
   sampler.ShaderRegister   = 0;
   sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
 
-  D3D12_DESCRIPTOR_RANGE ranges[3] = {};
+  D3D12_DESCRIPTOR_RANGE ranges[] =
-  ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
+  {
-  ranges[0].NumDescriptors = 1;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 0),
-  ranges[0].BaseShaderRegister = 0;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0),
-  ranges[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0),
-  ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
+  };
-  ranges[1].NumDescriptors = 1;
-  ranges[1].BaseShaderRegister = 0;
-  ranges[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
-  ranges[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
-  ranges[2].NumDescriptors = 1;
-  ranges[2].BaseShaderRegister = 0;
-  ranges[2].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
 
   const char * shader =
     "cbuffer Constants       : register(b0)\n"
@@ -144,22 +136,9 @@ bool CDownsampleEffect::Init(const ComPtr<ID3D12Device3>& device)
   if (!InitCompute(device, ranges, ARRAYSIZE(ranges), &sampler, 1, shader))
     return false;
 
-  D3D12_HEAP_PROPERTIES heapProps = {};
+  const size_t size = AlignTo(sizeof(m_consts),
-  heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
-
-  D3D12_RESOURCE_DESC desc = {};
-  desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-  desc.Width = AlignTo(sizeof(m_consts),
     (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  desc.Height = 1;
+  const HRESULT hr = CreateUploadBuffer(device, size, m_constBuffer);
-  desc.DepthOrArraySize = 1;
-  desc.MipLevels = 1;
-  desc.SampleDesc.Count = 1;
-  desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-
-  HRESULT hr = device->CreateCommittedResource(&heapProps,
-    D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ,
-    nullptr, IID_PPV_ARGS(&m_constBuffer));
   if (FAILED(hr))
   {
     DEBUG_ERROR_HR(hr, "Failed to create Downsample constant buffer");
@@ -189,26 +168,21 @@ PostProcessStatus CDownsampleEffect::SetFormat(
   m_consts.width  = (float)rule->targetX;
   m_consts.height = (float)rule->targetY;
 
-  void * data = nullptr;
+  const HRESULT hr = Upload(m_constBuffer, &m_consts, sizeof(m_consts));
-  D3D12_RANGE readRange = { 0, 0 };
-  HRESULT hr = m_constBuffer->Map(0, &readRange, &data);
   if (FAILED(hr))
   {
     DEBUG_ERROR_HR(hr, "Failed to map Downsample constant buffer");
     return PostProcessStatus::FAILED;
   }
-  std::memcpy(data, &m_consts, sizeof(m_consts));
+  m_threadsX = Groups((unsigned)desc.Width);
-  m_constBuffer->Unmap(0, nullptr);
+  m_threadsY = Groups(desc.Height);
-
-  m_threadsX = ((unsigned)desc.Width  + (Threads - 1)) / Threads;
-  m_threadsY = ((unsigned)desc.Height + (Threads - 1)) / Threads;
   m_format   = src.desc.Format;
   m_scaleX   = (double)desc.Width  / src.desc.Width;
   m_scaleY   = (double)desc.Height / src.desc.Height;
   m_width    = (unsigned)desc.Width;
   m_height   = desc.Height;
 
-  dst.desc        = desc;
+  dst.desc   = desc;
   dst.width  = (unsigned)desc.Width;
   dst.height = desc.Height;
   return PostProcessStatus::SUCCESS;
@@ -244,33 +218,10 @@ ComPtr<ID3D12Resource> CDownsampleEffect::Run(
   TransitionDst(commandList, D3D12_RESOURCE_STATE_COMMON,
     D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
 
-  D3D12_CPU_DESCRIPTOR_HANDLE handle =
+  CBV(device, 0, m_constBuffer.Get(), sizeof(m_consts));
-    m_descHeap->GetCPUDescriptorHandleForHeapStart();
+  SRV(device, 1, src.Get(), m_format);
-  const UINT inc = device->GetDescriptorHandleIncrementSize(
+  UAV(device, 2, m_dst.Get(), m_format);
-    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+  Dispatch(commandList);
-
-  D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
-  cbvDesc.BufferLocation = m_constBuffer->GetGPUVirtualAddress();
-  cbvDesc.SizeInBytes = (UINT)AlignTo(sizeof(m_consts),
-    (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  device->CreateConstantBufferView(&cbvDesc, handle);
-  handle.ptr += inc;
-
-  D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-  srvDesc.Format = m_format;
-  srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
-  srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-  srvDesc.Texture2D.MipLevels = 1;
-  device->CreateShaderResourceView(src.Get(), &srvDesc, handle);
-  handle.ptr += inc;
-
-  D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
-  uavDesc.Format = m_format;
-  uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
-  device->CreateUnorderedAccessView(m_dst.Get(), nullptr, &uavDesc, handle);
-
-  Bind(commandList);
-  commandList->Dispatch(m_threadsX, m_threadsY, 1);
 
   TransitionDst(commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
     D3D12_RESOURCE_STATE_COMMON);

idd/LGIdd/postprocess/effect/CDownsampleEffect.h

@@ -30,9 +30,9 @@ class CDownsampleEffect : public CComputeEffect
 private:
   struct Rule
   {
-    bool greater = false;
+    bool     greater = false;
-    unsigned x = 0;
+    unsigned x       = 0;
-    unsigned y = 0;
+    unsigned y       = 0;
     unsigned targetX = 0;
     unsigned targetY = 0;
   };

idd/LGIdd/postprocess/effect/CHDR16to10Effect.cpp

@@ -22,25 +22,16 @@
 
 #include "CDebug.h"
 
-#include <cstring>
-
 using namespace PostProcessUtil;
 
 bool CHDR16to10Effect::Init(const ComPtr<ID3D12Device3>& device)
 {
-  D3D12_DESCRIPTOR_RANGE ranges[3] = {};
+  D3D12_DESCRIPTOR_RANGE ranges[] =
-  ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
+  {
-  ranges[0].NumDescriptors = 1;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 0),
-  ranges[0].BaseShaderRegister = 0;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0),
-  ranges[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0),
-  ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
+  };
-  ranges[1].NumDescriptors = 1;
-  ranges[1].BaseShaderRegister = 0;
-  ranges[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
-  ranges[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
-  ranges[2].NumDescriptors = 1;
-  ranges[2].BaseShaderRegister = 0;
-  ranges[2].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
 
   const char * shader =
     "cbuffer Constants : register(b0)\n"
@@ -77,35 +68,18 @@ bool CHDR16to10Effect::Init(const ComPtr<ID3D12Device3>& device)
   if (!InitCompute(device, ranges, ARRAYSIZE(ranges), nullptr, 0, shader))
     return false;
 
-  D3D12_HEAP_PROPERTIES heapProps = {};
+  const size_t size = AlignTo(sizeof(m_consts),
-  heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
-
-  D3D12_RESOURCE_DESC desc = {};
-  desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-  desc.Width = AlignTo(sizeof(m_consts),
     (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  desc.Height = 1;
+  HRESULT hr = CreateUploadBuffer(device, size, m_constBuffer);
-  desc.DepthOrArraySize = 1;
-  desc.MipLevels = 1;
-  desc.SampleDesc.Count = 1;
-  desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-
-  HRESULT hr = device->CreateCommittedResource(&heapProps,
-    D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ,
-    nullptr, IID_PPV_ARGS(&m_constBuffer));
   if (FAILED(hr))
   {
     DEBUG_ERROR_HR(hr, "Failed to create HDR16to10 constant buffer");
     return false;
   }
 
-  void * data = nullptr;
+  hr = Upload(m_constBuffer, &m_consts, sizeof(m_consts));
-  D3D12_RANGE readRange = { 0, 0 };
-  hr = m_constBuffer->Map(0, &readRange, &data);
   if (FAILED(hr))
     return false;
-  std::memcpy(data, &m_consts, sizeof(m_consts));
-  m_constBuffer->Unmap(0, nullptr);
 
   return true;
 }
@@ -124,8 +98,8 @@ PostProcessStatus CHDR16to10Effect::SetFormat(
   if (!CreateDefaultTexture(device, desc, m_dst))
     return PostProcessStatus::FAILED;
 
-  m_threadsX = ((unsigned)desc.Width  + (Threads - 1)) / Threads;
+  m_threadsX = Groups((unsigned)desc.Width);
-  m_threadsY = ((unsigned)desc.Height + (Threads - 1)) / Threads;
+  m_threadsY = Groups(desc.Height);
 
   dst.desc   = desc;
   dst.format = FRAME_TYPE_RGBA10;
@@ -151,33 +125,10 @@ ComPtr<ID3D12Resource> CHDR16to10Effect::Run(
   TransitionDst(commandList, D3D12_RESOURCE_STATE_COMMON,
     D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
 
-  D3D12_CPU_DESCRIPTOR_HANDLE handle =
+  CBV(device, 0, m_constBuffer.Get(), sizeof(m_consts));
-    m_descHeap->GetCPUDescriptorHandleForHeapStart();
+  SRV(device, 1, src.Get(), DXGI_FORMAT_R16G16B16A16_FLOAT);
-  const UINT inc = device->GetDescriptorHandleIncrementSize(
+  UAV(device, 2, m_dst.Get(), DXGI_FORMAT_R10G10B10A2_UNORM);
-    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+  Dispatch(commandList);
-
-  D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
-  cbvDesc.BufferLocation = m_constBuffer->GetGPUVirtualAddress();
-  cbvDesc.SizeInBytes = (UINT)AlignTo(sizeof(m_consts),
-    (size_t)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
-  device->CreateConstantBufferView(&cbvDesc, handle);
-  handle.ptr += inc;
-
-  D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-  srvDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
-  srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
-  srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-  srvDesc.Texture2D.MipLevels = 1;
-  device->CreateShaderResourceView(src.Get(), &srvDesc, handle);
-  handle.ptr += inc;
-
-  D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
-  uavDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
-  uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
-  device->CreateUnorderedAccessView(m_dst.Get(), nullptr, &uavDesc, handle);
-
-  Bind(commandList);
-  commandList->Dispatch(m_threadsX, m_threadsY, 1);
 
   TransitionDst(commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
     D3D12_RESOURCE_STATE_COMMON);

idd/LGIdd/postprocess/effect/CRGB24Effect.cpp

@@ -78,8 +78,8 @@ struct CRGB24Effect::State
 
   static bool IsEligible(const D12FrameFormat& format)
   {
-    if (format.hdr ||
+    if (format.hdr                                                   ||
-        format.desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D ||
+        format.desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D  ||
         format.desc.Format    != DXGI_FORMAT_B8G8R8A8_UNORM)
       return false;
 
@@ -123,16 +123,17 @@ struct CRGB24Effect::State
   {
     CSRWExclusiveLock guard(lock);
 
-    const bool formatChanged = !formatValid ||
+    const bool formatChanged =
-      format.resourceDimension != next.desc.Dimension        ||
+      !formatValid                                            ||
-      format.resourceWidth     != next.desc.Width            ||
+      format.resourceDimension != next.desc.Dimension         ||
-      format.resourceHeight    != next.desc.Height           ||
+      format.resourceWidth     != next.desc.Width             ||
-      format.resourceFormat    != next.desc.Format           ||
+      format.resourceHeight    != next.desc.Height            ||
-      format.width             != next.width                 ||
+      format.resourceFormat    != next.desc.Format            ||
-      format.height            != next.height                ||
+      format.width             != next.width                  ||
-      format.format            != next.format                ||
+      format.height            != next.height                 ||
-      format.hdr               != next.hdr                   ||
+      format.format            != next.format                 ||
-      format.hdrPQ             != next.hdrPQ                 ||
+      format.hdr               != next.hdr                    ||
+      format.hdrPQ             != next.hdrPQ                  ||
       format.colorTransform    != next.colorTransform;
 
     if (formatChanged)
@@ -194,7 +195,8 @@ struct CRGB24Effect::State
           const uint64_t threshold         = relativeThreshold > 50000ULL ?
             relativeThreshold : 50000ULL;
           // Prefer the bandwidth saving unless native is meaningfully faster.
-          const bool     usePacked         = packedMean <= nativeMean ||
+          const bool usePacked =
+            packedMean <= nativeMean              ||
             packedMean - nativeMean <= threshold;
 
           DEBUG_INFO(
@@ -281,15 +283,11 @@ bool CRGB24Effect::Init(const ComPtr<ID3D12Device3>& device)
   if (!g_settings.ReadBoolValue(L"AllowRGB24", true))
     return false;
 
-  D3D12_DESCRIPTOR_RANGE ranges[2] = {};
+  D3D12_DESCRIPTOR_RANGE ranges[] =
-  ranges[0].RangeType                         = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
+  {
-  ranges[0].NumDescriptors                    = 1;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0),
-  ranges[0].BaseShaderRegister                = 0;
+    Range(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0),
-  ranges[0].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
+  };
-  ranges[1].RangeType                         = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
-  ranges[1].NumDescriptors                    = 1;
-  ranges[1].BaseShaderRegister                = 0;
-  ranges[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
 
   const char * shader =
     "Texture2D<float4> src : register(t0);\n"
@@ -483,7 +481,8 @@ PostProcessStatus CRGB24Effect::SetFormat(const ComPtr<ID3D12Device3>& device,
 
   const UINT64 packedPitch = AlignTo<UINT64>(
     src.desc.Width * 3, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
-  if (!src.desc.Height || packedPitch > LONG_MAX ||
+  if (!src.desc.Height                              ||
+      packedPitch > LONG_MAX                        ||
       packedPitch > UINT64_MAX / src.desc.Height)
   {
     m_state->Reject();
@@ -495,7 +494,8 @@ PostProcessStatus CRGB24Effect::SetFormat(const ComPtr<ID3D12Device3>& device,
   const UINT64 maxUAVSize =
     (1ULL << D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP) *
       sizeof(uint32_t);
-  if (bufferSize > UINT32_MAX || bufferSize > maxUAVSize)
+  if (bufferSize > UINT32_MAX ||
+      bufferSize > maxUAVSize)
   {
     m_state->Reject();
     m_dst.Reset();
@@ -510,8 +510,8 @@ PostProcessStatus CRGB24Effect::SetFormat(const ComPtr<ID3D12Device3>& device,
   }
 
   const unsigned dataWidth = (unsigned)(packedPitch / 4);
-  m_threadsX = (dataWidth       + (Threads - 1)) / Threads;
+  m_threadsX = Groups(dataWidth);
-  m_threadsY = (src.desc.Height + (Threads - 1)) / Threads;
+  m_threadsY = Groups(src.desc.Height);
   m_width    = (unsigned)src.desc.Width;
   m_height   = src.desc.Height;
   m_pitch    = (unsigned)packedPitch;
@@ -535,18 +535,7 @@ ComPtr<ID3D12Resource> CRGB24Effect::Run(const ComPtr<ID3D12Device3>& device,
   TransitionDst(commandList, D3D12_RESOURCE_STATE_COMMON,
     D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
 
-  D3D12_CPU_DESCRIPTOR_HANDLE handle =
+  SRV(device, 0, src.Get(), DXGI_FORMAT_B8G8R8A8_UNORM);
-    m_descHeap->GetCPUDescriptorHandleForHeapStart();
-  const UINT inc = device->GetDescriptorHandleIncrementSize(
-    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
-
-  D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-  srvDesc.Format                  = DXGI_FORMAT_B8G8R8A8_UNORM;
-  srvDesc.ViewDimension           = D3D12_SRV_DIMENSION_TEXTURE2D;
-  srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-  srvDesc.Texture2D.MipLevels     = 1;
-  device->CreateShaderResourceView(src.Get(), &srvDesc, handle);
-  handle.ptr += inc;
 
   D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
   uavDesc.Format                      = DXGI_FORMAT_R32_TYPELESS;
@@ -555,10 +544,10 @@ ComPtr<ID3D12Resource> CRGB24Effect::Run(const ComPtr<ID3D12Device3>& device,
   uavDesc.Buffer.StructureByteStride  = 0;
   uavDesc.Buffer.CounterOffsetInBytes = 0;
   uavDesc.Buffer.Flags                = D3D12_BUFFER_UAV_FLAG_RAW;
-  device->CreateUnorderedAccessView(m_dst.Get(), nullptr, &uavDesc, handle);
+  device->CreateUnorderedAccessView(
+    m_dst.Get(), nullptr, &uavDesc, Handle(device, 1));
 
-  Bind(commandList);
+  Dispatch(commandList);
-  commandList->Dispatch(m_threadsX, m_threadsY, 1);
 
   TransitionDst(commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
     D3D12_RESOURCE_STATE_COMMON);