Changeset 108229 in vbox

Timestamp:

Feb 14, 2025 5:47:02 PM (2 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

167549

Message:

libs/dxvk-2.3.1: D3D11 video decode API implementation (disabled)

Location:

trunk/src/libs/dxvk-2.3.1

Files:

• Makefile.kmk (modified) (6 diffs)
• src/d3d11/d3d11_device.cpp (modified) (11 diffs)
• src/d3d11/d3d11_device.h (modified) (1 diff)
• src/d3d11/d3d11_include.h (modified) (1 diff)
• src/d3d11/d3d11_texture.cpp (modified) (1 diff)
• src/d3d11/d3d11_video.cpp (modified) (7 diffs)
• src/d3d11/d3d11_video.h (modified) (1 diff)
• src/dxvk/dxvk_adapter.cpp (modified) (9 diffs)
• src/dxvk/dxvk_adapter.h (modified) (2 diffs)
• src/dxvk/dxvk_buffer.cpp (modified) (1 diff)
• src/dxvk/dxvk_buffer.h (modified) (1 diff)
• src/dxvk/dxvk_cmdlist.cpp (modified) (13 diffs)
• src/dxvk/dxvk_cmdlist.h (modified) (7 diffs)
• src/dxvk/dxvk_context.h (modified) (1 diff)
• src/dxvk/dxvk_device.cpp (modified) (1 diff)
• src/dxvk/dxvk_device.h (modified) (3 diffs)
• src/dxvk/dxvk_device_info.h (modified) (1 diff)
• src/dxvk/dxvk_extensions.h (modified) (1 diff)
• src/dxvk/dxvk_image.cpp (modified) (1 diff)
• src/dxvk/dxvk_image.h (modified) (1 diff)
• src/dxvk/dxvk_instance.cpp (modified) (1 diff)
• src/util/com/com_include.h (modified) (1 diff)
• src/vulkan/vulkan_loader.h (modified) (2 diffs)

trunk/src/libs/dxvk-2.3.1/Makefile.kmk

@@ -56 +56 @@
  VBOX_DXVK_CXXFLAGS_WIN += -wd5204 # class has virtual functions, but its trivial destructor is not virtual
  VBOX_DXVK_CXXFLAGS_WIN += -wd5219 # implicit conversion from 'int' to 'float', possible loss of data
+ VBOX_DXVK_CXXFLAGS_WIN += -wd5246 # 'anonymous struct or union': the initialization of a subobject should be wrapped in braces
+ VBOX_DXVK_CXXFLAGS_WIN += -wd5249 # '_DXVA_ExtendedFormat::NominalRange' of type 'DXVA_NominalRange' has named enumerators with values that cannot be represented in the given bit field width of '3'.
  VBOX_DXVK_CXXFLAGS_WIN += -wd5264 # 'MaxPendingSubmits': 'const' variable is not used
  VBOX_DXVK_CXXFLAGS_WIN += -wd5267 # definition of implicit copy constructor for 'dxvk::DxvkSparseBindSubmission' is deprecated because it has a user-provided destructor
 else
  VBOX_DXVK_PLATFORM = DXVK_PLATFORM_LINUX
+endif
+
+VBOX_DXVK_COMMON_DEFINES =
+ifdef VBOX_WITH_DXVK_VIDEO
+ VBOX_DXVK_COMMON_DEFINES += \
+        VBOX_WITH_DXVK_VIDEO
 endif
 
@@ -98 +106 @@
 VBox-DxVkNativeUtil_TEMPLATE       = VBoxR3DllNonPedantic
 VBox-DxVkNativeUtil_DEFS           = \
+        $(VBOX_DXVK_COMMON_DEFINES) \
         DXVK_NATIVE \
         NOMINMAX \
@@ -191 +200 @@
 VBox-DxVkNativeDxVk_TEMPLATE       = VBoxR3DllNonPedantic
 VBox-DxVkNativeDxVk_DEFS           = \
+        $(VBOX_DXVK_COMMON_DEFINES) \
         DXVK_NATIVE \
         NOMINMAX \
@@ -266 +276 @@
         src/dxvk/hud/dxvk_hud_renderer.cpp \
         src/dxvk/platform/dxvk_headless_exts.cpp
+ifdef VBOX_WITH_DXVK_VIDEO
+VBox-DxVkNativeDxVk_SOURCES       += \
+        src/dxvk/dxvk_video_decoder.cpp
+endif
 VBox-DxVkNativeDxVk_VBOX_SHADERS := \
         $(PATH_SUB_CURRENT)/src/dxvk/shaders/dxvk_clear_buffer_u.comp \
@@ -328 +342 @@
 VBox-DxVkNativeD3D11_TEMPLATE        = VBoxR3DllNonPedantic
 VBox-DxVkNativeD3D11_DEFS            = \
+        $(VBOX_DXVK_COMMON_DEFINES) \
         DXVK_NATIVE \
         NOMINMAX \
@@ -418 +433 @@
 VBoxDxVk_TEMPLATE = VBoxR3DllNonPedantic
 VBoxDxVk_DEFS     = \
+        $(VBOX_DXVK_COMMON_DEFINES) \
         DXVK_NATIVE \
         NOMINMAX \

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_device.cpp

@@ +1 @@
+#if defined(VBOX_WITH_DXVK_VIDEO) && defined(RT_OS_WINDOWS)
+#define INITGUID
+#endif
+
 #include <algorithm>
 #include <cstring>
@@ -2811 +2815 @@
   : m_container(pContainer), m_device(pDevice) {
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    InitDecoderProfiles();
+#endif
   }
 
@@ -2840 +2847 @@
     const D3D11_VIDEO_DECODER_CONFIG*                   pConfig,
           ID3D11VideoDecoder**                          ppDecoder) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = ProfileIndexFromDecoderDesc(pVideoDesc);
+    if (i >= 0) {
+      const DxvkVideoDecodeProfileInfo& v = m_decoderProfiles[i].second;
+
+      try {
+        *ppDecoder = ref(new D3D11VideoDecoder(m_device, *pVideoDesc, *pConfig, v));
+        return S_OK;
+      } catch (const DxvkError& e) {
+        Logger::err(e.message());
+        return E_FAIL;
+      }
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::CreateVideoDecoder: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2882 +2905 @@
     const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC*         pDesc,
           ID3D11VideoDecoderOutputView**                ppVDOVView) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = GetDecoderProfileIndex(pDesc->DecodeProfile);
+    if (i >= 0) {
+      try {
+        *ppVDOVView = ref(new D3D11VideoDecoderOutputView(m_device, pResource, *pDesc));
+        return S_OK;
+      } catch (const DxvkError& e) {
+        Logger::err(e.message());
+        return E_FAIL;
+      }
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::CreateVideoDecoderOutputView: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2931 +2968 @@
 
   UINT STDMETHODCALLTYPE D3D11VideoDevice::GetVideoDecoderProfileCount() {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    return m_decoderProfiles.size();
+#else
     Logger::err("D3D11VideoDevice::GetVideoDecoderProfileCount: Stub");
     return 0;
+#endif
   }
 
@@ -2939 +2980 @@
           UINT                                          Index,
           GUID*                                         pDecoderProfile) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (Index < m_decoderProfiles.size()) {
+      if (pDecoderProfile != nullptr)
+        *pDecoderProfile = m_decoderProfiles[Index].first.guid;
+      return S_OK;
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::GetVideoDecoderProfile: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2948 +2998 @@
           DXGI_FORMAT                                   Format,
           BOOL*                                         pSupported) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = GetDecoderProfileIndex(*pDecoderProfile);
+    if (i >= 0) {
+      const D3D11VideoDecoderProfile &p = m_decoderProfiles[i].first;
+
+      const auto it = std::find_if(p.supportedFormats.begin(), p.supportedFormats.end(),
+        [Format](DXGI_FORMAT f) -> bool { return f == Format; });
+
+      if (pSupported != nullptr)
+        *pSupported = it != p.supportedFormats.end();
+      return S_OK;
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::CheckVideoDecoderFormat: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2956 +3021 @@
     const D3D11_VIDEO_DECODER_DESC*                     pDesc,
           UINT*                                         pCount) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = ProfileIndexFromDecoderDesc(pDesc);
+    if (i >= 0) {
+      const D3D11VideoDecoderProfile& p = m_decoderProfiles[i].first;
+
+      if (pCount != nullptr)
+        *pCount = p.decoderConfigs.size();
+      return S_OK;
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::GetVideoDecoderConfigCount: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2965 +3042 @@
           UINT                                          Index,
           D3D11_VIDEO_DECODER_CONFIG*                   pConfig) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = ProfileIndexFromDecoderDesc(pDesc);
+    if (i >= 0) {
+      const D3D11VideoDecoderProfile &p = m_decoderProfiles[i].first;
+
+      if (Index >= p.decoderConfigs.size())
+        return E_INVALIDARG;
+
+      if (pConfig != nullptr)
+        *pConfig = p.decoderConfigs[Index];
+      return S_OK;
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::GetVideoDecoderConfig: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -2974 +3066 @@
     const GUID*                                         pDecoderProfile,
           D3D11_VIDEO_CONTENT_PROTECTION_CAPS*          pCaps) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const int i = GetDecoderProfileIndex(*pDecoderProfile);
+    if (i >= 0) {
+      if (pCaps != nullptr)
+        memset(pCaps, 0, sizeof(*pCaps));
+      return S_OK;
+    }
+    return E_INVALIDARG;
+#else
     Logger::err("D3D11VideoDevice::GetContentProtectionCaps: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -3002 +3104 @@
     return m_container->SetPrivateDataInterface(Name, pData);
   }
+
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+  void D3D11VideoDevice::InitDecoderProfiles() {
+    Rc<DxvkDevice> dxvkDevice = m_device->GetDXVKDevice();
+
+    /* Check that video decoding is supported. */
+    if (!dxvkDevice->features().khrVideoDecodeQueue
+     || dxvkDevice->queues().videoDecode.queueHandle == VK_NULL_HANDLE)
+      return;
+
+    /*
+     * Create a list of D3D11 profiles descriptions (m_decoderProfiles) with backlinks to
+     * supported Vulkan video profiles.
+     */
+
+    /* A Vulkan video profile with a list of compatible D3D11 profiles. */
+    struct D3D11VideoDecodeProfileMapping {
+      DxvkVideoDecodeProfileInfo&           dxvkProfile;
+      std::vector<D3D11VideoDecoderProfile> d3dProfiles;
+    };
+    std::vector<D3D11VideoDecodeProfileMapping> mappings;
+
+    /*
+     * D3D11 profiles descriptions.
+     */
+    const struct D3D11VideoDecoderProfile profile_ModeH264_VLD_NoFGT = {
+      /* .guid = */ DXVA2_ModeH264_VLD_NoFGT,  /* D3D11_DECODER_PROFILE_H264_VLD_NOFGT */
+      /* .decoderConfigs = */ std::vector<D3D11_VIDEO_DECODER_CONFIG> {
+        {
+          /* .guidConfigBitstreamEncryption = */ DXVA2_NoEncrypt,
+          /* .guidConfigMBcontrolEncryption = */ DXVA2_NoEncrypt,
+          /* .guidConfigResidDiffEncryption = */ DXVA2_NoEncrypt,
+          /* .ConfigBitstreamRaw = */ 1,
+          /* .ConfigMBcontrolRasterOrder = */ 0,
+          /* .ConfigResidDiffHost = */ 0,
+          /* .ConfigSpatialResid8 = */ 0,
+          /* .ConfigResid8Subtraction = */ 0,
+          /* .ConfigSpatialHost8or9Clipping = */ 0,
+          /* .ConfigSpatialResidInterleaved = */ 0,
+          /* .ConfigIntraResidUnsigned = */ 0,
+          /* .ConfigResidDiffAccelerator = */ 1,
+          /* .ConfigHostInverseScan = */ 1,
+          /* .ConfigSpecificIDCT = */ 2,
+          /* .Config4GroupedCoefs = */ 0,
+          /* .ConfigMinRenderTargetBuffCount = */ 3,
+          /* .ConfigDecoderSpecific = */ 0
+        },
+        {
+          /* .guidConfigBitstreamEncryption = */ DXVA2_NoEncrypt,
+          /* .guidConfigMBcontrolEncryption = */ DXVA2_NoEncrypt,
+          /* .guidConfigResidDiffEncryption = */ DXVA2_NoEncrypt,
+          /* .ConfigBitstreamRaw = */ 2,
+          /* .ConfigMBcontrolRasterOrder = */ 0,
+          /* .ConfigResidDiffHost = */ 0,
+          /* .ConfigSpatialResid8 = */ 0,
+          /* .ConfigResid8Subtraction = */ 0,
+          /* .ConfigSpatialHost8or9Clipping = */ 0,
+          /* .ConfigSpatialResidInterleaved = */ 0,
+          /* .ConfigIntraResidUnsigned = */ 0,
+          /* .ConfigResidDiffAccelerator = */ 1,
+          /* .ConfigHostInverseScan = */ 1,
+          /* .ConfigSpecificIDCT = */ 2,
+          /* .Config4GroupedCoefs = */ 0,
+          /* .ConfigMinRenderTargetBuffCount = */ 3,
+          /* .ConfigDecoderSpecific = */ 0
+        }
+      },
+      /* .supportedFormats = */ std::vector<DXGI_FORMAT> {
+          DXGI_FORMAT_NV12
+      }
+    };
+
+    /*
+     * Add desired Vulkan profile descriptions to the 'mappings'.
+     */
+    m_vulkanDecodeProfiles[0].profileName            = "H.264";
+    m_vulkanDecodeProfiles[0].h264ProfileInfo        =
+      { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, nullptr,
+        STD_VIDEO_H264_PROFILE_IDC_HIGH,
+        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR
+      };
+    m_vulkanDecodeProfiles[0].profileInfo            =
+      { VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, &m_vulkanDecodeProfiles[0].h264ProfileInfo,
+        VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR,
+        VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
+        VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
+        VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR
+      };
+    m_vulkanDecodeProfiles[0].decodeH264Capabilities =
+      { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR };
+    m_vulkanDecodeProfiles[0].decodeCapabilities     =
+      { VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, &m_vulkanDecodeProfiles[0].decodeH264Capabilities };
+    m_vulkanDecodeProfiles[0].videoCapabilities      =
+      { VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, &m_vulkanDecodeProfiles[0].decodeCapabilities };
+
+    mappings.push_back({ m_vulkanDecodeProfiles[0] });
+    mappings.back().d3dProfiles.push_back(profile_ModeH264_VLD_NoFGT);
+
+    /// @todo More Vulkan profiles: H.265 and AV1
+
+    /*
+     * Query caps of every Vulkan profile and add supported profiles to the m_decoderProfiles list.
+     */
+    auto vki = dxvkDevice->adapter()->vki();
+    auto physicalDevice = dxvkDevice->adapter()->handle();
+
+    for (auto& m: mappings) {
+      VkResult vr = vki->vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice,
+        &m.dxvkProfile.profileInfo, &m.dxvkProfile.videoCapabilities);
+      if (vr != VK_SUCCESS)
+        continue;
+
+      Logger::info(str::format("DXVK: Video Decode: ", m.dxvkProfile.profileName, ":"
+        " separate reference images=",
+        (m.dxvkProfile.videoCapabilities.flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR) ? "1" : "0",
+        ", DPB and output distinct=",
+        (m.dxvkProfile.decodeCapabilities.flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) ? "1" : "0",
+        ", DPB and output coincide=",
+        (m.dxvkProfile.decodeCapabilities.flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) ? "1" : "0"));
+
+      m.dxvkProfile.videoQueueHasTransfer =
+        (dxvkDevice->adapter()->getQueueFlags(dxvkDevice->queues().videoDecode.queueFamily) & VK_QUEUE_TRANSFER_BIT) != 0;
+
+      /* Query format caps of DPB images. */
+      VkVideoProfileListInfoKHR profileListInfo =
+        { VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR };
+      profileListInfo.profileCount = 1;
+      profileListInfo.pProfiles    = &m.dxvkProfile.profileInfo;
+
+      VkPhysicalDeviceVideoFormatInfoKHR physicalFormatInfo =
+        { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, &profileListInfo };
+
+      /* 42.4.2. Video Format Capabilities */
+      switch (m.dxvkProfile.decodeCapabilities.flags
+        & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR
+         | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR))
+      {
+        case VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR
+          | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR:
+        case VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR:
+          physicalFormatInfo.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR
+                                        | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR
+                                        | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+          break;
+        case VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR:
+          physicalFormatInfo.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
+          break;
+        default:
+          continue; /* Must not be returned by Vulkan. */
+      }
+
+      uint32_t videoFormatPropertyCount = 0;
+      vr = vki->vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice,
+        &physicalFormatInfo, &videoFormatPropertyCount, nullptr);
+      if (vr != VK_SUCCESS)
+        continue;
+
+      std::vector<VkVideoFormatPropertiesKHR> videoFormatProperties(videoFormatPropertyCount,
+        { VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR });
+      vr = vki->vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice,
+        &physicalFormatInfo, &videoFormatPropertyCount, videoFormatProperties.data());
+      if (vr != VK_SUCCESS)
+        continue;
+
+      /* Verify that DXGI_FORMAT_NV12 is supported for DPB. */
+      const VkVideoFormatPropertiesKHR *pFormatProperties = nullptr;
+      for (uint32_t i = 0; i < videoFormatPropertyCount; ++i) {
+        const VkVideoFormatPropertiesKHR &p = videoFormatProperties[i];
+        if (p.format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM) {
+          pFormatProperties = &videoFormatProperties[i];
+          break;
+        }
+      }
+
+      if (pFormatProperties == nullptr)
+        continue;
+
+      m.dxvkProfile.dpbFormatProperties = *pFormatProperties;
+
+      /* Add supported D3D11 profiles to the list. */
+      for (auto &p: m.d3dProfiles) {
+        m_decoderProfiles.push_back({ p, m.dxvkProfile });
+      }
+    }
+  }
+
+
+  int D3D11VideoDevice::GetDecoderProfileIndex(const GUID &guid)
+  {
+    const auto it = std::find_if(m_decoderProfiles.begin(), m_decoderProfiles.end(),
+      [ &guid ](std::pair<D3D11VideoDecoderProfile, DxvkVideoDecodeProfileInfo&>& p) -> bool
+        { return p.first.guid == guid; });
+    if (it != m_decoderProfiles.end())
+      return std::distance(m_decoderProfiles.begin(), it);
+    return -1;
+  }
+
+  int D3D11VideoDevice::ProfileIndexFromDecoderDesc(
+    const D3D11_VIDEO_DECODER_DESC* pVideoDesc)
+  {
+    const int i = GetDecoderProfileIndex(pVideoDesc->Guid);
+    if (i >= 0) {
+      const D3D11VideoDecoderProfile &p = m_decoderProfiles[i].first;
+
+      const auto it = std::find_if(p.supportedFormats.begin(), p.supportedFormats.end(),
+        [ OutputFormat = pVideoDesc->OutputFormat ](DXGI_FORMAT f) -> bool { return f == OutputFormat; });
+      if (it == p.supportedFormats.end())
+        return -1;
+
+      const DxvkVideoDecodeProfileInfo& v = m_decoderProfiles[i].second;
+
+      if (pVideoDesc->SampleWidth > v.videoCapabilities.maxCodedExtent.width
+       || pVideoDesc->SampleHeight > v.videoCapabilities.maxCodedExtent.height)
+        return -1;
+
+      if (pVideoDesc->SampleWidth < v.videoCapabilities.minCodedExtent.width
+       || pVideoDesc->SampleHeight < v.videoCapabilities.minCodedExtent.height)
+        return -1;
+    }
+    return i;
+  }
+#endif /* VBOX_WITH_DXVK_VIDEO */
 
 

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_device.h

@@ -695 +695 @@
     D3D11Device*     m_device;
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    struct D3D11VideoDecoderProfile {
+      GUID guid;
+      std::vector<D3D11_VIDEO_DECODER_CONFIG> decoderConfigs;
+      std::vector<DXGI_FORMAT>              supportedFormats;
+    };
+
+    /* Vulkan video profiles, supported by DxvkVideoDecoder. Not necessarily supported by hardware. */
+    std::array<DxvkVideoDecodeProfileInfo, 1> m_vulkanDecodeProfiles;
+
+    /* Supported D3D11 profiles with a reference to the underlaying Vulkan profile (m_vulkanDecodeProfiles).
+     * This is what the D3D11 methods expose to applications.
+     */
+    std::vector<std::pair<D3D11VideoDecoderProfile, DxvkVideoDecodeProfileInfo&> > m_decoderProfiles;
+
+    void InitDecoderProfiles();
+    int GetDecoderProfileIndex(
+      const GUID &guid);
+    int ProfileIndexFromDecoderDesc(
+      const D3D11_VIDEO_DECODER_DESC* pVideoDesc);
+#endif
+
   };
 

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_include.h

@@ -4 +4 @@
 
 #include <d3d11_4.h>
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+// For video decoding
+#include <d3d9.h>
+#include <dxva.h>
+#include <dxva2api.h>
+#endif

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_texture.cpp

@@ -80 +80 @@
     }
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_desc.BindFlags & D3D11_BIND_DECODER)
+      formatFamily.Add(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM);
+#endif
+
     // The image must be marked as mutable if it can be reinterpreted
     // by a view with a different format. Depth-stencil formats cannot

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_video.cpp

@@ -8 +8 @@
 
 namespace dxvk {
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+  D3D11VideoDecoder::D3D11VideoDecoder(
+          D3D11Device*                    pDevice,
+          const D3D11_VIDEO_DECODER_DESC  &VideoDesc,
+          const D3D11_VIDEO_DECODER_CONFIG &Config,
+          const DxvkVideoDecodeProfileInfo& profile)
+  : D3D11DeviceChild<ID3D11VideoDecoder>(pDevice),
+    m_desc(VideoDesc), m_config(Config),
+    m_device(pDevice->GetDXVKDevice()) {
+    DXGI_VK_FORMAT_INFO formatInfo = pDevice->LookupFormat(
+      m_desc.OutputFormat, DXGI_VK_FORMAT_MODE_COLOR);
+
+    if (formatInfo.Format == VK_FORMAT_UNDEFINED)
+      throw DxvkError(str::format("D3D11VideoDecoder: Unsupported output DXGI format: ", m_desc.OutputFormat));
+
+    m_videoDecoder = m_device->createVideoDecoder(profile, m_desc.SampleWidth, m_desc.SampleHeight, formatInfo.Format);
+  }
+
+
+  D3D11VideoDecoder::~D3D11VideoDecoder() {
+
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoDecoder::QueryInterface(
+          REFIID                  riid,
+          void**                  ppvObject) {
+    if (riid == __uuidof(IUnknown)
+     || riid == __uuidof(ID3D11DeviceChild)
+     || riid == __uuidof(ID3D11VideoDecoder)) {
+      *ppvObject = ref(this);
+      return S_OK;
+    }
+
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoDecoder), riid)) {
+      Logger::warn("D3D11VideoDecoder::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
+    return E_NOINTERFACE;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoDecoder::GetCreationParameters(
+        D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig) {
+    if (pVideoDesc != nullptr)
+      *pVideoDesc = m_desc;
+    if (pConfig != nullptr)
+      *pConfig = m_config;
+    return S_OK;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoDecoder::GetDriverHandle(
+        HANDLE *pDriverHandle) {
+    if (pDriverHandle != nullptr)
+      *pDriverHandle = m_videoDecoder.ptr();
+    return S_OK;
+  }
+
+
+  HRESULT D3D11VideoDecoder::GetDecoderBuffer(
+          D3D11_VIDEO_DECODER_BUFFER_TYPE Type,
+          UINT*                           BufferSize,
+          void**                          ppBuffer)
+  {
+    if (Type >= m_decoderBuffers.size())
+      return E_INVALIDARG;
+
+    D3D11VideoDecoderBuffer& decoderBuffer = m_decoderBuffers[Type];
+
+    if (decoderBuffer.buffer.size() == 0) {
+      size_t cbBuffer;
+      switch (Type)
+      {
+        case D3D11_VIDEO_DECODER_BUFFER_BITSTREAM:
+          /* Arbitrary. Sufficiently big for one compressed frame (usually). */
+          cbBuffer = 1024*1024;
+          break;
+        default:
+          cbBuffer = 65536;
+      }
+      decoderBuffer.buffer.resize(cbBuffer);
+    }
+
+    if (BufferSize != nullptr)
+      *BufferSize = decoderBuffer.buffer.size();
+    if (ppBuffer != nullptr)
+      *ppBuffer = decoderBuffer.buffer.data();
+    return S_OK;
+  }
+
+
+  HRESULT D3D11VideoDecoder::ReleaseDecoderBuffer(
+          D3D11_VIDEO_DECODER_BUFFER_TYPE Type)
+  {
+    if (Type >= m_decoderBuffers.size())
+      return E_INVALIDARG;
+
+    return S_OK;
+  }
+
+
+  template<typename DXVA_Slice_H264_T>
+  static bool GetSliceOffsetsAndNALType(
+          DxvkVideoDecodeInputParameters *pParms,
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pSliceDesc,
+    const void *pSlices,
+    const uint8_t *pBitStream,
+          uint32_t cbBitStream) {
+     const DXVA_Slice_H264_T *paSlices = (DXVA_Slice_H264_T *)pSlices;
+     const uint32_t cSlices = pSliceDesc->DataSize / sizeof(DXVA_Slice_H264_T);
+
+     /* D3D11VideoDecoder::GetVideoDecodeH264InputParameters checks that 'pSliceDesc->DataSize' is less than
+      * the size of D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL buffer that is assigned in
+      * D3D11VideoDecoder::GetDecoderBuffer. I.e. 'cSlices' is limuted too.
+      */
+     pParms->sliceOffsets.resize(cSlices);
+
+     for (uint32_t i = 0; i < cSlices; ++i) {
+       const DXVA_Slice_H264_T& slice = paSlices[i];
+
+       if (slice.SliceBytesInBuffer > cbBitStream
+        || slice.BSNALunitDataLocation > cbBitStream - slice.SliceBytesInBuffer
+        || slice.SliceBytesInBuffer < 4) { /* NALU header: 00, 00, 01, xx */
+         Logger::warn(str::format("D3D11VideoDecoder::GetH264: Invalid slice at ",
+           slice.BSNALunitDataLocation, "/", slice.SliceBytesInBuffer, ", bitstream size ", cbBitStream));
+         return false;
+       }
+
+       if (slice.wBadSliceChopping) {
+         /* Should not happen because we use a sufficiently big bitstream buffer (see GetDecoderBuffer). */
+         Logger::warn(str::format("D3D11VideoDecoder::GetH264: Ignored slice with wBadSliceChopping ",
+           slice.wBadSliceChopping));
+         return false; /// @todo not supported yet
+       }
+
+       pParms->sliceOffsets[i] = slice.BSNALunitDataLocation;
+
+       const uint8_t *pu8NALHdr = pBitStream + slice.BSNALunitDataLocation;
+       const uint8_t nal_unit_type = pu8NALHdr[3] & 0x1F;
+
+       Logger::debug(str::format("NAL[", i, "]=", (uint32_t)nal_unit_type, " at ",
+         slice.BSNALunitDataLocation, "/", slice.SliceBytesInBuffer));
+
+       if (i == 0)
+         pParms->nal_unit_type = nal_unit_type;
+     }
+
+     return true;
+  }
+
+
+  bool D3D11VideoDecoder::GetVideoDecodeH264InputParameters(
+          UINT BufferCount,
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDescs,
+          DxvkVideoDecodeInputParameters *pParms) {
+    /*
+     * Fetch all pieces of data from available buffers.
+     */
+    const DXVA_PicParams_H264*             pPicParams     = nullptr;
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pPicParamsDesc = nullptr;
+    const DXVA_Qmatrix_H264*               pQmatrix       = nullptr;
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pQmatrixDesc   = nullptr;
+    const void*                            pSlices        = nullptr;
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pSliceDesc     = nullptr;
+    const uint8_t*                         pBitStream     = nullptr;
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pBitStreamDesc = nullptr;
+
+    for (UINT i = 0; i < BufferCount; ++i) {
+      const auto& desc = pBufferDescs[i];
+      if (desc.BufferType >= m_decoderBuffers.size()) {
+        Logger::warn(str::format("DXVK: Video Decode: Ignored buffer type ", desc.BufferType));
+        continue;
+      }
+
+      D3D11VideoDecoderBuffer const &b = m_decoderBuffers[desc.BufferType];
+      Logger::debug(str::format("D3D11VideoDecoder::GetH264: Type ", desc.BufferType, ", size ", b.buffer.size()));
+
+      if (desc.DataSize > b.buffer.size()) {
+        Logger::warn(str::format("DXVK: Video Decode: Buffer ", desc.BufferType, " invalid size: ", desc.DataSize, " > ", b.buffer.size()));
+        continue;
+      }
+
+      switch (desc.BufferType) {
+        case D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS:
+          pPicParams = (DXVA_PicParams_H264 *)b.buffer.data();
+          pPicParamsDesc = &desc;
+          break;
+
+        case D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX:
+          pQmatrix = (DXVA_Qmatrix_H264 *)b.buffer.data();
+          pQmatrixDesc = &desc;
+          break;
+
+        case D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL:
+          pSlices = b.buffer.data();
+          pSliceDesc = &desc;
+          break;
+
+        case D3D11_VIDEO_DECODER_BUFFER_BITSTREAM:
+          pBitStream = (uint8_t *)b.buffer.data();
+          pBitStreamDesc = &desc;
+          break;
+
+        default:
+          break;
+      }
+    }
+
+    if (pPicParams == nullptr || pSlices == nullptr || pBitStream == nullptr) {
+      Logger::warn(str::format("DXVK: Video Decode: Not enough data:"
+        " PicParams ", (uint32_t)(pPicParams != nullptr),
+        " Slice ", (uint32_t)(pSlices != nullptr),
+        " BitStream ", (uint32_t)(pBitStream != nullptr)));
+      return false;
+    }
+
+    if (pPicParamsDesc->DataSize < sizeof(DXVA_PicParams_H264)) {
+      Logger::warn(str::format("DXVK: Video Decode: PicParams buffer size is too small: ", pPicParamsDesc->DataSize));
+      return false;
+    }
+
+    if (pQmatrixDesc->DataSize < sizeof(DXVA_Qmatrix_H264)) {
+      Logger::warn(str::format("DXVK: Video Decode: Qmatrix buffer size is too small: ", pQmatrixDesc->DataSize));
+      return false;
+    }
+
+    struct DxvkVideoDecodeInputParameters &p = *pParms;
+
+    p.sps.flags.constraint_set0_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.constraint_set1_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.constraint_set2_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.constraint_set3_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.constraint_set4_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.constraint_set5_flag                 = 0; /* not known, assume unconstrained */
+    p.sps.flags.direct_8x8_inference_flag            = pPicParams->ContinuationFlag
+                                                      ? (pPicParams->direct_8x8_inference_flag ? 1 : 0)
+                                                      : 0;
+    p.sps.flags.mb_adaptive_frame_field_flag         = pPicParams->MbaffFrameFlag ? 1 : 0; /// @todo Is it?
+    p.sps.flags.frame_mbs_only_flag                  = pPicParams->frame_mbs_only_flag ? 1 : 0;
+    p.sps.flags.delta_pic_order_always_zero_flag     = pPicParams->ContinuationFlag
+                                                      ? (pPicParams->delta_pic_order_always_zero_flag ? 1 : 0)
+                                                      : 0;
+    p.sps.flags.separate_colour_plane_flag           = 0; /* 4:4:4 only. Apparently DXVA decoding profiles do not use this flags. */
+    p.sps.flags.gaps_in_frame_num_value_allowed_flag = 1; /// @todo unknown
+    p.sps.flags.qpprime_y_zero_transform_bypass_flag = 0; /// @todo unknown
+    p.sps.flags.frame_cropping_flag                  = 0; /* not used */
+    p.sps.flags.seq_scaling_matrix_present_flag      = 0; /* not used */
+    p.sps.flags.vui_parameters_present_flag          = 0; /* not used */
+    p.sps.profile_idc                                = STD_VIDEO_H264_PROFILE_IDC_HIGH; /* Unknown */
+    p.sps.level_idc                                  = StdVideoH264LevelIdc(0); /* Unknown, set to maxLevelIdc by Dxvk decoder. */
+    p.sps.chroma_format_idc                          = StdVideoH264ChromaFormatIdc(pPicParams->chroma_format_idc);
+    p.sps.seq_parameter_set_id                       = 0; /* Unknown, will be inferred by the Dxvk decoder. */
+    p.sps.bit_depth_luma_minus8                      = pPicParams->bit_depth_luma_minus8;
+    p.sps.bit_depth_chroma_minus8                    = pPicParams->bit_depth_chroma_minus8;
+    p.sps.log2_max_frame_num_minus4                  = pPicParams->ContinuationFlag
+                                                        ? pPicParams->log2_max_frame_num_minus4
+                                                        : 0;
+    p.sps.pic_order_cnt_type                         = pPicParams->ContinuationFlag
+                                                        ? StdVideoH264PocType(pPicParams->pic_order_cnt_type)
+                                                        : StdVideoH264PocType(0);
+    p.sps.offset_for_non_ref_pic                     = 0; /// @todo unknown
+    p.sps.offset_for_top_to_bottom_field             = 0; /// @todo unknown
+    p.sps.log2_max_pic_order_cnt_lsb_minus4          = pPicParams->ContinuationFlag
+                                                        ? pPicParams->log2_max_pic_order_cnt_lsb_minus4
+                                                        : 0;
+    p.sps.num_ref_frames_in_pic_order_cnt_cycle      = 0; /* Unknown */
+    p.sps.max_num_ref_frames                         = pPicParams->num_ref_frames;
+    p.sps.reserved1                                  = 0;
+    p.sps.pic_width_in_mbs_minus1                    = pPicParams->wFrameWidthInMbsMinus1;
+    p.sps.pic_height_in_map_units_minus1             = pPicParams->wFrameHeightInMbsMinus1; /// @todo Is it?
+    p.sps.frame_crop_left_offset                     = 0; /* not used */
+    p.sps.frame_crop_right_offset                    = 0; /* not used */
+    p.sps.frame_crop_top_offset                      = 0; /* not used */
+    p.sps.frame_crop_bottom_offset                   = 0; /* not used */
+    p.sps.reserved2                                  = 0;
+    p.sps.pOffsetForRefFrame                         = nullptr; /* &p.spsOffsetForRefFrame, updated by dxvk decoder. */
+    p.sps.pScalingLists                              = nullptr; /* not used */
+    p.sps.pSequenceParameterSetVui                   = nullptr; /* not used */
+    p.spsOffsetForRefFrame                           = 0; /// @todo Is it?
+
+    p.pps.flags.transform_8x8_mode_flag                = pPicParams->transform_8x8_mode_flag;
+    p.pps.flags.redundant_pic_cnt_present_flag         = pPicParams->ContinuationFlag
+                                                          ? (pPicParams->redundant_pic_cnt_present_flag ? 1 : 0)
+                                                          : 0;
+    p.pps.flags.constrained_intra_pred_flag            = pPicParams->constrained_intra_pred_flag ? 1 : 0;
+    p.pps.flags.deblocking_filter_control_present_flag = pPicParams->deblocking_filter_control_present_flag ? 1 : 0;
+    p.pps.flags.weighted_pred_flag                     = pPicParams->weighted_pred_flag ? 1 : 0;
+    p.pps.flags.bottom_field_pic_order_in_frame_present_flag = pPicParams->ContinuationFlag
+                                                                ? (pPicParams->pic_order_present_flag ? 1 : 0)
+                                                                : 0;
+    p.pps.flags.entropy_coding_mode_flag               = pPicParams->ContinuationFlag
+                                                          ? (pPicParams->entropy_coding_mode_flag ? 1 : 0)
+                                                          : 0;
+    p.pps.flags.pic_scaling_matrix_present_flag        = pQmatrix != nullptr ? 1 : 0;
+    p.pps.seq_parameter_set_id                         = 0; /* Unknown, will be inferred by the Dxvk decoder. */
+    p.pps.pic_parameter_set_id                         = 0; /* Unknown, will be inferred by the Dxvk decoder. */
+    p.pps.num_ref_idx_l0_default_active_minus1         = pPicParams->ContinuationFlag
+                                                          ? pPicParams->num_ref_idx_l0_active_minus1
+                                                          : 0;
+    p.pps.num_ref_idx_l1_default_active_minus1         = pPicParams->ContinuationFlag
+                                                          ? pPicParams->num_ref_idx_l1_active_minus1
+                                                          : 0;
+    p.pps.weighted_bipred_idc                          = StdVideoH264WeightedBipredIdc(pPicParams->weighted_bipred_idc);
+    p.pps.pic_init_qp_minus26                          = pPicParams->ContinuationFlag
+                                                          ? pPicParams->pic_init_qp_minus26
+                                                          : 0;
+    p.pps.pic_init_qs_minus26                          = pPicParams->pic_init_qs_minus26;
+    p.pps.chroma_qp_index_offset                       = pPicParams->chroma_qp_index_offset;
+    p.pps.second_chroma_qp_index_offset                = pPicParams->second_chroma_qp_index_offset;
+    p.pps.pScalingLists                                = nullptr; /* &p.ppsScalingLists, updated by dxvk decoder. */
+
+    if (p.pps.flags.pic_scaling_matrix_present_flag) {
+      p.ppsScalingLists.scaling_list_present_mask        = 0xFF; /* 6x 4x4 and 2x 8x8 = 8 bits total */
+      p.ppsScalingLists.use_default_scaling_matrix_mask  = 0;
+      memcpy(p.ppsScalingLists.ScalingList4x4, pQmatrix->bScalingLists4x4, sizeof(pQmatrix->bScalingLists4x4));
+      memcpy(p.ppsScalingLists.ScalingList8x8, pQmatrix->bScalingLists8x8, sizeof(pQmatrix->bScalingLists8x8));
+    }
+
+    /* Fetch slice offsets. */
+    bool fSuccess = m_config.ConfigBitstreamRaw == 2
+      ? GetSliceOffsetsAndNALType<DXVA_Slice_H264_Short>(&p, pSliceDesc, pSlices, pBitStream, pBitStreamDesc->DataSize)
+      : GetSliceOffsetsAndNALType<DXVA_Slice_H264_Long>(&p, pSliceDesc, pSlices, pBitStream, pBitStreamDesc->DataSize);
+    if (!fSuccess)
+      return false;
+
+    /// @todo Avoid intermediate buffer. Directly copy to a DxvkBuffer?
+    p.bitstreamLength = pBitStreamDesc->DataSize;
+    p.bitstream.resize(p.bitstreamLength);
+    memcpy(p.bitstream.data(), pBitStream, p.bitstream.size());
+
+    p.stdH264PictureInfo.flags.field_pic_flag           = pPicParams->field_pic_flag;
+    p.stdH264PictureInfo.flags.is_intra                 = pPicParams->IntraPicFlag;
+    p.stdH264PictureInfo.flags.IdrPicFlag               = p.nal_unit_type == 5 ? 1 : 0; 
+    p.stdH264PictureInfo.flags.bottom_field_flag        = pPicParams->CurrPic.AssociatedFlag; /* flag is bottom field flag */
+    p.stdH264PictureInfo.flags.is_reference             = pPicParams->RefPicFlag;
+    p.stdH264PictureInfo.flags.complementary_field_pair = 0; /// @todo unknown
+    p.stdH264PictureInfo.seq_parameter_set_id           = 0; /* Unknown, will be inferred by the Dxvk decoder. */
+    p.stdH264PictureInfo.pic_parameter_set_id           = 0; /* Unknown, will be inferred by the Dxvk decoder. */
+    p.stdH264PictureInfo.reserved1                      = 0;
+    p.stdH264PictureInfo.reserved2                      = 0;
+    p.stdH264PictureInfo.frame_num                      = pPicParams->frame_num;
+    p.stdH264PictureInfo.idr_pic_id                     = 0; /// @todo unknown
+    p.stdH264PictureInfo.PicOrderCnt[0]                 = pPicParams->CurrFieldOrderCnt[0]; /// @todo Is it?
+    p.stdH264PictureInfo.PicOrderCnt[1]                 = pPicParams->CurrFieldOrderCnt[1];
+
+    p.stdH264ReferenceInfo.flags.top_field_flag         =
+      (p.stdH264PictureInfo.flags.field_pic_flag && !p.stdH264PictureInfo.flags.bottom_field_flag) ? 1 : 0;
+    p.stdH264ReferenceInfo.flags.bottom_field_flag      =
+      (p.stdH264PictureInfo.flags.field_pic_flag && p.stdH264PictureInfo.flags.bottom_field_flag) ? 1 : 0;
+    p.stdH264ReferenceInfo.flags.used_for_long_term_reference = 0; /// @todo
+    p.stdH264ReferenceInfo.flags.is_non_existing        = 0;
+    p.stdH264ReferenceInfo.FrameNum                     = pPicParams->frame_num;
+    p.stdH264ReferenceInfo.reserved                     = 0;
+    p.stdH264ReferenceInfo.PicOrderCnt[0]               = pPicParams->CurrFieldOrderCnt[0]; /// @todo Is it?
+    p.stdH264ReferenceInfo.PicOrderCnt[1]               = pPicParams->CurrFieldOrderCnt[1];
+
+    return true;
+  }
+
+
+
+
+  D3D11VideoDecoderOutputView::D3D11VideoDecoderOutputView(
+          D3D11Device*            pDevice,
+          ID3D11Resource*         pResource,
+    const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC& Desc)
+  : D3D11DeviceChild<ID3D11VideoDecoderOutputView>(pDevice),
+    m_resource(pResource), m_desc(Desc) {
+    /* Desc.DecodeProfile and resource format has been verified by the caller (Device). */
+    D3D11_COMMON_RESOURCE_DESC resourceDesc = { };
+    GetCommonResourceDesc(pResource, &resourceDesc);
+
+    DXGI_VK_FORMAT_INFO formatInfo = pDevice->LookupFormat(
+      resourceDesc.Format, DXGI_VK_FORMAT_MODE_COLOR);
+
+    /* In principle it is possible to use this view as video decode output if the Vulkan implementation
+     * supports VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR capability. In this case
+     * the image must be either created with VkVideoProfileListInfoKHR it its pNext chain or with
+     * VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR flag (if VK_KHR_VIDEO_MAINTENANCE_1 is supported,
+     * which is not always the case).
+     *
+     * However the video profile is not known at D3D11_BIND_DECODER texture creation time.
+     * D3D11 provides this information only when creating a VideoDecoderOutputView.
+     *
+     * Therefore the video decoder output view image is created without the video profile and
+     * the dxvk decoder will copy decoded picture to it.
+     *
+     * If Vulkan implementation supports VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR
+     * then the decoded picture has to be copied to the output image anyway.
+     *
+     * Otherwise the dxvk video decoder will use an internal output image and will copy it to
+     * the video decoder output view.
+     *
+     * In either case the D3D11 video decoder output view is only used as a transfer destination.
+     */
+    Rc<DxvkImage> dxvkImage = GetCommonTexture(pResource)->GetImage();
+
+    DxvkImageViewCreateInfo viewInfo;
+    viewInfo.format  = formatInfo.Format;
+    viewInfo.aspect  = VK_IMAGE_ASPECT_COLOR_BIT;
+    viewInfo.swizzle = formatInfo.Swizzle;
+    viewInfo.usage   = dxvkImage->info().usage & ~VK_IMAGE_USAGE_SAMPLED_BIT;
+
+    switch (m_desc.ViewDimension) {
+      case D3D11_VDOV_DIMENSION_TEXTURE2D:
+        if (m_desc.Texture2D.ArraySlice >= dxvkImage->info().numLayers)
+          throw DxvkError(str::format("Invalid video decoder output view ArraySlice ", m_desc.Texture2D.ArraySlice));
+
+        viewInfo.type       = VK_IMAGE_VIEW_TYPE_2D;
+        viewInfo.minLevel   = 0;
+        viewInfo.numLevels  = 1;
+        viewInfo.minLayer   = m_desc.Texture2D.ArraySlice;
+        viewInfo.numLayers  = 1;
+        break;
+
+      case D3D11_VDOV_DIMENSION_UNKNOWN:
+      default:
+        throw DxvkError("Invalid view dimension");
+    }
+
+    m_view = pDevice->GetDXVKDevice()->createImageView(
+      dxvkImage, viewInfo);
+  }
+
+
+  D3D11VideoDecoderOutputView::~D3D11VideoDecoderOutputView() {
+
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoDecoderOutputView::QueryInterface(
+          REFIID                  riid,
+          void**                  ppvObject) {
+    if (riid == __uuidof(IUnknown)
+     || riid == __uuidof(ID3D11DeviceChild)
+     || riid == __uuidof(ID3D11View)
+     || riid == __uuidof(ID3D11VideoDecoderOutputView)) {
+      *ppvObject = ref(this);
+      return S_OK;
+    }
+
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoDecoderOutputView), riid)) {
+      Logger::warn("D3D11VideoDecoderOutputView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
+    return E_NOINTERFACE;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoDecoderOutputView::GetResource(
+          ID3D11Resource**        ppResource) {
+    *ppResource = m_resource.ref();
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoDecoderOutputView::GetDesc(
+          D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc) {
+    *pDesc = m_desc;
+  }
+#endif
+
+
+
 
   D3D11VideoProcessorEnumerator::D3D11VideoProcessorEnumerator(
@@ -201 +669 @@
         viewInfo.minLevel   = m_desc.Texture2D.MipSlice;
         viewInfo.numLevels  = 1;
+#ifdef VBOX_WITH_DXVK_VIDEO
+        viewInfo.minLayer   = m_desc.Texture2D.ArraySlice;
+#else
         viewInfo.minLayer   = 0;
+#endif
         viewInfo.numLayers  = 1;
         break;
@@ -422 +894 @@
           UINT*                           BufferSize,
           void**                          ppBuffer) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    auto videoDecoder = static_cast<D3D11VideoDecoder*>(pDecoder);
+    return videoDecoder->GetDecoderBuffer(Type, BufferSize, ppBuffer);
+#else
     Logger::err("D3D11VideoContext::GetDecoderBuffer: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -430 +907 @@
           ID3D11VideoDecoder*             pDecoder,
           D3D11_VIDEO_DECODER_BUFFER_TYPE Type) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    auto videoDecoder = static_cast<D3D11VideoDecoder*>(pDecoder);
+    return videoDecoder->ReleaseDecoderBuffer(Type);
+#else
     Logger::err("D3D11VideoContext::ReleaseDecoderBuffer: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -439 +921 @@
           UINT                            KeySize,
     const void*                           pKey) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    auto videoDecoder = static_cast<D3D11VideoDecoder*>(pDecoder);
+    auto dxvkDecoder = videoDecoder->GetDecoder();
+    auto dxvkView = static_cast<D3D11VideoDecoderOutputView*>(pView)->GetView();
+
+    m_ctx->EmitCs([
+      cDecoder = dxvkDecoder,
+      cView = dxvkView
+    ] (DxvkContext* ctx) {
+      cDecoder->BeginFrame(ctx, cView);
+    });
+    return S_OK;
+#else
     Logger::err("D3D11VideoContext::DecoderBeginFrame: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -446 +942 @@
   HRESULT STDMETHODCALLTYPE D3D11VideoContext::DecoderEndFrame(
           ID3D11VideoDecoder*             pDecoder) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    auto videoDecoder = static_cast<D3D11VideoDecoder*>(pDecoder);
+    auto dxvkDecoder = videoDecoder->GetDecoder();
+
+    m_ctx->EmitCs([
+      cDecoder = dxvkDecoder
+    ] (DxvkContext* ctx) {
+      cDecoder->EndFrame(ctx);
+    });
+    return S_OK;
+#else
     Logger::err("D3D11VideoContext::DecoderEndFrame: Stub");
     return E_NOTIMPL;
+#endif
   }
 
@@ -455 +963 @@
           UINT                            BufferCount,
     const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDescs) {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    auto videoDecoder = static_cast<D3D11VideoDecoder*>(pDecoder);
+    auto dxvkDecoder = videoDecoder->GetDecoder();
+
+    DxvkVideoDecodeInputParameters parms;
+    if (!videoDecoder->GetVideoDecodeH264InputParameters(BufferCount, pBufferDescs, &parms))
+       return E_INVALIDARG;
+
+    m_ctx->EmitCs([
+      cDecoder = dxvkDecoder,
+      cParms = parms
+    ] (DxvkContext* ctx) {
+      cDecoder->Decode(ctx, cParms);
+    });
+
+    return S_OK;
+#else
     Logger::err("D3D11VideoContext::SubmitDecoderBuffers: Stub");
     return E_NOTIMPL;
+#endif
   }
 

trunk/src/libs/dxvk-2.3.1/src/d3d11/d3d11_video.h

@@ -1 +1 @@
 #pragma once
 
+#include "../dxvk/dxvk_video_decoder.h"
+
 #include "d3d11_device.h"
 
 namespace dxvk {
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+
+  class D3D11VideoDecoder : public D3D11DeviceChild<ID3D11VideoDecoder> {
+
+  public:
+
+    D3D11VideoDecoder(
+            D3D11Device*                      pDevice,
+            const D3D11_VIDEO_DECODER_DESC    &VideoDesc,
+            const D3D11_VIDEO_DECODER_CONFIG  &Config,
+            const DxvkVideoDecodeProfileInfo& profile);
+
+    ~D3D11VideoDecoder();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    virtual HRESULT STDMETHODCALLTYPE GetCreationParameters(
+            D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+            D3D11_VIDEO_DECODER_CONFIG *pConfig);
+
+    virtual HRESULT STDMETHODCALLTYPE GetDriverHandle(
+            HANDLE *pDriverHandle);
+
+    HRESULT GetDecoderBuffer(
+            D3D11_VIDEO_DECODER_BUFFER_TYPE Type,
+            UINT*                           BufferSize,
+            void**                          ppBuffer);
+
+    HRESULT ReleaseDecoderBuffer(
+            D3D11_VIDEO_DECODER_BUFFER_TYPE Type);
+
+    Rc<DxvkVideoDecoder> GetDecoder() {
+      return m_videoDecoder;
+    }
+
+    bool GetVideoDecodeH264InputParameters(
+      UINT BufferCount,
+      const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDescs,
+      DxvkVideoDecodeInputParameters *pParms);
+
+  private:
+
+    struct D3D11VideoDecoderBuffer {
+      std::vector<uint8_t> buffer;
+    };
+
+    D3D11_VIDEO_DECODER_DESC                    m_desc;
+    D3D11_VIDEO_DECODER_CONFIG                  m_config;
+
+    /* All buffer types except for D3D11_VIDEO_DECODER_BUFFER_HUFFMAN_TABLE. */
+    std::array<D3D11VideoDecoderBuffer, D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN + 1> m_decoderBuffers;
+    Rc<DxvkDevice>                              m_device;
+    Rc<DxvkVideoDecoder>                        m_videoDecoder;
+
+  };
+
+
+  class D3D11VideoDecoderOutputView : public D3D11DeviceChild<ID3D11VideoDecoderOutputView> {
+
+  public:
+
+    D3D11VideoDecoderOutputView(
+            D3D11Device*            pDevice,
+            ID3D11Resource*         pResource,
+      const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC& Desc);
+
+    ~D3D11VideoDecoderOutputView();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    void STDMETHODCALLTYPE GetResource(
+            ID3D11Resource**        ppResource);
+
+    void STDMETHODCALLTYPE GetDesc(
+            D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc);
+
+    Rc<DxvkImageView> GetView() const {
+      return m_view;
+    }
+
+  private:
+
+    Com<ID3D11Resource>                     m_resource;
+    D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC    m_desc;
+    Rc<DxvkImageView>                       m_view;
+
+  };
+#endif /* VBOX_WITH_DXVK_VIDEO */
 
   static constexpr uint32_t D3D11_VK_VIDEO_STREAM_COUNT = 8;

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_adapter.cpp

@@ -159 +159 @@
     }
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    uint32_t videoDecodeQueue = findQueueFamily(
+      VK_QUEUE_VIDEO_DECODE_BIT_KHR,
+      VK_QUEUE_VIDEO_DECODE_BIT_KHR);
+#endif
+
     DxvkAdapterQueueIndices queues;
     queues.graphics = graphicsQueue;
     queues.transfer = transferQueue;
     queues.sparse = sparseQueue;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    queues.videoDecode = videoDecodeQueue;
+#endif
     return queues;
   }
@@ -470 +479 @@
       queueFamiliySet.insert(queueFamilies.sparse);
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (queueFamilies.videoDecode != VK_QUEUE_FAMILY_IGNORED)
+      queueFamiliySet.insert(queueFamilies.videoDecode);
+#endif
+
     this->logQueueFamilies(queueFamilies);
     
@@ -520 +534 @@
     queues.transfer = getDeviceQueue(vkd, queueFamilies.transfer, 0);
     queues.sparse = getDeviceQueue(vkd, queueFamilies.sparse, 0);
+#ifdef VBOX_WITH_DXVK_VIDEO
+    queues.videoDecode = getDeviceQueue(vkd, queueFamilies.videoDecode, 0);
+#endif
 
     return new DxvkDevice(instance, this, vkd, enabledFeatures, queues, DxvkQueueCallback());
@@ -719 +736 @@
       }
     }
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    for (uint32_t i = 0; i < m_queueFamilies.size(); ++i) {
+      Logger::info(str::format("  Queue[", i, "]: Flags = 0x", std::hex, m_queueFamilies[i].queueFlags, std::dec));
+    }
+#endif
   }
   
@@ -964 +987 @@
     if (m_deviceExtensions.supports(VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME))
       m_deviceFeatures.nvxImageViewHandle = VK_TRUE;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_deviceExtensions.supports(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME))
+      m_deviceFeatures.khrVideoDecodeQueue = VK_TRUE;
+#endif
 
     m_vki->vkGetPhysicalDeviceFeatures2(m_handle, &m_deviceFeatures.core);
@@ -1029 +1057 @@
       &devExtensions.nvxBinaryImport,
       &devExtensions.nvxImageViewHandle,
+#ifdef VBOX_WITH_DXVK_VIDEO
+      &devExtensions.khrVideoQueue,
+      &devExtensions.khrVideoDecodeQueue,
+      &devExtensions.khrVideoDecodeH264,
+#endif
     }};
   }
@@ -1179 +1212 @@
     if (devExtensions.khrWin32KeyedMutex)
       enabledFeatures.khrWin32KeyedMutex = VK_TRUE;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (devExtensions.khrVideoDecodeQueue)
+      enabledFeatures.khrVideoDecodeQueue = VK_TRUE;
+#endif
   }
 
@@ -1331 +1369 @@
       "\n", VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME,
       "\n  extension supported                    : ", features.khrWin32KeyedMutex ? "1" : "0"));
+#ifdef VBOX_WITH_DXVK_VIDEO
+    Logger::info(str::format(
+      "",  VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME,
+      "\n  extension supported                    : ", features.khrVideoDecodeQueue ? "1" : "0"));
+#endif
   }
 
@@ -1338 +1381 @@
       "\n  Graphics : ", queues.graphics,
       "\n  Transfer : ", queues.transfer,
+#ifdef VBOX_WITH_DXVK_VIDEO
+      "\n  Sparse   : ", queues.sparse != VK_QUEUE_FAMILY_IGNORED ? str::format(queues.sparse) : "n/a",
+      "\n  VideoDec : ", queues.videoDecode != VK_QUEUE_FAMILY_IGNORED ? str::format(queues.videoDecode) : "n/a"));
+#else
       "\n  Sparse   : ", queues.sparse != VK_QUEUE_FAMILY_IGNORED ? str::format(queues.sparse) : "n/a"));
+#endif
   }
   

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_adapter.h

@@ -57 +57 @@
     uint32_t transfer;
     uint32_t sparse;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    uint32_t videoDecode;
+#endif
   };
   
@@ -303 +306 @@
     }
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VkQueueFlags getQueueFlags(uint32_t  queueFamily) {
+      if (queueFamily < m_queueFamilies.size())
+        return m_queueFamilies[queueFamily].queueFlags;
+      return 0;
+    }
+#endif
+
   private:
     

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_buffer.cpp

@@ -98 +98 @@
   DxvkBufferHandle DxvkBuffer::allocBuffer(VkDeviceSize sliceCount, bool clear) const {
     VkBufferCreateInfo info = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+#ifdef VBOX_WITH_DXVK_VIDEO
+    info.pNext = m_info.pNext;
+#endif
     info.flags = m_info.flags;
     info.size = m_physSliceStride * sliceCount;

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_buffer.h

@@ -35 +35 @@
     /// Allowed access patterns
     VkAccessFlags access;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    /// VkBufferCreateInfo::pNext
+    void* pNext = nullptr;
+#endif
   };
   

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_cmdlist.cpp

@@ -174 +174 @@
     const auto& graphicsQueue = m_device->queues().graphics;
     const auto& transferQueue = m_device->queues().transfer;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const auto& videoDecodeQueue = m_device->queues().videoDecode;
+#endif
 
     VkSemaphoreCreateInfo semaphoreInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
@@ -182 +185 @@
       throw DxvkError("DxvkCommandList: Failed to create semaphore");
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VkSemaphoreTypeCreateInfo typeInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO };
+    typeInfo.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
+    typeInfo.initialValue = m_vdecSemaphoreValue;
+
+    semaphoreInfo.pNext = &typeInfo;
+
+    if (m_vkd->vkCreateSemaphore(m_vkd->device(), &semaphoreInfo, nullptr, &m_vdecSemaphore))
+      throw DxvkError("DxvkCommandList: Failed to create video decode timeline semaphore");
+#endif
+
     VkFenceCreateInfo fenceInfo = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
 
@@ -193 +207 @@
     else
       m_transferPool = m_graphicsPool;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (videoDecodeQueue.queueFamily != VK_QUEUE_FAMILY_IGNORED)
+      m_videoDecodePool = new DxvkCommandPool(device, videoDecodeQueue.queueFamily);
+#endif
   }
   
@@ -202 +221 @@
     m_vkd->vkDestroySemaphore(m_vkd->device(), m_postSemaphore, nullptr);
     m_vkd->vkDestroySemaphore(m_vkd->device(), m_sdmaSemaphore, nullptr);
+#ifdef VBOX_WITH_DXVK_VIDEO
+    m_vkd->vkDestroySemaphore(m_vkd->device(), m_vdecSemaphore, nullptr);
+#endif
 
     m_vkd->vkDestroyFence(m_vkd->device(), m_fence, nullptr);
@@ -207 +229 @@
   
   
+#ifdef VBOX_WITH_DXVK_VIDEO
+  void DxvkCommandList::addSubmissionFences(
+    DxvkCmdBuffer cmdBuffer,
+    const DxvkCommandSubmissionInfo& cmd) {
+    for (const auto& entry : cmd.submissionFences) {
+      if (entry.cmdBuffer == cmdBuffer) {
+        if (entry.op == DxvkFenceOp::FenceOpWait) {
+          m_commandSubmission.waitSemaphore(entry.fence.fence->handle(),
+            entry.fence.value, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT);
+        }
+        else if (entry.op == DxvkFenceOp::FenceOpSignal) {
+          m_commandSubmission.signalSemaphore(entry.fence.fence->handle(),
+            entry.fence.value, VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT);
+        }
+      }
+    }
+  }
+#endif
+
+
   VkResult DxvkCommandList::submit() {
     VkResult status = VK_SUCCESS;
@@ -213 +255 @@
     const auto& transfer = m_device->queues().transfer;
     const auto& sparse = m_device->queues().sparse;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    const auto& videoDecode = m_device->queues().videoDecode;
+#endif
 
     m_commandSubmission.reset();
@@ -274 +319 @@
 
       // Submit graphics commands
+#ifdef VBOX_WITH_DXVK_VIDEO
+      if (cmd.usedFlags.test(DxvkCmdBuffer::InitBuffer)) {
+        addSubmissionFences(DxvkCmdBuffer::InitBuffer, cmd);
+        m_commandSubmission.executeCommandBuffer(cmd.initBuffer);
+      }
+#else
       if (cmd.usedFlags.test(DxvkCmdBuffer::InitBuffer))
         m_commandSubmission.executeCommandBuffer(cmd.initBuffer);
+#endif
 
       if (cmd.usedFlags.test(DxvkCmdBuffer::ExecBuffer))
@@ -300 +352 @@
       if ((status = m_commandSubmission.submit(m_device, graphics.queueHandle)))
         return status;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+      if (videoDecode.queueFamily != VK_QUEUE_FAMILY_IGNORED) {
+        // Submit video decode commands as necessary
+
+        // Always signal the vdec command buffer completion. synchronizeFence waits for it.
+        m_commandSubmission.signalSemaphore(m_vdecSemaphore, ++m_vdecSemaphoreValue, VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT);
+
+        if (cmd.usedFlags.test(DxvkCmdBuffer::VDecBuffer)) {
+          addSubmissionFences(DxvkCmdBuffer::VDecBuffer, cmd);
+          m_commandSubmission.executeCommandBuffer(cmd.vdecBuffer);
+        }
+
+        // Submit all video decode commands of the current submission
+        if ((status = m_commandSubmission.submit(m_device, videoDecode.queueHandle)))
+          return status;
+      }
+#endif
     }
 
@@ -313 +383 @@
     m_cmd.initBuffer = m_graphicsPool->getCommandBuffer();
     m_cmd.sdmaBuffer = m_transferPool->getCommandBuffer();
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_videoDecodePool.ptr() != nullptr)
+      m_cmd.vdecBuffer = m_videoDecodePool->getCommandBuffer();
+#endif
   }
   
@@ -325 +399 @@
     this->endCommandBuffer(m_cmd.initBuffer);
     this->endCommandBuffer(m_cmd.sdmaBuffer);
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_videoDecodePool.ptr() != nullptr)
+      this->endCommandBuffer(m_cmd.vdecBuffer);
+#endif
 
     // Reset all command buffer handles
@@ -355 +433 @@
     }
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_videoDecodePool.ptr() != nullptr) {
+      if (m_cmd.usedFlags.test(DxvkCmdBuffer::VDecBuffer)) {
+        this->endCommandBuffer(m_cmd.vdecBuffer);
+        m_cmd.vdecBuffer = m_videoDecodePool->getCommandBuffer();
+      }
+    }
+
+    m_cmd.submissionFences.clear();
+#endif
+
     m_cmd.usedFlags = 0;
   }
@@ -360 +449 @@
   
   VkResult DxvkCommandList::synchronizeFence() {
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_device->queues().videoDecode.queueFamily != VK_QUEUE_FAMILY_IGNORED) {
+      /* Wait for completion of vdec buffer */
+      const uint64_t waitValue = m_vdecSemaphoreValue;
+
+      VkSemaphoreWaitInfo waitInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO };
+      // waitInfo.flags = 0;
+      waitInfo.semaphoreCount = 1;
+      waitInfo.pSemaphores = &m_vdecSemaphore;
+      waitInfo.pValues = &waitValue;
+
+      m_vkd->vkWaitSemaphores(m_vkd->device(), &waitInfo, ~0ull);
+    }
+#endif
+
     return m_vkd->vkWaitForFences(m_vkd->device(), 1, &m_fence, VK_TRUE, ~0ull);
   }
@@ -403 +507 @@
     m_graphicsPool->reset();
     m_transferPool->reset();
+#ifdef VBOX_WITH_DXVK_VIDEO
+    if (m_videoDecodePool.ptr() != nullptr)
+      m_videoDecodePool->reset();
+#endif
 
     // Reset fence

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_cmdlist.h

@@ -31 +31 @@
     ExecBuffer = 1,
     SdmaBuffer = 2,
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VDecBuffer = 3,
+#endif
   };
   
@@ -119 +122 @@
   };
 
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+  enum class DxvkFenceOp : uint32_t {
+    FenceOpWait = 0,
+    FenceOpSignal = 1,
+  };
+
+  struct DxvkCommandSubmissionFence {
+    DxvkFenceOp         op;          /* Do this op, */
+    DxvkFenceValuePair  fence;       /* for this fence (timeline semaphore in fact), */
+    DxvkCmdBuffer       cmdBuffer;   /* when submitting a command buffer of this type. */
+  };
+#endif
 
   /**
@@ -131 +147 @@
     VkCommandBuffer     initBuffer  = VK_NULL_HANDLE;
     VkCommandBuffer     sdmaBuffer  = VK_NULL_HANDLE;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VkCommandBuffer     vdecBuffer  = VK_NULL_HANDLE;
+#endif
     VkBool32            sparseBind  = VK_FALSE;
     uint32_t            sparseCmd   = 0;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    std::vector<DxvkCommandSubmissionFence> submissionFences;
+#endif
   };
 
@@ -999 +1021 @@
 
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    void cmdBeginVideoCodingKHR(
+            VkVideoBeginCodingInfoKHR *videoBeginCodingInfo) {
+      m_cmd.usedFlags.set(DxvkCmdBuffer::VDecBuffer);
+
+      m_vkd->vkCmdBeginVideoCodingKHR(m_cmd.vdecBuffer, videoBeginCodingInfo);
+    }
+
+    void cmdControlVideoCodingKHR(
+            VkVideoCodingControlInfoKHR *videoCodingControlInfo) {
+      m_cmd.usedFlags.set(DxvkCmdBuffer::VDecBuffer);
+
+      m_vkd->vkCmdControlVideoCodingKHR(m_cmd.vdecBuffer, videoCodingControlInfo);
+    }
+
+    void cmdDecodeVideoKHR(
+            VkVideoDecodeInfoKHR *videoDecodeInfo) {
+      m_cmd.usedFlags.set(DxvkCmdBuffer::VDecBuffer);
+
+      m_vkd->vkCmdDecodeVideoKHR(m_cmd.vdecBuffer, videoDecodeInfo);
+    }
+
+    void cmdEndVideoCodingKHR(
+            VkVideoEndCodingInfoKHR *videoEndCodingInfo) {
+      m_cmd.usedFlags.set(DxvkCmdBuffer::VDecBuffer);
+
+      m_vkd->vkCmdEndVideoCodingKHR(m_cmd.vdecBuffer, videoEndCodingInfo);
+    }
+
+    void waitSubmissionFence(DxvkCmdBuffer cmdBuffer, Rc<DxvkFence> fence, uint64_t value) {
+      m_cmd.submissionFences.emplace_back(
+        DxvkCommandSubmissionFence {DxvkFenceOp::FenceOpWait, {std::move(fence), value}, cmdBuffer });
+    }
+
+    void signalSubmissionFence(DxvkCmdBuffer cmdBuffer, Rc<DxvkFence> fence, uint64_t value) {
+      m_cmd.submissionFences.emplace_back(
+        DxvkCommandSubmissionFence {DxvkFenceOp::FenceOpSignal, {std::move(fence), value}, cmdBuffer });
+    }
+#endif
+
+
     void bindBufferMemory(
       const DxvkSparseBufferBindKey& key,
@@ -1035 +1098 @@
     Rc<DxvkCommandPool>       m_graphicsPool;
     Rc<DxvkCommandPool>       m_transferPool;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    Rc<DxvkCommandPool>       m_videoDecodePool;
+#endif
 
     VkSemaphore               m_bindSemaphore = VK_NULL_HANDLE;
     VkSemaphore               m_postSemaphore = VK_NULL_HANDLE;
     VkSemaphore               m_sdmaSemaphore = VK_NULL_HANDLE;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VkSemaphore               m_vdecSemaphore = VK_NULL_HANDLE;
+    std::atomic<uint64_t>     m_vdecSemaphoreValue = 0;
+#endif
     VkFence                   m_fence         = VK_NULL_HANDLE;
 
@@ -1070 +1140 @@
       if (cmdBuffer == DxvkCmdBuffer::InitBuffer) return m_cmd.initBuffer;
       if (cmdBuffer == DxvkCmdBuffer::SdmaBuffer) return m_cmd.sdmaBuffer;
+#ifdef VBOX_WITH_DXVK_VIDEO
+      if (cmdBuffer == DxvkCmdBuffer::VDecBuffer) return m_cmd.vdecBuffer;
+#endif
       return VK_NULL_HANDLE;
     }
@@ -1085 +1158 @@
     void endCommandBuffer(VkCommandBuffer cmdBuffer);
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    void addSubmissionFences(
+      DxvkCmdBuffer cmdBuffer,
+      const DxvkCommandSubmissionInfo& cmd);
+#endif
   };
   

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_context.h

@@ -856 +856 @@
             uint32_t          counterBias);
     
+#ifdef VBOX_WITH_DXVK_VIDEO
+    /**
+     * \brief Begin a video coding scope.
+
+     * \param [in] videoBeginCodingInfo Parameters of the video coding scope
+     */
+    void beginVideoCodingKHR(
+            VkVideoBeginCodingInfoKHR *videoBeginCodingInfo) {
+      m_cmd->cmdBeginVideoCodingKHR(
+        videoBeginCodingInfo);
+    }
+
+    /**
+     * \brief Control video coding parameters.
+
+     * \param [in] videoDecodeInfo Control parameters
+     */
+    void controlVideoCodingKHR(
+            VkVideoCodingControlInfoKHR *videoCodingControlInfo) {
+      m_cmd->cmdControlVideoCodingKHR(
+        videoCodingControlInfo);
+    }
+
+    /**
+     * \brief Decode video data.
+
+     * \param [in] videoDecodeInfo Video decoder input data
+     */
+    void decodeVideoKHR(
+            VkVideoDecodeInfoKHR *videoDecodeInfo) {
+      m_cmd->cmdDecodeVideoKHR(
+        videoDecodeInfo);
+    }
+
+    /**
+     * \brief End a video coding scope.
+
+     * \param [in] videoEndCodingInfo Parameters for ending the video coding scope
+     */
+    void endVideoCodingKHR(
+            VkVideoEndCodingInfoKHR *videoEndCodingInfo) {
+      m_cmd->cmdEndVideoCodingKHR(
+        videoEndCodingInfo);
+    }
+
+    void emitPipelineBarrier(
+            DxvkCmdBuffer           cmdBuffer,
+      const VkDependencyInfo*       dependencyInfo) {
+      m_cmd->cmdPipelineBarrier(cmdBuffer, dependencyInfo);
+    }
+
+    void emitCopyImage(
+            DxvkCmdBuffer           cmdBuffer,
+      const VkCopyImageInfo2*       copyInfo) {
+      m_cmd->cmdCopyImage(cmdBuffer, copyInfo);
+    }
+
+    void transferImageQueueOwnership(
+            DxvkCmdBuffer           srcCmdBuffer,
+      const VkImageMemoryBarrier2*  srcBarrier,
+            DxvkCmdBuffer           dstCmdBuffer,
+      const VkImageMemoryBarrier2*  dstBarrier,
+      const Rc<DxvkFence>&          fence,
+            uint64_t                value) {
+      // Submit 'release=src' barrier.
+      VkDependencyInfo dependencyInfo =
+        { VK_STRUCTURE_TYPE_DEPENDENCY_INFO };
+      dependencyInfo.imageMemoryBarrierCount = 1;
+      dependencyInfo.pImageMemoryBarriers    = srcBarrier;
+
+      m_cmd->cmdPipelineBarrier(srcCmdBuffer, &dependencyInfo);
+      m_cmd->signalSubmissionFence(srcCmdBuffer, fence, value);
+
+      // Split command buffers so that we submit barriers in the right order.
+      // That is the release barrier is submitted to the source queue before
+      // the acquire barrier is submitted to the destination queue.
+      splitCommands();
+
+      // Submit 'acquire=dst' barrier.
+      dependencyInfo.pImageMemoryBarriers    = dstBarrier;
+
+      m_cmd->cmdPipelineBarrier(dstCmdBuffer, &dependencyInfo);
+      m_cmd->waitSubmissionFence(dstCmdBuffer, fence, value);
+    }
+
+    void trackResource(
+            DxvkAccess access,
+      const Rc<DxvkResource>& resource) {
+      if (access == DxvkAccess::Write)
+        m_cmd->trackResource<DxvkAccess::Write>(resource);
+      else if (access == DxvkAccess::Read)
+        m_cmd->trackResource<DxvkAccess::Read>(resource);
+      else
+        m_cmd->trackResource<DxvkAccess::None>(resource);
+    }
+#endif
+
     /**
      * \brief Emits graphics barrier

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_device.cpp

@@ -197 +197 @@
 
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+  Rc<DxvkVideoDecoder> DxvkDevice::createVideoDecoder(
+    const DxvkVideoDecodeProfileInfo& profile,
+          uint32_t sampleWidth,
+          uint32_t sampleHeight,
+          VkFormat outputFormat) {
+    return new DxvkVideoDecoder(this, m_objects.memoryManager(),
+      profile, sampleWidth, sampleHeight, outputFormat);
+  }
+#endif
+
+
   DxvkStatCounters DxvkDevice::getStatCounters() {
     DxvkPipelineCount pipe = m_objects.pipelineManager().getPipelineCount();

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_device.h

@@ -26 +26 @@
 #include "dxvk_unbound.h"
 #include "dxvk_marker.h"
+#ifdef VBOX_WITH_DXVK_VIDEO
+#include "dxvk_video_decoder.h"
+#endif
 
 namespace dxvk {
@@ -66 +69 @@
     DxvkDeviceQueue transfer;
     DxvkDeviceQueue sparse;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    DxvkDeviceQueue videoDecode;
+#endif
   };
   
@@ -361 +367 @@
     Rc<DxvkSparsePageAllocator> createSparsePageAllocator();
 
+#ifdef VBOX_WITH_DXVK_VIDEO
+    /**
+     * \brief Creates a video decoder
+     *
+     * \param [in] profileInfo Vulkan video profile and caps
+     * \param [in] sampleWidth The video frame width
+     * \param [in] sampleHeight The video frame height
+     * \param [in] outputFormat The format of decoded frame
+     * \returns Video decoder
+     */
+    Rc<DxvkVideoDecoder> createVideoDecoder(
+      const DxvkVideoDecodeProfileInfo& profile,
+            uint32_t sampleWidth,
+            uint32_t sampleHeight,
+            VkFormat outputFormat);
+#endif
+
     /**
      * \brief Imports a buffer

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_device_info.h

@@ -73 +73 @@
     VkBool32                                                  nvxImageViewHandle;
     VkBool32                                                  khrWin32KeyedMutex;
+#ifdef VBOX_WITH_DXVK_VIDEO
+    VkBool32                                                  khrVideoDecodeQueue;
+#endif
   };
 

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_extensions.h

@@ -329 +329 @@
     DxvkExt nvxBinaryImport                   = { VK_NVX_BINARY_IMPORT_EXTENSION_NAME,                      DxvkExtMode::Disabled };
     DxvkExt nvxImageViewHandle                = { VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME,                  DxvkExtMode::Disabled };
+#ifdef VBOX_WITH_DXVK_VIDEO
+    DxvkExt khrVideoQueue                     = { VK_KHR_VIDEO_QUEUE_EXTENSION_NAME,                        DxvkExtMode::Optional };
+    DxvkExt khrVideoDecodeQueue               = { VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME,                 DxvkExtMode::Optional };
+    DxvkExt khrVideoDecodeH264                = { VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME,                  DxvkExtMode::Optional };
+#endif
   };
   

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_image.cpp

@@ -21 +21 @@
     // allows some drivers to enable image compression
     VkImageFormatListCreateInfo formatList = { VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO };
+#ifdef VBOX_WITH_DXVK_VIDEO
+    formatList.pNext           = createInfo.pNext;
+#endif
     formatList.viewFormatCount = createInfo.viewFormatCount;
     formatList.pViewFormats    = createInfo.viewFormats;

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_image.h

@@ -70 +70 @@
     // Shared handle info
     DxvkSharedHandleInfo sharing;
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    void* pNext = nullptr;
+#endif
   };
   

trunk/src/libs/dxvk-2.3.1/src/dxvk/dxvk_instance.cpp

@@ -351 +351 @@
     std::stringstream str;
 
+#ifdef VBOX
+    str << "VKValidation: ";
+#endif
+
     if (pCallbackData->pMessageIdName)
       str << pCallbackData->pMessageIdName << ": " << std::endl;

trunk/src/libs/dxvk-2.3.1/src/util/com/com_include.h

@@ -6 +6 @@
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif // __GNUC__
+
+#ifdef VBOX
+#include <iprt/asm.h>
+#endif
 
 #define WIN32_LEAN_AND_MEAN

trunk/src/libs/dxvk-2.3.1/src/vulkan/vulkan_loader.h

@@ -169 +169 @@
     VULKAN_FN(vkReleaseSwapchainImagesEXT);
     #endif
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    #ifdef VK_KHR_video_queue
+    VULKAN_FN(vkGetPhysicalDeviceVideoCapabilitiesKHR);
+    VULKAN_FN(vkGetPhysicalDeviceVideoFormatPropertiesKHR);
+    #endif
+#endif /* VBOX_WITH_DXVK_VIDEO */
   };
   
@@ -453 +460 @@
     VULKAN_FN(wine_vkReleaseKeyedMutex);
     #endif
+
+#ifdef VBOX_WITH_DXVK_VIDEO
+    #ifdef VK_KHR_video_queue
+    VULKAN_FN(vkCreateVideoSessionKHR);
+    VULKAN_FN(vkDestroyVideoSessionKHR);
+    VULKAN_FN(vkGetVideoSessionMemoryRequirementsKHR);
+    VULKAN_FN(vkBindVideoSessionMemoryKHR);
+    VULKAN_FN(vkCreateVideoSessionParametersKHR);
+    VULKAN_FN(vkUpdateVideoSessionParametersKHR);
+    VULKAN_FN(vkDestroyVideoSessionParametersKHR);
+    VULKAN_FN(vkCmdBeginVideoCodingKHR);
+    VULKAN_FN(vkCmdEndVideoCodingKHR);
+    VULKAN_FN(vkCmdControlVideoCodingKHR);
+    #endif
+
+    #ifdef VK_KHR_video_decode_queue
+    VULKAN_FN(vkCmdDecodeVideoKHR);
+    #endif
+#endif /* VBOX_WITH_DXVK_VIDEO */
   };